implementations/notebooks_df/reviews_accepted.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reviews_Accepted\n",
    "This is the reference implementation for [Reviews Accepted](https://github.com/chaoss/wg-evolution/blob/master/metrics/Reviews_Accepted.md),\n",
    "a metric specified by the\n",
    "[Evolution Working Group](https://github.com/chaoss/wg-evolution) of the\n",
    "[CHAOSS project](https://chaoss.community).\n",
    "This implementation is specific to Git repositories.\n",
    "\n",
    "Have a look at [README.md](../README.md) to find out how to run this notebook (and others in this directory) as well as to get a better understanding of the purpose of the implementations.\n",
    "\n",
    "The implementation is described in two parts (see below):\n",
    "\n",
    "* Class for computing Reviews Accepted\n",
    "* An explanatory analysis of the class' functionality\n",
    "\n",
    "Some more auxiliary information in this notebook:\n",
    "\n",
    "* Examples of the use of the implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As discussed in the [README](../README.md) file, the scripts required to analyze the data fetched by Perceval are located in the `code_df` package. Due to python's import system, to import modules from a package which is not in the current directory, we have to either add the package to `PYTHONPATH` or simply append a `..` to `sys.path`, so that `code_df` can be successfully imported. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "sys.path.append('..')\n",
    "from code_df import utils\n",
    "from code_df import conditions\n",
    "from code_df.pullrequest import PullRequest\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReviewsAccepted(PullRequest):\n",
    "    \"\"\"\n",
    "    Class for Reviews Accepted\n",
    "    \"\"\"\n",
    "\n",
    "    def compute(self):\n",
    "        \"\"\"\n",
    "        Compute the total number of reviews which were accepted, from the Perceval data.\n",
    "\n",
    "        :returns count: The total number of reviews accepted\n",
    "        \"\"\"\n",
    "\n",
    "        count = len(self.df['hash'][self.df['merged']].unique())\n",
    "        return count\n",
    "\n",
    "    def _agg(self, df, period):\n",
    "        \"\"\"\n",
    "        Perform an aggregation operation on a DataFrame to find\n",
    "        the total number of reviews accepted in every\n",
    "        interval of the period specified in the time_series method,\n",
    "        like 'M', 'W',etc.\n",
    "\n",
    "        It computes the count of the \"category\" column of the\n",
    "        DataFrame for those rows with the 'merge' column having True.\n",
    "\n",
    "        :param df: a pandas DataFrame on which the aggregation will be\n",
    "            applied.\n",
    "\n",
    "        :param period: A string which can be any one of the pandas time\n",
    "            series rules:\n",
    "            'W': week\n",
    "            'M': month\n",
    "            'D': day\n",
    "\n",
    "        :returns df: The aggregated dataframe, where aggregations have\n",
    "            been performed on the \"category\" column\n",
    "        \"\"\"\n",
    "\n",
    "        df = df[df['merged']]\n",
    "        df = df.resample(period)['category'].agg(['count'])\n",
    "\n",
    "        return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performing the Analysis\n",
    "Lets perform two kinds of analysis here:\n",
    "- computing the number of reviews accepted in a given period\n",
    "- finding the trends in the number of reviews accepted over time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counting the total number of reviews accepted\n",
    "We first read the JSON file containing Perceval data using the `read_json_file` utility function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = utils.read_json_file('../pull_requests.json')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the `compute` method to count the total number of accepted reviews. First, we will do it without passing any since and until dates. \n",
    "Next, we can pass in the start and end dates as a tuple. The format would be `%Y-%m-%d`.\n",
    "Let's also find the number of accepted reviews created after a certain date. Here, we would pass a valid `datetime` object for the `since` part of `date_range`, leaving the `until` part as `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total number of reviews accepted in the data is 201.\n",
      "The total number of reviews created between 2018-01-01 and 2018-07-01 that were accepted is 37.\n",
      "The total number of reviews created after 2018-01-01  that were accepted is 57.\n"
     ]
    }
   ],
   "source": [
    "reviews_accepted = ReviewsAccepted(items)\n",
    "print(\"The total number of reviews accepted \"\n",
    "      \"in the data is {}.\".format(reviews_accepted.compute()))\n",
    "\n",
    "date_since = datetime.strptime(\"2018-01-01\", \"%Y-%m-%d\")\n",
    "date_until = datetime.strptime(\"2018-07-01\", \"%Y-%m-%d\")    \n",
    "\n",
    "reviews_accepted_dated = ReviewsAccepted(items,\n",
    "                        date_range=(date_since, date_until))\n",
    "                        \n",
    "print(\"The total number of reviews created between \"\n",
    "      \"2018-01-01 and 2018-07-01 that were accepted is {}.\".format(reviews_accepted_dated.compute()))\n",
    "\n",
    "reviews_accepted_since = ReviewsAccepted(items,\n",
    "                        date_range=(date_since, None))\n",
    "                        \n",
    "print(\"The total number of reviews created after \"\n",
    "      \"2018-01-01  that were accepted is {}.\".format(reviews_accepted_since.compute()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing the number of accepted reviews over regular time intervals\n",
    "Using the `time_series` method, it is possible to compute the number of reviews accepted every month, every week or any valid pandas timeseries period. This kind of analysis is useful in finding trends over time, as we will see in the cell below.\n",
    "\n",
    "Let's perform a basic analysis: lets see the change in the number of reviews accepted, between the same dates we used above on a weekly basis: 2018-01-01 and 2018-07-01. \n",
    "The `ReviewsAccepted` object, `reviews_accepted_dated`, will be used again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekly_df = reviews_accepted_dated.time_series(period='W')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets see what the dataframe returned by `time_series` looks like. As you will notice, the dataframe has rows corresponding to each and every week between the start and end dates. To do this, we simply set the `created_date` column of the DataFrame `changes_dated.df`, as its index and then `resample` it to whatever time period we need. In this case, we have used `W`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>created_date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-01-07</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-01-14</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-01-21</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-01-28</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-04</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-11</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-18</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-25</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-04</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-11</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-18</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-25</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-01</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-08</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-15</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-22</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-29</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-05-06</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-05-13</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-05-20</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-05-27</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-06-03</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count\n",
       "created_date       \n",
       "2018-01-07        3\n",
       "2018-01-14        3\n",
       "2018-01-21        2\n",
       "2018-01-28        2\n",
       "2018-02-04        1\n",
       "2018-02-11        4\n",
       "2018-02-18        2\n",
       "2018-02-25        1\n",
       "2018-03-04        0\n",
       "2018-03-11        5\n",
       "2018-03-18        2\n",
       "2018-03-25        5\n",
       "2018-04-01        0\n",
       "2018-04-08        2\n",
       "2018-04-15        1\n",
       "2018-04-22        1\n",
       "2018-04-29        0\n",
       "2018-05-06        0\n",
       "2018-05-13        0\n",
       "2018-05-20        0\n",
       "2018-05-27        0\n",
       "2018-06-03        3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weekly_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets plot the dataframe `weekly_df` using matplotlib.pyplot. We use the `seaborn` theme and plot a simple line plot --- commit count vs time interval. Using the `plt.fill_between` method allows us to \"fill up\" the area between the line plot and the x axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('seaborn')\n",
    "weekly_df.plot(y='count', use_index=True)\n",
    "plt.fill_between(y1=weekly_df['count'], y2=0, x=weekly_df.index)\n",
    "plt.title(\"Number of Reviews Accepted\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do the same thing on a monthly basis. As can be expected, the resulting DataFrame, `monthly_df` would have a lesser number of datapoints when compared to `weekly_df`, due to the larger period being considered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthly_df = reviews_accepted_dated.time_series(period='M')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>created_date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-01-31</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-02-28</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-31</th>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-30</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-05-31</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count\n",
       "created_date       \n",
       "2018-01-31       11\n",
       "2018-02-28        7\n",
       "2018-03-31       12\n",
       "2018-04-30        4\n",
       "2018-05-31        3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monthly_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('seaborn')\n",
    "monthly_df.plot(y='count', use_index=True)\n",
    "plt.fill_between(y1=monthly_df['count'], y2=0, x=monthly_df.index)\n",
    "plt.title(\"Number of Reviews Accepted\");"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}