From 3bcd7b544431b702755a6a12c83d205311ca417a Mon Sep 17 00:00:00 2001 From: siddharm Date: Wed, 19 Aug 2020 18:36:26 -0400 Subject: [PATCH] updated file names to remove space --- ASCL_language_statistics.ipynb | 221 +++++++++ Language-Date_visualizations.ipynb | 707 +++++++++++++++++++++++++++++ 2 files changed, 928 insertions(+) create mode 100644 ASCL_language_statistics.ipynb create mode 100644 Language-Date_visualizations.ipynb diff --git a/ASCL_language_statistics.ipynb b/ASCL_language_statistics.ipynb new file mode 100644 index 0000000..e6b83ef --- /dev/null +++ b/ASCL_language_statistics.ipynb @@ -0,0 +1,221 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "#testing out opening a file\n", + "import re\n", + "\n", + "with open('ascl_github_repos') as fp:\n", + " for line in fp:\n", + " match = re.match(\"^.*github.com/(.*)/(.*)$\", line)\n", + " if match:\n", + " author = match.group(1)\n", + " repo = match.group(2)\n", + " #print(\"author: \" + author + \" repo: \" + repo)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'C++': 219978, 'Jupyter Notebook': 46397, 'Makefile': 2142}\n", + "\n", + "\n", + "\n", + " Repo Author Language Bytes\n", + "0 Eclairs 0satoken C++ 219978\n", + "1 Eclairs 0satoken Jupyter Notebook 46397\n", + "2 Eclairs 0satoken Makefile 2142\n" + ] + } + ], + "source": [ + "#testing out a GET request to the GitHub API and adding it to a DataFrame\n", + "import requests\n", + "import github_config\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "df = pd.DataFrame(columns=['Repo', 'Author', 'Language', 'Bytes'])\n", + "\n", + "session = requests.Session()\n", + "session.auth = (github_config.username, github_config.password)\n", + "\n", + "http_base = 'https://api.github.com/repos/'\n", + "r = session.get(http_base+'0satoken/Eclairs'+'/languages')\n", + "print(r)\n", + "json = r.json()\n", + "\n", + "print(json)\n", + "\n", + "for key in json:\n", + " df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1] = ['Eclairs', '0satoken', key, json[key]]\n", + " \n", + " '''\n", + " df2 = pd.DataFrame({\n", + " 'Repo':'Eclairs',\n", + " 'Author':'0satoken',\n", + " 'Language':i,\n", + " 'Bytes':[json[i]]\n", + " })\n", + " df = df.append(df2)\n", + " '''\n", + "print(\"\\n\\n\")\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Repo Author Language Bytes\n", + "0 Eclairs 0satoken C++ 219978\n", + "1 Eclairs 0satoken Jupyter Notebook 46397\n", + "2 Eclairs 0satoken Makefile 2142\n", + "3 Crab.Toolkit.michi2 1054 Python 1199268\n", + "4 Crab.Toolkit.michi2 1054 Shell 862626\n", + "5 Crab.Toolkit.michi2 1054 Fortran 458353\n", + "6 Crab.Toolkit.michi2 1054 Prolog 173935\n", + "7 Crab.Toolkit.michi2 1054 IDL 107971\n", + "8 Crab.Toolkit.michi2 1054 Makefile 2800\n", + "9 PRISM 1313e Python 910299\n", + "10 PRISM 1313e Jupyter Notebook 78845\n", + "11 PRISM 1313e TeX 6351\n", + "12 exostriker 3fon3fonov Python 5826713\n", + "13 exostriker 3fon3fonov Fortran 1747617\n", + "14 exostriker 3fon3fonov Jupyter Notebook 75609\n", + "15 exostriker 3fon3fonov Assembly 20621\n", + "16 exostriker 3fon3fonov C 6542\n", + "17 exostriker 3fon3fonov Shell 5688\n", + "18 exostriker 3fon3fonov C++ 2253\n", + "19 exostriker 3fon3fonov MATLAB 1752\n", + "20 exostriker 3fon3fonov Pascal 1492\n", + "21 fourpisky-core 4pisky HTML 4890745\n", + "22 fourpisky-core 4pisky Python 203440\n", + "23 fourpisky-core 4pisky Jupyter Notebook 13027\n", + "24 fourpisky-core 4pisky Shell 743\n", + "25 AskaryanModule 918particle C++ 47462\n", + "26 AskaryanModule 918particle MATLAB 14572\n", + "27 AskaryanModule 918particle Gnuplot 4028\n", + "28 AskaryanModule 918particle C 1053\n", + "29 AskaryanModule 918particle M 802\n", + "... ... ... ... ...\n", + "4003 OpenMHD zenitani Gnuplot 694\n", + "4004 OpenMHD zenitani Shell 170\n", + "4005 TAP zgazak IDL 346739\n", + "4006 TAP zgazak Prolog 24400\n", + "4007 pyreaclib zingale Fortran 129292\n", + "4008 pyreaclib zingale Jupyter Notebook 82591\n", + "4009 pyreaclib zingale Python 72679\n", + "4010 pyreaclib zingale Makefile 1248\n", + "4011 dacapo_calibration ziotom78 Python 90488\n", + "4012 dacapo_calibration ziotom78 Fortran 6825\n", + "4013 dacapo_calibration ziotom78 Makefile 5039\n", + "4014 dacapo_calibration ziotom78 TeX 4898\n", + "4015 dacapo_calibration ziotom78 MATLAB 3042\n", + "4016 dacapo_calibration ziotom78 Dockerfile 653\n", + "4017 polycomp ziotom78 Python 116573\n", + "4018 megalib zoglauer GLSL 13138267\n", + "4019 megalib zoglauer C++ 9821809\n", + "4020 megalib zoglauer Shell 438070\n", + "4021 megalib zoglauer Makefile 93092\n", + "4022 megalib zoglauer C 28767\n", + "4023 megalib zoglauer Python 9763\n", + "4024 megalib zoglauer Dockerfile 2306\n", + "4025 megalib zoglauer Objective-C 301\n", + "4026 dst zonca Python 29300\n", + "4027 python-qucs zonca Python 8313\n", + "4028 starpy zooniverse Python 53011\n", + "4029 CausticFrog zpenoyre Python 21851\n", + "4030 CausticFrog zpenoyre Jupyter Notebook 3453\n", + "4031 OoT zpenoyre Jupyter Notebook 68132\n", + "4032 OoT zpenoyre Python 9640\n", + "\n", + "[4033 rows x 4 columns]\n" + ] + } + ], + "source": [ + "#The real deal\n", + "import re\n", + "import requests\n", + "import github_config\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "session = requests.Session()\n", + "session.auth = (github_config.username, github_config.password)\n", + "\n", + "http_base = 'https://api.github.com/repos/'\n", + "\n", + "#placeholder column names\n", + "df = pd.DataFrame(columns=['Repo', 'Author', 'Language', 'Bytes'])\n", + "\n", + "with open('ascl_github_repos') as fp:\n", + " for line in fp:\n", + " #if it matches the github repo URL scheme \n", + " # (weeds out malformed duplicates)\n", + " match = re.match(\"^.*github.com/(.*)/(.*)$\", line)\n", + " if match:\n", + " author = match.group(1)\n", + " repo = match.group(2)\n", + " \n", + " #hit the GitHub API\n", + " r = session.get(http_base+author+'/'+repo+'/languages')\n", + " languages = r.json()\n", + " \n", + " for key in languages:\n", + " #adds each language to the end of the dataframe\n", + " df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1] = [repo, author, key, languages[key]]\n", + "\n", + " \n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "df.to_csv('languages.csv')" + ] + } + ], + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Language-Date_visualizations.ipynb b/Language-Date_visualizations.ipynb new file mode 100644 index 0000000..91792a3 --- /dev/null +++ b/Language-Date_visualizations.ipynb @@ -0,0 +1,707 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "df = pd.read_csv('language_data_with_dates.csv')\n", + "#codes where df[df['ascl-id'] == 0] need to be dealt with when thinking about dates" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nfig1, ax1 = plt.subplots()\\nax1.pie(lang[lang.columns[1]], labels=lang[lang.columns[0]], autopct='%1.1f%%',\\n shadow=True, startangle=90)\\nax1.axis('equal')\\n\"" + ] + }, + "execution_count": 207, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#A pie chart of the total language stats\n", + "\n", + "#cast the Bytes column to int64\n", + "df = df[pd.to_numeric(df.Bytes,errors='coerce').notnull()]\n", + "df.Bytes = df['Bytes'].astype(str).astype(int)\n", + "df.sort_values(by='Bytes', ascending=False)\n", + "\n", + "#group the rows by languages and sum on the Bytes column\n", + "lang = df.groupby('Language', as_index=False)['Bytes'].sum()\n", + "\n", + "#Sed takes up a lot because one repository was\n", + "#using the file extension for their own data, not code\n", + "#Jupyter notebooks can be excluded, since they may contain \n", + "#images which can artificially inflate the size\n", + "lang = lang[lang['Language'] != \"sed\"]\n", + "lang = lang[lang['Language'] != \"Jupyter Notebook\"]\n", + "\n", + "#create a new column for the percent that language occupies\n", + "lang['% of total'] = lang.Bytes / lang.Bytes.sum() * 100\n", + "\n", + "#filtering out irrelevant data\n", + "lang = lang[lang['% of total'] > 0.001]\n", + "\n", + "lang = lang.sort_values(by='% of total', ascending=False)\n", + "\n", + "#Pie chart time!\n", + "\n", + "#this creates a pie chart without consolidating languages\n", + "'''\n", + "fig1, ax1 = plt.subplots()\n", + "ax1.pie(lang[lang.columns[1]], labels=lang[lang.columns[0]], autopct='%1.1f%%',\n", + " shadow=True, startangle=90)\n", + "ax1.axis('equal')\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Language Bytes % of total\n", + "0 Python 289004288 18.163067\n", + "1 Fortran 263411241 16.554619\n", + "2 C 244733012 15.380748\n", + "3 C++ 218327962 13.721268\n", + "4 All other languages, each < 2% of total 191282135 12.021518\n", + "5 HTML 95307284 5.989782\n", + "6 Java 63113450 3.966494\n", + "7 Shell 54842464 3.446687\n", + "8 Ruby 53948642 3.390513\n", + "9 TeX 44539192 2.799157\n", + "10 OpenEdge ABL 36927794 2.320803\n", + "11 IDL 35571569 2.235568\n" + ] + }, + { + "data": { + "text/plain": [ + "(-1.1125275989249963,\n", + " 1.1061580341722685,\n", + " -1.101081319684025,\n", + " 1.1000514928489695)" + ] + }, + "execution_count": 208, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Now, create a pie chart with languages <2% consolidated into one \"Other Languages\" entry\n", + "\n", + "#calculate percent sum\n", + "#calculate bytes sum\n", + "#filter lang dataframe for > 2%\n", + "#create new dataframe row of sum data and append to filtered dataframe\n", + "\n", + "find_sum = lang[lang['% of total'] < 2].sum()\n", + "\n", + "pct_sum = find_sum['% of total']\n", + "bytes_sum = find_sum['Bytes']\n", + "\n", + "new_row = [\"All other languages, each < 2% of total\",\n", + " bytes_sum,\n", + " pct_sum]\n", + "\n", + "most = lang[lang['% of total'] >= 2].reset_index().drop(columns=['index'])\n", + "most.loc[len(most)] = new_row\n", + "most = most.sort_values(by='% of total', ascending=False).reset_index().drop(columns=['index'])\n", + "print(most)\n", + "\n", + "\n", + "fig2, ax2 = plt.subplots()\n", + "ax2.pie(most[most.columns[1]], labels=most[most.columns[0]], autopct='%1.1f%%',\n", + " shadow=True, startangle=90)\n", + "ax2.axis('equal')" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [], + "source": [ + "#function to return the correct year depending on the first 2 digits of the ascl-id\n", + "def ascl_year(row):\n", + " year = str(row['ascl-id'])[0:2]\n", + " try:\n", + " year = int(year)\n", + " except:\n", + " year = float(year)\n", + " if year > 89:\n", + " return 1900+int(year)\n", + " elif year == 0:\n", + " return None\n", + " else:\n", + " return 2000+int(year)\n", + "\n", + "#now, a function to generate the repo year\n", + "def repo_year(row):\n", + " return row['repo_date'][0:4]\n", + "\n", + "df['ascl_year'] = df.apply (lambda row: ascl_year(row), axis=1)\n", + "df.ascl_year = df.ascl_year.fillna(0.0).astype(int)\n", + "df['repo_year'] = df.apply (lambda row: repo_year(row), axis=1)\n", + "df.repo_year = df.repo_year.fillna(\"0\").astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
YearJavaCC++PythonRubyShell
20080.0000000.5780530.0580890.3613690.0000000.002489
20090.0000000.0016070.4176360.5665790.0000000.014178
20100.0000000.0091530.2706740.7161610.0000000.004011
20110.0000000.1391550.0242590.7860910.0000000.050494
20120.0178040.4566890.1401290.3338530.0000000.051525
20130.2401660.3964100.1659450.1679470.0149560.014577
20140.1314480.3736470.1639970.3164730.0000000.014435
20150.0016000.2194180.2097170.2913590.2695030.008403
20160.0323610.2059680.2348690.4896170.0155210.021665
20170.0000000.1375360.4250450.2367150.0000030.200702
20180.0007080.1862190.2086670.5708270.0000050.033575
20190.1928660.1363250.1532220.5136840.0000000.003903
2020NaNNaNNaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + "Year Java C C++ Python Ruby Shell\n", + "2008 0.000000 0.578053 0.058089 0.361369 0.000000 0.002489\n", + "2009 0.000000 0.001607 0.417636 0.566579 0.000000 0.014178\n", + "2010 0.000000 0.009153 0.270674 0.716161 0.000000 0.004011\n", + "2011 0.000000 0.139155 0.024259 0.786091 0.000000 0.050494\n", + "2012 0.017804 0.456689 0.140129 0.333853 0.000000 0.051525\n", + "2013 0.240166 0.396410 0.165945 0.167947 0.014956 0.014577\n", + "2014 0.131448 0.373647 0.163997 0.316473 0.000000 0.014435\n", + "2015 0.001600 0.219418 0.209717 0.291359 0.269503 0.008403\n", + "2016 0.032361 0.205968 0.234869 0.489617 0.015521 0.021665\n", + "2017 0.000000 0.137536 0.425045 0.236715 0.000003 0.200702\n", + "2018 0.000708 0.186219 0.208667 0.570827 0.000005 0.033575\n", + "2019 0.192866 0.136325 0.153222 0.513684 0.000000 0.003903\n", + "2020 NaN NaN NaN NaN NaN NaN" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#link to how to get stacked area chart\n", + "#https://python-graph-gallery.com/255-percentage-stacked-area-chart/\n", + "\n", + "#x axis - year\n", + "#y axis - percentage of the total\n", + "#for each language, we need an array of languages over years\n", + "\n", + "#let's only take a look at the most popular languages\n", + "\n", + "#each language is a separate row\n", + "#each column is a year, and each cell represents the bytes of that language in that year\n", + "\n", + "repo_years = np.sort(df.repo_year.unique())\n", + "\n", + "#can use either of these, or define your own subset to get different information\n", + "most_bytes_langs = ['Java', 'C', 'C++', 'Python', 'R', 'Fortran', 'Ruby', 'HTML', 'Shell', 'Others']\n", + "language_subset = ['Java', 'C', 'C++', 'Python', 'Ruby', 'Shell']\n", + "\n", + "requested_langs = language_subset\n", + "repo_df = pd.DataFrame({'Language': requested_langs})\n", + "\n", + "def bytes_that_year(row, year):\n", + " #print('trying ' + row['Language'] + ' in year ' + str(year))\n", + " \n", + " if row['Language'] == 'Others':\n", + " #sum up all the non-request_langs bytes\n", + " return df[ ~(df['Language'].isin(requested_langs)) & (df['repo_year'] == year)]['Bytes'].sum()\n", + " lang = row['Language']\n", + " \n", + " try:\n", + " return df[df['repo_year'] == year].groupby('Language').sum().loc[lang]['Bytes']\n", + " except:\n", + " return 0\n", + "\n", + " \n", + "#for each year in repo_years, create a column\n", + "# each cell will be the number of bytes in that year for that language \n", + "\n", + "for year in repo_years:\n", + " #create columns for the total number of bytes\n", + " arr = repo_df.apply (lambda row: bytes_that_year(row, year), axis=1)\n", + " #col_name = str(year) + \" bytes\"\n", + " #repo_df[col_name] = arr\n", + " total_bytes = arr.sum()\n", + " pct_col_name = str(year) #+ \" pct\"\n", + " repo_df[pct_col_name] = arr.divide(total_bytes)\n", + "\n", + "#display(repo_df)\n", + "\n", + "\n", + "#need to get the whole df sideways to make the stackchart easy\n", + "repo_df = repo_df.T\n", + "new_header = repo_df.iloc[0] \n", + "repo_df = repo_df[1:]\n", + "repo_df.columns = new_header\n", + "\n", + "repo_df.columns.name = 'Year'\n", + "repo_df = repo_df.apply(pd.to_numeric, errors='coerce')\n", + "display(repo_df)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
YearJavaCC++PythonRubyShell
20080.0000000.5780530.0580890.3613690.0000000.002489
20090.0000000.0016340.4246160.5593350.0000000.014415
20100.0000000.0181080.7428810.2352320.0000000.003779
20110.0000000.1327690.0248020.7908380.0000000.051591
20120.0181740.4630170.1359440.3302770.0000000.052587
20130.2452340.3948220.1682730.1615160.0152710.014883
20140.1356500.3842750.1687590.2967890.0000000.014526
20150.0017230.2145730.2251170.2593760.2902720.008939
20160.0336680.2128530.2366410.4782050.0161470.022486
20170.0000000.1373410.4123990.2339960.0000030.216262
20180.0007250.1896090.2137740.5616290.0000050.034258
20190.2556980.1722780.0706550.4989160.0000000.002454
2020NaNNaNNaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + "Year Java C C++ Python Ruby Shell\n", + "2008 0.000000 0.578053 0.058089 0.361369 0.000000 0.002489\n", + "2009 0.000000 0.001634 0.424616 0.559335 0.000000 0.014415\n", + "2010 0.000000 0.018108 0.742881 0.235232 0.000000 0.003779\n", + "2011 0.000000 0.132769 0.024802 0.790838 0.000000 0.051591\n", + "2012 0.018174 0.463017 0.135944 0.330277 0.000000 0.052587\n", + "2013 0.245234 0.394822 0.168273 0.161516 0.015271 0.014883\n", + "2014 0.135650 0.384275 0.168759 0.296789 0.000000 0.014526\n", + "2015 0.001723 0.214573 0.225117 0.259376 0.290272 0.008939\n", + "2016 0.033668 0.212853 0.236641 0.478205 0.016147 0.022486\n", + "2017 0.000000 0.137341 0.412399 0.233996 0.000003 0.216262\n", + "2018 0.000725 0.189609 0.213774 0.561629 0.000005 0.034258\n", + "2019 0.255698 0.172278 0.070655 0.498916 0.000000 0.002454\n", + "2020 NaN NaN NaN NaN NaN NaN" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Now, do the same for ascl_year instead of github repo_year\n", + "ascl_years = np.sort(df.ascl_year.unique())\n", + "\n", + "#drop all the codes where the ascl_year is 0 (they have no ascl-id)\n", + "df = df[df['ascl_year'] != 0]\n", + "\n", + "ascl_df = pd.DataFrame({'Language': requested_langs})\n", + "\n", + "\n", + "def bytes_that_year_ascl(row, year):\n", + " #print('trying ' + row['Language'] + ' in year ' + str(year))\n", + " \n", + " if row['Language'] == 'Others':\n", + " #sum up all the non-request_langs bytes\n", + " return df[ ~(df['Language'].isin(requested_langs)) & (df['ascl_year'] == year)]['Bytes'].sum()\n", + " lang = row['Language']\n", + " \n", + " try:\n", + " return df[df['repo_year'] == year].groupby('Language').sum().loc[lang]['Bytes']\n", + " except:\n", + " return 0\n", + "\n", + "for year in repo_years:\n", + " #create columns for the total number of bytes\n", + " arr = ascl_df.apply (lambda row: bytes_that_year_ascl(row, year), axis=1)\n", + " total_bytes = arr.sum()\n", + " pct_col_name = str(year) #+ \" pct\"\n", + " ascl_df[pct_col_name] = arr.divide(total_bytes)\n", + "\n", + "ascl_df = ascl_df.T\n", + "new_header = ascl_df.iloc[0] \n", + "ascl_df = ascl_df[1:]\n", + "ascl_df.columns = new_header\n", + "\n", + "ascl_df.columns.name = 'Year'\n", + "ascl_df = ascl_df.apply(pd.to_numeric, errors='coerce')\n", + "display(ascl_df)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#now, let's create the stacked area chart\n", + "\n", + "plt.stackplot( repo_df.index.values, repo_df.T )\n", + "plt.legend(bbox_to_anchor=(1.25, 1), labels=repo_df.columns)\n", + "plt.margins(0,0)\n", + "plt.title('ASCL Language Data Over the Years (Github Years)')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('% of total language use')\n", + "plt.show()\n", + "\n", + "\n", + "plt.stackplot( ascl_df.index.values, ascl_df.T )\n", + "plt.legend(bbox_to_anchor=(1.25, 1), labels=ascl_df.columns)\n", + "plt.margins(0,0)\n", + "plt.title('ASCL Language Data Over the Years (ASCL Years)')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('% of total language use')\n", + "plt.show()" + ] + } + ], + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}