notebooks/4_postprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data directory\n",
    "data_dir = Path(\"../data\")\n",
    "\n",
    "input_dir = data_dir / \"input\"\n",
    "raw_dir = data_dir / \"raw\"\n",
    "output_dir = data_dir / \"processed\"\n",
    "sample_dir = data_dir / \"samples\"\n",
    "\n",
    "rss_dir = raw_dir / \"rss\"\n",
    "twitter_dir = raw_dir / \"twitter\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load articles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "articles = pd.read_csv(\n",
    "    output_dir / \"articles.csv\",\n",
    "    index_col=\"url_id\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "orig_counts = articles.groupby(\"source\").size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Postprocessing of collected articles\n",
    "\n",
    "Articles are excluded if:\n",
    "\n",
    "- they were not successfully parsed by `newspaper`\n",
    "- they have been published before Mar 1 or after Apr 30 \n",
    "- they are in Spanish\n",
    "- they have been used in previous samples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Successful content parsing\n",
    "\n",
    "Remove articles that were not properly parsed by `newspaper`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set success to False for all articles with parse_errors\n",
    "articles.loc[(articles == \"parse_error\").any(axis=1), \"success\"] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing 39 that were not parsed successfully.\n",
      "Breakdown of reasons: {'404 Client Error': 27, '402 Client Error': 1, 'Timeout': 0, 'Wrong domain': 11, 'Parse error': 6}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "newsmed    20\n",
       "ifls       14\n",
       "popsci      4\n",
       "wired       1\n",
       "Name: source, dtype: int64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = articles[~articles.success]\n",
    "errors = {\n",
    "    \"404 Client Error\": df.error_msg.str.contains(\"404 Client Error\").sum(),\n",
    "    \"402 Client Error\": df.error_msg.str.contains(\"402 Client Error\").sum(),\n",
    "    \"Timeout\": df.error_msg.str.contains(\"Read timed out\").sum(),\n",
    "    \"Wrong domain\": df.error_msg.str.contains(\"wrong domain\").sum(),\n",
    "    \"Parse error\": (articles == \"parse_error\").any(axis=1).sum()\n",
    "}\n",
    "\n",
    "print(f\"Removing {(~articles.success).sum()} that were not parsed successfully.\")\n",
    "print(f\"Breakdown of reasons: {errors}\")\n",
    "\n",
    "articles[~articles.success].source.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "articles = articles[articles.success]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Publication date\n",
    "\n",
    "Only keep articles published Mar 1 - Apr 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert dates to datetime format\n",
    "articles.published = pd.to_datetime(articles.published, utc=True)\n",
    "articles.modified = pd.to_datetime(articles.modified, utc=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing 1645 articles in Spanish\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "popsci       1420\n",
       "newsmed        82\n",
       "ifls           73\n",
       "healthday      29\n",
       "medpage        21\n",
       "guardian       10\n",
       "nyt             8\n",
       "wired           2\n",
       "Name: source, dtype: int64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "good_articles = (articles.published>=\"2021-03-01\")&(articles.published<=\"2021-04-29\")\n",
    "bad_articles = ~good_articles\n",
    "print(f\"Removing {bad_articles.sum()} articles in Spanish\")\n",
    "\n",
    "articles[bad_articles][\"source\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "articles = articles[good_articles]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Language\n",
    "\n",
    "Remove articles that aren't English"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing 228 articles in Spanish\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "healthday    219\n",
       "nyt            9\n",
       "Name: source, dtype: int64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spanish_articles = articles.section.isin([\"Consumer News in Spanish\", \"en Español\", \"HealthDay TV en Español\"])\n",
    "print(f\"Removing {spanish_articles.sum()} articles in Spanish\")\n",
    "\n",
    "articles[spanish_articles][\"source\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "articles = articles[~spanish_articles]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intercoding samples\n",
    "\n",
    "Remove articles that were used for previous samples except `all_venues_sample_05052021.csv` (this file is already part of the final dataset and has been coded)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing 41 articles previously sampled\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "wired        10\n",
       "nyt           8\n",
       "healthday     7\n",
       "medpage       7\n",
       "guardian      7\n",
       "newsmed       2\n",
       "Name: source, dtype: int64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "samples = list(sample_dir.glob(\"*.csv\"))\n",
    "\n",
    "sampled_urls = []\n",
    "for sample in samples:\n",
    "    if sample.name == \"all_venues_sample_05052021.csv\":\n",
    "        continue\n",
    "    df = pd.read_csv(sample)\n",
    "    if \"link\" in df:\n",
    "        sampled_urls.extend(df[\"link\"].tolist())\n",
    "    else:\n",
    "        sampled_urls.extend(df[\"url\"].tolist())\n",
    "        \n",
    "sampled_articles = articles.url.isin(sampled_urls)\n",
    "print(f\"Removing {sampled_articles.sum()} articles previously sampled\")\n",
    "articles[sampled_articles][\"source\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "articles = articles[~sampled_articles]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5172, 12)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "articles.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "source_order = [\"guardian\", \"nyt\", \"wired\", \"popsci\", \"ifls\", \"newsmed\", \"healthday\", \"medpage\"]\n",
    "source_order = source_order[::-1]\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "with sns.axes_style(\"whitegrid\"):\n",
    "    ax = orig_counts.loc[source_order].plot(kind=\"barh\", alpha=.3)\n",
    "    pdf = articles.groupby(\"source\").size()\n",
    "    pdf.loc[source_order].plot(kind=\"barh\", ax=ax)\n",
    "    sns.despine(bottom=True)\n",
    "    plt.grid(False, axis=\"y\")\n",
    "#     xticks = range(100, 1600, 100)\n",
    "    yticks, labels = plt.yticks()\n",
    "    labels = [f\"{_.get_text()} (n={pdf[_.get_text()]})\" for _ in labels]\n",
    "    plt.yticks(ticks=yticks, labels=labels)\n",
    "#     plt.xticks(xticks, xticks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "articles.to_csv(output_dir / \"filtered_articles.csv\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "altmetric-news",
   "language": "python",
   "name": "altmetric-news"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}