github_scala_history_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "5"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 1. Scala's real-world project repository data\n",
    "<p>With almost 30k commits and a history spanning over ten years, Scala is a mature programming language. It is a general-purpose programming language that has recently become another prominent language for data scientists.</p>\n",
    "<p>Scala is also an open source project. Open source projects have the advantage that their entire development histories -- who made changes, what was changed, code reviews, etc. -- are publicly available. </p>\n",
    "<p>We're going to read in, clean up, and visualize the real world project repository of Scala that spans data from a version control system (Git) as well as a project hosting site (GitHub). We will find out who has had the most influence on its development and who are the experts.</p>\n",
    "<p>The dataset we will use, which has been previously mined and extracted from GitHub, is comprised of three files:</p>\n",
    "<ol>\n",
    "<li><code>pulls_2011-2013.csv</code> contains the basic information about the pull requests, and spans from the end of 2011 up to (but not including) 2014.</li>\n",
    "<li><code>pulls_2014-2018.csv</code> contains identical information, and spans from 2014 up to 2018.</li>\n",
    "<li><code>pull_files.csv</code> contains the files that were modified by each pull request.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {
    "dc": {
     "key": "5"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# Importing pandas\n",
    "import pandas as pd\n",
    "# ... YOUR CODE FOR TASK 1 ...\n",
    "\n",
    "# Loading in the data\n",
    "pulls_one = pd.read_csv(\"datasets/pulls_2011-2013.csv\")\n",
    "pulls_two = pd.read_csv(\"datasets/pulls_2014-2018.csv\")\n",
    "pull_files = pd.read_csv(\"datasets/pull_files.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {
    "dc": {
     "key": "5"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 3, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_pulls_one\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_pulls_two\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_pull_files\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3/3 tests passed\n"
      ]
     },
     "execution_count": 319,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "def test_pulls_one():\n",
    "    correct_pulls_one = pd.read_csv('datasets/pulls_2011-2013.csv')\n",
    "    assert correct_pulls_one.equals(pulls_one), \\\n",
    "    \"Read in 'datasets/pulls_2011-2013.csv' using read_csv().\"\n",
    "\n",
    "def test_pulls_two():\n",
    "    correct_pulls_two = pd.read_csv('datasets/pulls_2014-2018.csv')\n",
    "    assert correct_pulls_two.equals(pulls_two), \\\n",
    "   \"Read in 'datasets/pulls_2014-2018.csv' using read_csv().\"\n",
    "    \n",
    "def test_pull_files():\n",
    "    correct_pull_files = pd.read_csv('datasets/pull_files.csv')\n",
    "    assert correct_pull_files.equals(pull_files), \\\n",
    "    \"Read in 'pull_files.csv' using read_csv().\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "12"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 2. Preparing and cleaning the data\n",
    "<p>First, we will need to combine the data from the two separate pull DataFrames. </p>\n",
    "<p>Next, the raw data extracted from GitHub contains dates in the ISO8601 format. However, <code>pandas</code> imports them as regular strings. To make our analysis easier, we need to convert the strings into Python's <code>DateTime</code> objects. <code>DateTime</code> objects have the important property that they can be compared and sorted.</p>\n",
    "<p>The pull request times are all in UTC (also known as Coordinated Universal Time). The commit times, however, are in the local time of the author with time zone information (number of hours difference from UTC). To make comparisons easy, we should convert all times to UTC.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {
    "dc": {
     "key": "12"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# Append pulls_one to pulls_two\n",
    "pulls = pulls_one.append(pulls_two)\n",
    "\n",
    "# Convert the date for the pulls object\n",
    "pulls['date'] = pd.to_datetime(pulls['date'], utc = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {
    "dc": {
     "key": "12"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 2, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_pulls_length\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_pulls_type\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2/2 tests passed\n"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_pulls_length():\n",
    "    assert len(pulls) == 6200, \\\n",
    "    'The DataFrame pulls does not have the correct number of rows. Did you correctly append pulls_one to pulls_two?'\n",
    "\n",
    "def test_pulls_type():\n",
    "    assert type(pulls['date'].dtype) is pd.core.dtypes.dtypes.DatetimeTZDtype, \\\n",
    "    'The date for the pull requests is not the correct type.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "19"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 3. Merging the DataFrames\n",
    "<p>The data extracted comes in two separate files. Merging the two DataFrames will make it easier for us to analyze the data in the future tasks.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {
    "dc": {
     "key": "19"
    },
    "tags": [
     "sample_code"
    ]
   },
   "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>pid</th>\n",
       "      <th>user</th>\n",
       "      <th>date</th>\n",
       "      <th>file</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>11166973</td>\n",
       "      <td>VladimirNik</td>\n",
       "      <td>2013-12-31 23:10:55+00:00</td>\n",
       "      <td>src/reflect/scala/reflect/api/Printers.scala</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>11166973</td>\n",
       "      <td>VladimirNik</td>\n",
       "      <td>2013-12-31 23:10:55+00:00</td>\n",
       "      <td>src/reflect/scala/reflect/internal/Printers.scala</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>11166973</td>\n",
       "      <td>VladimirNik</td>\n",
       "      <td>2013-12-31 23:10:55+00:00</td>\n",
       "      <td>test/files/run/reify_ann3.check</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11166973</td>\n",
       "      <td>VladimirNik</td>\n",
       "      <td>2013-12-31 23:10:55+00:00</td>\n",
       "      <td>test/junit/scala/reflect/internal/PrintersTest...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>11161892</td>\n",
       "      <td>Ichoran</td>\n",
       "      <td>2013-12-31 16:55:47+00:00</td>\n",
       "      <td>src/library/scala/collection/mutable/ArrayOps....</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85583</th>\n",
       "      <td>11231462</td>\n",
       "      <td>rklaehn</td>\n",
       "      <td>2014-01-04 22:42:02+00:00</td>\n",
       "      <td>src/library/scala/collection/immutable/HashSet...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85584</th>\n",
       "      <td>11188295</td>\n",
       "      <td>rklaehn</td>\n",
       "      <td>2014-01-02 18:55:33+00:00</td>\n",
       "      <td>src/library/scala/collection/immutable/HashSet...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85585</th>\n",
       "      <td>11188295</td>\n",
       "      <td>rklaehn</td>\n",
       "      <td>2014-01-02 18:55:33+00:00</td>\n",
       "      <td>test/files/run/t6253a.scala</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85586</th>\n",
       "      <td>11188295</td>\n",
       "      <td>rklaehn</td>\n",
       "      <td>2014-01-02 18:55:33+00:00</td>\n",
       "      <td>test/files/run/t6253b.scala</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85587</th>\n",
       "      <td>11188295</td>\n",
       "      <td>rklaehn</td>\n",
       "      <td>2014-01-02 18:55:33+00:00</td>\n",
       "      <td>test/files/run/t6253c.scala</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>85588 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            pid         user                      date                                               file\n",
       "0      11166973  VladimirNik 2013-12-31 23:10:55+00:00       src/reflect/scala/reflect/api/Printers.scala\n",
       "1      11166973  VladimirNik 2013-12-31 23:10:55+00:00  src/reflect/scala/reflect/internal/Printers.scala\n",
       "2      11166973  VladimirNik 2013-12-31 23:10:55+00:00                    test/files/run/reify_ann3.check\n",
       "3      11166973  VladimirNik 2013-12-31 23:10:55+00:00  test/junit/scala/reflect/internal/PrintersTest...\n",
       "4      11161892      Ichoran 2013-12-31 16:55:47+00:00  src/library/scala/collection/mutable/ArrayOps....\n",
       "...         ...          ...                       ...                                                ...\n",
       "85583  11231462      rklaehn 2014-01-04 22:42:02+00:00  src/library/scala/collection/immutable/HashSet...\n",
       "85584  11188295      rklaehn 2014-01-02 18:55:33+00:00  src/library/scala/collection/immutable/HashSet...\n",
       "85585  11188295      rklaehn 2014-01-02 18:55:33+00:00                        test/files/run/t6253a.scala\n",
       "85586  11188295      rklaehn 2014-01-02 18:55:33+00:00                        test/files/run/t6253b.scala\n",
       "85587  11188295      rklaehn 2014-01-02 18:55:33+00:00                        test/files/run/t6253c.scala\n",
       "\n",
       "[85588 rows x 4 columns]"
      ]
     },
     "execution_count": 322,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Merge the two DataFrames\n",
    "data = pulls.merge(pull_files, on = \"pid\")\n",
    "\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {
    "dc": {
     "key": "19"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 2, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_merge\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_merge_dataframes\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2/2 tests passed\n"
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_merge():\n",
    "    assert len(data) == 85588, \\\n",
    "    'The merged DataFrame does not have the correct number of rows.'\n",
    "\n",
    "def test_merge_dataframes():\n",
    "    correct_data = pulls.merge(pull_files, on='pid')\n",
    "    also_correct_data = pull_files.merge(pulls, on='pid')\n",
    "    assert correct_data.equals(data) or \\\n",
    "        also_correct_data.equals(data), \\\n",
    "        \"The DataFrames are not merged correctly.\"        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "26"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 4. Is the project still actively maintained?\n",
    "<p>The activity in an open source project is not very consistent. Some projects might be active for many years after the initial release, while others can slowly taper out into oblivion. Before committing to contributing to a project, it is important to understand the state of the project. Is development going steadily, or is there a drop? Has the project been abandoned altogether?</p>\n",
    "<p>The data used in this project was collected in January of 2018. We are interested in the evolution of the number of contributions up to that date.</p>\n",
    "<p>For Scala, we will do this by plotting a chart of the project's activity. We will calculate the number of pull requests submitted each (calendar) month during the project's lifetime. We will then plot these numbers to see the trend of contributions.</p>\n",
    "<ul>\n",
    "<li><p>A helpful reminder of how to access various components of a date can be found in <a href=\"https://campus.datacamp.com/courses/data-manipulation-with-pandas/slicing-and-indexing?ex=12\">this exercise of Data Manipulation with pandas</a></p></li>\n",
    "<li><p>Additionally, recall that you can group by multiple variables by passing a list to <code>.groupby()</code>. This video from <a href=\"https://campus.datacamp.com/courses/data-manipulation-with-pandas/aggregating-dataframes?ex=9\">Data Manipulation with pandas</a> should help!</p></li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {
    "dc": {
     "key": "26"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='month,year'>"
      ]
     },
     "execution_count": 324,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import datetime as dt\n",
    "# Create a column that will store the month\n",
    "data['month'] = data['date'].dt.month\n",
    "\n",
    "# Create a column that will store the year\n",
    "data['year'] = data['date'].dt.year\n",
    "\n",
    "# Group by the month and year and count the pull requests\n",
    "counts = data.groupby(['month', 'year']).agg({'pid':'count'})\n",
    "\n",
    "# Plot the results\n",
    "counts.plot(kind='bar', figsize = (12,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {
    "dc": {
     "key": "26"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 1, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_group_and_count\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1/1 tests passed\n"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "    \n",
    "def test_group_and_count():\n",
    "    assert len(counts) == 74, \\\n",
    "    \"The data was not grouped correctly. The history only spans 74 months.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "33"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 5. Is there camaraderie in the project?\n",
    "<p>The organizational structure varies from one project to another, and it can influence your success as a contributor. A project that has a very small community might not be the best one to start working on. The small community might indicate a high barrier of entry. This can be caused by several factors, including a community that is reluctant to accept pull requests from \"outsiders,\" that the code base is hard to work with, etc. However, a large community can serve as an indicator that the project is regularly accepting pull requests from new contributors. Such a project would be a good place to start.</p>\n",
    "<p>In order to evaluate the dynamics of the community, we will plot a histogram of the number of pull requests submitted by each user. A distribution that shows that there are few people that only contribute a small number of pull requests can be used as in indicator that the project is not welcoming of new contributors. </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "dc": {
     "key": "33"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='Frequency'>"
      ]
     },
     "execution_count": 326,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Required for matplotlib\n",
    "%matplotlib inline\n",
    "\n",
    "# Group by the submitter\n",
    "by_user = data.groupby('user').agg({'pid':'count'})\n",
    "\n",
    "# Plot the histogram\n",
    "by_user.plot(kind = \"hist\")\n",
    "# ... YOUR CODE FOR TASK 5 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {
    "dc": {
     "key": "33"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 1, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_by_user\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1/1 tests passed\n"
      ]
     },
     "execution_count": 327,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_by_user():\n",
    "    assert len(by_user) == 467 or len(by_user) == 464, \\\n",
    "    'The grouping by user is not correct'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "40"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 6. What files were changed in the last ten pull requests?\n",
    "<p>Choosing the right place to make a contribution is as important as choosing the project to contribute to. Some parts of the code might be stable, some might be dead. Contributing there might not have the most impact. Therefore it is important to understand the parts of the system that have been recently changed. This allows us to pinpoint the \"hot\" areas of the code where most of the activity is happening. Focusing on those parts might not the most effective use of our times.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {
    "dc": {
     "key": "40"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'LICENSE',\n",
       " 'doc/LICENSE.md',\n",
       " 'doc/License.rtf',\n",
       " 'project/VersionUtil.scala',\n",
       " 'src/compiler/scala/reflect/reify/phases/Calculate.scala',\n",
       " 'src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala',\n",
       " 'src/compiler/scala/tools/nsc/backend/jvm/PostProcessor.scala',\n",
       " 'src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala',\n",
       " 'src/compiler/scala/tools/nsc/profile/AsyncHelper.scala',\n",
       " 'src/compiler/scala/tools/nsc/profile/Profiler.scala',\n",
       " 'src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala',\n",
       " 'src/compiler/scala/tools/nsc/typechecker/Contexts.scala',\n",
       " 'src/library/scala/Predef.scala',\n",
       " 'src/library/scala/concurrent/Lock.scala',\n",
       " 'src/library/scala/util/Properties.scala',\n",
       " 'src/reflect/scala/reflect/internal/pickling/ByteCodecs.scala',\n",
       " 'src/reflect/scala/reflect/internal/tpe/GlbLubs.scala',\n",
       " 'src/scaladoc/scala/tools/nsc/doc/html/page/Entity.scala',\n",
       " 'src/scalap/decoder.properties',\n",
       " 'test/files/neg/leibniz-liskov.check',\n",
       " 'test/files/neg/leibniz-liskov.scala',\n",
       " 'test/files/pos/leibniz-liskov.scala',\n",
       " 'test/files/pos/leibniz_liskov.scala',\n",
       " 'test/files/pos/parallel-classloader.scala',\n",
       " 'test/files/pos/t10568/Converter.java',\n",
       " 'test/files/pos/t10568/Impl.scala',\n",
       " 'test/files/pos/t10686.scala',\n",
       " 'test/files/pos/t5638/Among.java',\n",
       " 'test/files/pos/t5638/Usage.scala',\n",
       " 'test/files/pos/t9291.scala',\n",
       " 'test/files/run/t8348.check',\n",
       " 'test/files/run/t8348/TableColumn.java',\n",
       " 'test/files/run/t8348/TableColumnImpl.java',\n",
       " 'test/files/run/t8348/Test.scala'}"
      ]
     },
     "execution_count": 328,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Identify the last 10 pull requests\n",
    "last_10 = pulls.sort_values(by = \"date\").tail(10)\n",
    "last_10\n",
    "# Join the two data sets\n",
    "joined_pr = pull_files.merge(last_10, on = \"pid\")\n",
    "\n",
    "# Identify the unique files\n",
    "files = set(joined_pr['file'])\n",
    "# Print the results\n",
    "files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {
    "dc": {
     "key": "40"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 3, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_last_10\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_join\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_no_files\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3/3 tests passed\n"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_last_10():\n",
    "    assert len(last_10) == 10, \\\n",
    "    'You need to select the last 10 pull requests.'\n",
    "\n",
    "def test_join():\n",
    "    assert len(joined_pr) == 34, \\\n",
    "    'The join was not done correctly. You lost some pull requests in the process.'\n",
    "    \n",
    "def test_no_files():\n",
    "    assert len(files) == 34, \\\n",
    "    'You did not select the right number of pull requests.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "47"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 7. Who made the most pull requests to a given file?\n",
    "<p>When contributing to a project, we might need some guidance. We might find ourselves needing some information regarding the codebase. It is important direct any questions to the right person. Contributors to open source projects generally have other day jobs, so their time is limited. It is important to address our questions to the right people. One way to identify the right target for our inquiries is by using their contribution history.</p>\n",
    "<p>We identified <code>src/compiler/scala/reflect/reify/phases/Calculate.scala</code> as being recently changed. We are interested in the top 3 developers who changed that file. Those developers are the ones most likely to have the best understanding of the code.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {
    "dc": {
     "key": "47"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          pid\n",
      "user         \n",
      "xeno-by    11\n",
      "retronym    5\n",
      "soc         4\n"
     ]
    }
   ],
   "source": [
    "# This is the file we are interested in:\n",
    "file = 'src/compiler/scala/reflect/reify/phases/Calculate.scala'\n",
    "\n",
    "# Identify the commits that changed the file\n",
    "file_pr = data[data['file'] == \"src/compiler/scala/reflect/reify/phases/Calculate.scala\"]\n",
    "\n",
    "# Count the number of changes made by each developer\n",
    "author_counts = file_pr.groupby('user').agg({'pid':'count'})\n",
    "\n",
    "# Print the top 3 developers\n",
    "print(author_counts.nlargest(3, 'pid'))\n",
    "# ... YOUR CODE FOR TASK 7 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {
    "dc": {
     "key": "47"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 2, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_selecting_commits\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_author_counts\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2/2 tests passed\n"
      ]
     },
     "execution_count": 331,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_selecting_commits():\n",
    "    assert len(file_pr) == 30, \\\n",
    "    'You did not filter the data on the right file.'\n",
    "    \n",
    "def test_author_counts():\n",
    "    assert len(author_counts) == 11, \\\n",
    "    'The number of authors is not correct.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "54"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 8. Who made the last ten pull requests on a given file?\n",
    "<p>Open source projects suffer from fluctuating membership. This makes the problem of finding the right person more challenging: the person has to be knowledgeable <em>and</em> still be involved in the project. A person that contributed a lot in the past might no longer be available (or willing) to help. To get a better understanding, we need to investigate the more recent history of that particular part of the system. </p>\n",
    "<p>Like in the previous task, we will look at the history of  <code>src/compiler/scala/reflect/reify/phases/Calculate.scala</code>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {
    "dc": {
     "key": "54"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bjornregnell', 'retronym', 'soc', 'starblood', 'xeno-by', 'zuvizudar'}"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file = 'src/compiler/scala/reflect/reify/phases/Calculate.scala'\n",
    "\n",
    "# Select the pull requests that changed the target file\n",
    "file_pr = pull_files[pull_files['file'] == file]\n",
    "\n",
    "# Merge the obtained results with the pulls DataFrame\n",
    "joined_pr = pulls.merge(file_pr, on = \"pid\")\n",
    "# Find the users of the last 10 most recent pull requests\n",
    "users_last_10 = set(joined_pr.nlargest(10, 'date')['user'])\n",
    "# Printing the results\n",
    "users_last_10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {
    "dc": {
     "key": "54"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 3, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_join\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_file_pr\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_last_10\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3/3 tests passed\n"
      ]
     },
     "execution_count": 333,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_join():\n",
    "    assert len(joined_pr) == len(file_pr), \\\n",
    "    'The join was not done correctly. You lost some pull requests in the process.'\n",
    "    \n",
    "def test_file_pr():\n",
    "    assert len(joined_pr) == 30, \\\n",
    "    'The file does not have the correct number of pull requests.'\n",
    "    \n",
    "def test_last_10():\n",
    "    assert len(users_last_10) == 6, \\\n",
    "    'You did not select the right number of pull requests.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "61"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 9. The pull requests of two special developers\n",
    "<p>Now that we have identified two potential contacts in the projects, we need to find the person who was most involved in the project in recent times. That person is most likely to answer our questions. For each calendar year, we are interested in understanding the number of pull requests the authors submitted. This will give us a high-level image of their contribution trend to the project.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {
    "dc": {
     "key": "61"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='date'>"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "# The developers we are interested in\n",
    "authors = ['xeno-by', 'soc']\n",
    "\n",
    "# Get all the developers' pull requests\n",
    "by_author = pulls[pulls['user'].isin(authors)]\n",
    "\n",
    "# Count the number of pull requests submitted each year\n",
    "counts = by_author.groupby([by_author['user'], by_author['date'].dt.year]).agg({'pid': 'count'}).reset_index()\n",
    "\n",
    "# Convert the table to a wide format\n",
    "counts_wide = counts.pivot_table(index='date', columns='user', values='pid', fill_value=0)\n",
    "\n",
    "# Plot the results\n",
    "counts_wide.plot(kind = \"bar\")\n",
    "# ... YOUR CODE FOR TASK 9 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {
    "dc": {
     "key": "61"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 2, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_author_pr\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_counts\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2/2 tests passed\n"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_author_pr():\n",
    "    assert len(by_author) == 715, \\\n",
    "    \"The wrong number of pull requests have been selected.\"\n",
    "    \n",
    "def test_counts():\n",
    "    assert len(counts) == 11, \\\n",
    "    'The data should span 6 years.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "dc": {
     "key": "68"
    },
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    },
    "tags": [
     "context"
    ]
   },
   "source": [
    "## 10. Visualizing the contributions of each developer\n",
    "<p>As mentioned before, it is important to make a distinction between the global expertise and contribution levels and the contribution levels at a more granular level (file, submodule, etc.) In our case, we want to see which of our two developers of interest have the most experience with the code in a given file. We will measure experience by the number of pull requests submitted that affect that file and how recent those pull requests were submitted.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {
    "dc": {
     "key": "68"
    },
    "tags": [
     "sample_code"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='date'>"
      ]
     },
     "execution_count": 336,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAU70lEQVR4nO3df5CV9X3o8fdHWAHjD8Qw1kgQckcQAqjN7nKvyY0CJtBixaTRxEC1WotOEoz2XsU7NYSb1BQnTHsbp2NiUiSJjdKoVxmcGg2tmvQmhB+u0UhMbEWg8QeuBYS4BtjP/WMXimRBds/Zc77rvl8zjnt+7Hk+i9/h7fOcZ58TmYkkSaU5ot4DSJLUFQMlSSqSgZIkFclASZKKZKAkSUUaWMuNvfOd78xRo0bVcpOSpMKtXbv2lcwcfuD9NQ3UqFGjWLNmTS03KUkqXEQ839X9HuKTJBXJQEmSimSgJElFqul7UJL0drNr1y42b95MW1tbvUcp3uDBgxkxYgQNDQ2H9XwDJUkV2Lx5M8cccwyjRo0iIuo9TrEyk9bWVjZv3szo0aMP63s8xCdJFWhra+OEE04wTm8hIjjhhBO6taf5loGKiCUR8XJEPLXffcMi4uGI+GXnv4/v4cyS1OcZp8PT3T+nw9mDWgrMOOC+G4CVmXkqsLLztiRJVfOWgcrMx4BXD7h7FvDNzq+/CVxQ3bEkSf1dT0+SODEzX+j8+kXgxIM9MSLmAnMBRo4c2cPNvY0sPK7eE8DCbfWeQFIhdu/ezcCBZZ4vV/FUmZkRcdCP5c3M24DbABobG/34XkmqwIYNGzjvvPN46qmO0wIWL17Mjh07GDZsGF/96lcZOHAg48eP56677mLnzp3MmzePp556il27drFw4UJmzZrF0qVLuffee9mxYwd79uzh0UcfrfNP1bWeBuqliDgpM1+IiJOAl6s5lCSpexYtWsRzzz3HoEGD2Lp1KwA33XQTU6dOZcmSJWzdupXm5mbOPfdcANatW8dPf/pThg0bVsepD62np5kvBy7t/PpS4P7qjCNJ6olJkyYxe/Zs7rjjjn2H7B566CEWLVrEGWecwTnnnENbWxsbN24E4EMf+lDRcYLDO838TuBHwNiI2BwRfwIsAj4UEb8Ezu28LUnqZQMHDqS9vX3f7b2/V/TAAw/w6U9/mnXr1tHU1MTu3bvJTO655x5aWlpoaWlh48aNjBs3DoB3vOMddZm/Ow7nLL6LM/OkzGzIzBGZ+XeZ2ZqZ0zLz1Mw8NzMPPMtPktQLTjzxRF5++WVaW1t54403WLFiBe3t7WzatIkpU6Zw8803s23bNnbs2MH06dO55ZZbyOx4+//xxx+v8/TdU+apG5KkLjU0NLBgwQKam5s5+eSTOe2009izZw9z5sxh27ZtZCZXX301Q4cO5XOf+xzXXHMNkyZNor29ndGjR7NixYp6/wiHLfaWtRYaGxuz339goaeZS28r69ev33fYTG+tqz+viFibmY0HPtdr8UmSimSgJElFMlCSpCIZKElSkQyUJKlIBkqSVCR/D0qSqmjUDQ9U9fU2LJpZ1dfrS9yDkiQVyUBJUh+2c+dOZs6cyemnn86ECRNYtmwZK1eu5Mwzz2TixIlcfvnlvPHGGwCsXr2as846i9NPP53m5mZee+21Ok9/aB7ik6Q+7MEHH+Rd73oXDzzQcWhx27ZtTJgwgZUrVzJmzBguueQSbr31Vj71qU/x8Y9/nGXLltHU1MT27dsZMmRInac/NPegJKkPmzhxIg8//DDz58/nBz/4ARs2bGD06NGMGTMGgEsvvZTHHnuMZ555hpNOOommpiYAjj322GI/SXcvAyVJfdiYMWNYt24dEydO5MYbb+S+++6r90hVY6AkqQ/71a9+xVFHHcWcOXO47rrr+NGPfsSGDRt49tlnAfj2t7/N2WefzdixY3nhhRdYvXo1AK+99hq7d++u5+hvqez9O0nqY2p9WviTTz7JddddxxFHHEFDQwO33nor27Zt48ILL2T37t00NTVx1VVXceSRR7Js2TLmzZvH66+/zpAhQ/j+97/P0UcfXdN5u8NASVIfNn36dKZPn/5b93f14YRNTU38+Mc/rsVYVeEhPklSkQyUJKlIBkqSVCQDJUkqkoGSJBXJQEmSiuRp5pJUTQuPq/Lrbavu61XgkUceYfHixaxYsaIm23MPSpJUJAMlSX3Y6tWrmTRpEm1tbezcuZP3vve9PPHEE1x++eU0Nzdz5plncv/99wOwdOlSPvrRjzJjxgxOPfVUrr/++n2vc+eddzJx4kQmTJjA/PnzD7q97du3M3PmTMaOHctVV11Fe3s7S5Ys4Zprrtn3nK9//etce+21Ff9sHuKTpD6sqamJ888/nxtvvJHXX3+dOXPmsGzZMqZOncqSJUvYunUrzc3NnHvuuQC0tLTw+OOPM2jQIMaOHcu8efMYMGAA8+fPZ+3atRx//PF8+MMf5r777uOCCy74re395Cc/4emnn+aUU05hxowZ3HvvvVx00UXcdNNNfPnLX6ahoYHbb7+dr33taxX/bAZKkvq4BQsW0NTUxODBg/nKV77C5MmTWb58OYsXLwagra2NjRs3AjBt2jSOO67jfbLx48fz/PPP09rayjnnnMPw4cMBmD17No899liXgWpubuY973kPABdffDE//OEP+djHPsbUqVNZsWIF48aNY9euXUycOLHin8tASVIf19rayo4dO9i1axdtbW1kJvfccw9jx4590/NWrVrFoEGD9t0eMGDAIa9ovmrVKq688koAvvCFL3DssccSEW96zt7bV1xxBV/60pc47bTTuOyyy6ryc/kelCT1cVdeeSVf/OIXmT17NvPnz2f69OnccsstZCbQ9YVj99fc3Myjjz7KK6+8wp49e7jzzjs5++yzmTx5Mi0tLbS0tHD++ecDHYf4nnvuOdrb21m2bBkf+MAHAJg8eTKbNm3iO9/5DhdffHFVfi73oCSpmmp8Wvi3vvUtGhoa+OQnP8mePXs466yzWLBgAcuXL2fSpEm0t7czevToQ54aftJJJ7Fo0SKmTJlCZjJz5kxmzZrV5XObmpr4zGc+w7PPPsuUKVP4yEc+su+xiy66iJaWFo4//viq/Gyxt7C10NjYmGvWrKnZ9opU7d+R6NEM5fxehdTXrV+/nnHjxtV7jCKcd955XHvttUybNu2gz+nqzysi1mZm44HP9RCfJKkiW7duZcyYMQwZMuSQcequig7xRcS1wBVAAk8Cl2VmWzUGkyT1DUOHDuUXv/hF1V+3x3tQEXEycDXQmJkTgAHAJ6o1mCT1FbV8q6Qv6+6fU6WH+AYCQyJiIHAU8KsKX0+S+pTBgwfT2tpqpN5CZtLa2srgwYMP+3t6fIgvM/89IhYDG4HXgYcy86EDnxcRc4G5ACNHjuzp5iSpSCNGjGDz5s1s2bKl3qMUb/DgwYwYMeKwn9/jQEXE8cAsYDSwFfhuRMzJzDv2f15m3gbcBh1n8fV0e5JUooaGBkaPHl3vMd6WKjnEdy7wXGZuycxdwL3AWdUZS5LU31USqI3Af42Io6LjWhfTgPXVGUuS1N/1OFCZuQq4G1hHxynmR9B5KE+SpEpV9HtQmfl54PNVmkWSpH28koQkqUgGSpJUJAMlSSqSgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSqSgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSqSgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSqSgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRKgpURAyNiLsj4ucRsT4i/lu1BpMk9W8DK/z+vwEezMyPRcSRwFFVmEmSpJ4HKiKOAz4I/DFAZv4G+E11xpIk9XeVHOIbDWwBbo+IxyPiGxHxjirNJUnq5yoJ1EDgd4FbM/NMYCdww4FPioi5EbEmItZs2bKlgs1JkvqTSgK1Gdicmas6b99NR7DeJDNvy8zGzGwcPnx4BZuTJPUnPQ5UZr4IbIqIsZ13TQOerspUkqR+r9Kz+OYBf995Bt+/AZdVPpIkSRUGKjNbgMbqjCJJ0n/yShKSpCIZKElSkQyUJKlIBkqSVCQDJUkqkoGSJBXJQEmSimSgJElFMlCSpCIZKElSkQyUJKlIBkqSVCQDJUkqkoGSJBXJQEmSimSgJElFMlCSpCIZKElSkQyUJKlIBkqSVCQDJUkqkoGSJBXJQEmSimSgJElFMlCSpCIZKElSkQyUJKlIBkqSVCQDJUkqkoGSJBXJQEmSimSgJElFMlCSpCJVHKiIGBARj0fEimoMJEkSVGcP6rPA+iq8jiRJ+1QUqIgYAcwEvlGdcSRJ6lDpHtT/Aa4H2isfRZKk/9TjQEXEecDLmbn2LZ43NyLWRMSaLVu29HRzkqR+ppI9qPcD50fEBuAuYGpE3HHgkzLztsxszMzG4cOHV7A5SVJ/0uNAZeb/yswRmTkK+ATwT5k5p2qTSZL6NX8PSpJUpIHVeJHMfAR4pBqvJUkSuAclSSqUgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSqSgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSqSgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSqSgZIkFclASZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSpSjwMVEe+OiH+OiKcj4mcR8dlqDiZJ6t8GVvC9u4H/kZnrIuIYYG1EPJyZT1dpNklSP9bjPajMfCEz13V+/RqwHji5WoNJkvq3qrwHFRGjgDOBVdV4PUmSKjnEB0BEHA3cA1yTmdu7eHwuMBdg5MiRlW6uIqNueKCu2wfYMLjeEwjqvxY2LJpZ1+1LfUFFe1AR0UBHnP4+M+/t6jmZeVtmNmZm4/DhwyvZnCSpH6nkLL4A/g5Yn5l/Vb2RJEmqbA/q/cAfAVMjoqXzn9+v0lySpH6ux+9BZeYPgajiLJIk7eOVJCRJRTJQkqQiGShJUpEMlCSpSAZKklQkAyVJKpKBkiQVyUBJkopkoCRJRTJQkqQiGShJUpEMlCSpSAZKklQkAyVJKpKBkiQVqcefByVJqtDC4+o9ASzcVu8JDso9KElSkQyUJKlIBkqSVCQDJUkqkoGSJBXJQEmSimSgJElFMlCSpCIZKElSkQyUJKlIBkqSVCQDJUkqkoGSJBXJQEmSimSgJElFMlCSpCIZKElSkSoKVETMiIhnIuLZiLihWkNJktTjQEXEAOBvgd8DxgMXR8T4ag0mSerfKtmDagaezcx/y8zfAHcBs6ozliSpvxtYwfeeDGza7/ZmYPKBT4qIucDczps7IuKZCrbZ5wW8E3ilrkP876jr5gVxcwHrQCWo/zoo4++DU7q6s5JAHZbMvA24rbe301dExJrMbKz3HKov14HAdfBWKjnE9+/Au/e7PaLzPkmSKlZJoFYDp0bE6Ig4EvgEsLw6Y0mS+rseH+LLzN0R8Rnge8AAYElm/qxqk719ebhT4DpQB9fBIURm1nsGSZJ+i1eSkCQVyUBJkopkoCRJRTJQkqQiGSipBiKiOSKaOr8eHxF/FhG/X++5VF8R8a16z1CyXr+SRH8XEafRcVmoVZm5Y7/7Z2Tmg/WbTLUSEZ+n46LKAyPiYTouCfbPwA0RcWZm3lTXAVUTEXHg74kGMCUihgJk5vk1H6pwnmbeiyLiauDTwHrgDOCzmXl/52PrMvN36zieaiQinqTjv/8g4EVgRGZuj4ghdPyPy6R6zqfaiIh1wNPAN4CkI1B30nGRAzLz0fpNVyb3oHrXnwLvy8wdETEKuDsiRmXm39CxONU/7M7MPcCvI+JfM3M7QGa+HhHtdZ5NtdMIfBb4c+C6zGyJiNcN08EZqN51xN7Depm5ISLOoSNSp2Cg+pPfRMRRmflr4H1774yI4wAD1U9kZjvw1xHx3c5/v4R/Bx+SJ0n0rpci4oy9NzpjdR4dl9ifWK+hVHMf7IzT3r+k9moALq3PSKqXzNycmRcC/wjcUe95SuZ7UL0oIkbQcXjnxS4ee39m/ksdxlJBIuLo/U+eUf/kOuiagaoTF6QAImJjZo6s9xyqL9dB1zz+WT9PAy7IfiAi/uxgDwFH13IW1Y/roPsMVC9yQarTl4AvA7u7eMz3gfsP10E3Gaje5YIUwDrgvsxce+ADEXFFHeZRfbgOusn3oHpRRPw/YN5BFuSmzHx3HcZSjUXEWODVzNzSxWMnZuZLdRhLNeY66D4D1YtckJLUcx5m6kWZ+UxXcep8zDj1ExFxXEQsioifR8SrEdEaEes77xta7/lUG66D7jNQvcgFqU7/APwHcE5mDsvME4Apnff9Q10nUy25DrrJQ3y9KCK+B/wT8M29v6wbEb9Dx9UDpmXmh+s5n2ojIp7JzLHdfUxvL66D7nMPqneNysyb97+SRGa+mJk3A6fUcS7V1vMRcX1EnLj3jog4MSLmA5vqOJdqy3XQTQaqd7kgBfBx4ATg0Yj4j4h4FXgEGAZcVM/BVFOug27yEF8viojjgRuAWcCJdHwGzEvAcuDmzHy1juOphjo/uHIE8GM/uLL/ch10j4HqZS5I+cGVAtdBT3gliV50wIL8RkTsW5B0XGXCQPUPfnClwHXQbQaqd7kgBX5wpTq4DrrJkyR615sWJHAO8HsR8Ve4IPsTP7hS4DroNgPVu1yQArgEeNOHVmbm7sy8BPhgfUZSHbgOusmTJHqRn6grST1noCRJRfIQnySpSAZKklQkAyX1kohYGBH/8xCPXxAR42s5k9SXGCipfi4ADJR0EJ4kIVVRRPw5HR+n8jIdFwReC2wD5gJHAs8Cf0THpW5WdD62DfjDzpf4W2A48GvgTzPz5zUcXyqKgZKqJCLeBywFJtNxlZZ1wFeB2zOztfM5fwG8lJm3RMRSYEVm3t352Ergqsz8ZURMBv4yM6fW/ieRyuCljqTq+e/A/83MXwNExPLO+yd0hmkocDTwvQO/MSKOBs4Cvhux7yIjg3p7YKlkBkrqfUuBCzLziYj4YzoueXWgI4CtmXlG7caSyuZJElL1PAZcEBFDIuIY4A867z8GeCEiGoDZ+z3/tc7HyMztwHMRcSFAdDi9dqNL5TFQUpVk5jpgGfAE8I/A6s6HPgesAv4F2P+kh7uA6yLi8Yj4L3TE608i4gngZ3R80KXUb3mShCSpSO5BSZKKZKAkSUUyUJKkIhkoSVKRDJQkqUgGSpJUJAMlSSrS/wdHGltwpCwdUwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "authors = ['xeno-by', 'soc']\n",
    "file = 'src/compiler/scala/reflect/reify/phases/Calculate.scala'\n",
    "\n",
    "# Select the pull requests submitted by the authors, from the `data` DataFrame\n",
    "by_author = data[data['user'].isin(authors)]\n",
    "\n",
    "# Select the pull requests that affect the file\n",
    "by_file = by_author[by_author['file'] == file]\n",
    "\n",
    "# Group and count the number of PRs done by each user each year\n",
    "grouped = by_file.groupby(['user', by_file['date'].dt.year]).count()['pid'].reset_index()\n",
    "\n",
    "# Transform the data into a wide format\n",
    "by_file_wide = grouped.pivot_table(index='date', columns='user', values='pid', fill_value=0)\n",
    "\n",
    "# Plot the results\n",
    "by_file_wide.plot(kind='bar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {
    "dc": {
     "key": "68"
    },
    "hide": true,
    "tags": [
     "tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 3, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_by_author\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_by_file\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_by_file_wide\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3/3 tests passed\n"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# one or more tests of the students code. \n",
    "# The @solution should pass the tests.\n",
    "# The purpose of the tests is to try to catch common errors and to \n",
    "# give the student a hint on how to resolve these errors.\n",
    "\n",
    "def test_by_author():\n",
    "    assert len(by_author) == 16999, \\\n",
    "    'Selecting by author did not produce the expected results.'\n",
    "    \n",
    "def test_by_file():\n",
    "    assert len(by_file) == 15, \\\n",
    "    'Selecting by file did not produce the expected results.'\n",
    "    \n",
    "# def test_grouped():\n",
    "#     assert len(grouped) == 4, \\\n",
    "#     'There should be only 3 years that matches our data.'\n",
    "    \n",
    "def test_by_file_wide():\n",
    "    assert len(by_file_wide) == 3, \\\n",
    "    'There should be only 3 years that matches our data.'"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}