20220509-pandasmostused/20220509-pandasmostused.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9cd1f8f9-2da5-4690-b980-b77c32705cc4",
   "metadata": {},
   "source": [
    "# Code for \"Parsing 1.2 million Jupyter Notebooks\" video \n",
    "\n",
    "* Download files on `https://library.ucsd.edu/dc/collection/bb6931851t`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9ddeff8-b61b-4114-8284-9d1920511314",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e8743ce-73c9-4b3c-8dad-c134097144f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ast\n",
    "import io\n",
    "import inspect\n",
    "import itertools\n",
    "import matplotlib.pyplot as plt\n",
    "import nbformat\n",
    "import operator\n",
    "import pandas\n",
    "import pickle\n",
    "import plotly.express as px\n",
    "import seaborn as sns\n",
    "import zipfile\n",
    "\n",
    "from collections import Counter\n",
    "from pathlib import Path\n",
    "from IPython.core.inputtransformer2 import TransformerManager\n",
    "from joblib import Parallel, delayed\n",
    "from typing import List\n",
    "\n",
    "import plotly.io as pio\n",
    "pio.templates.default = \"simple_white\"\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "tqdm.pandas()\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad20c0f8-450d-4b58-8377-5d80dadc6186",
   "metadata": {},
   "source": [
    "## 1. Extract notebooks with Pandas in it from zip archives"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8bee34d-c432-4997-94b8-6f61415b0003",
   "metadata": {},
   "source": [
    "### Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9906047-1b6f-4a7e-8afe-2975f866668e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def files_in_zip(p: Path) -> List[str]:\n",
    "    zip_file = zipfile.ZipFile(p)\n",
    "    return zip_file.namelist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe3f655c-d9e0-4cc6-b423-992ec2264e71",
   "metadata": {},
   "source": [
    "### Extracting notebooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "406bfc17-5703-41b4-926d-5693302a7a2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_folder = Path(\"path_to_all_zip_archives\")\n",
    "output_folder = Path(\"path_to_folder_with_extracted_notebooks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8334f108-8ee1-4b56-98af-b27d278720ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "zip_files = list(input_folder.glob(\"./*.zip\"))\n",
    "all_nbs = [file for zip_file in zip_files for file in files_in_zip(zip_file)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0013380-b875-4df5-848d-e8c3e0bf8ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://stackoverflow.com/questions/15282651/how-do-i-read-text-files-within-a-zip-file\n",
    "files_with_pandas = []\n",
    "for path_to_zip in zip_files:\n",
    "    with zipfile.ZipFile(path_to_zip) as zip_file:\n",
    "        path_to_nbs = zip_file.namelist()\n",
    "\n",
    "        for path_to_nb in tqdm(path_to_nbs):\n",
    "            with zip_file.open(path_to_nb) as zf:\n",
    "                with io.TextIOWrapper(zf, encoding=\"utf-8\") as nb_file:\n",
    "                    for line in nb_file.readlines():\n",
    "                        if \"pandas\" in line:\n",
    "                            files_with_pandas.append((path_to_zip, path_to_nb))\n",
    "                            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fcbef48-ef78-46b2-a2a7-5617c7904fe3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"There are {100*len(files_with_pandas)/len(all_nbs):2f}% notebooks with 'Pandas' inside\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3532cf1-b19f-45f3-8862-57039d2662f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "it = itertools.groupby(files_with_pandas, operator.itemgetter(0))\n",
    "for path_to_zip, sublist in it:\n",
    "    nbs_to_extract = list(sublist)\n",
    "    with zipfile.ZipFile(path_to_zip, 'r') as zip_file: \n",
    "        for path_to_nb in tqdm(nbs_to_extract):\n",
    "            zip_file.extract(path_to_nb[1], output_folder) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c688359f-119b-401e-8f32-401081942839",
   "metadata": {},
   "source": [
    "## 2. AST Parsing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d43a47ad-c90d-4c0f-9443-d40585845ed8",
   "metadata": {},
   "source": [
    "### Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7e38d9c-ea67-40ca-929e-a2a5f0e78458",
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_pickle(obj, path):\n",
    "    with open(path, 'wb') as fh:\n",
    "        pickle.dump(obj, fh)\n",
    "        \n",
    "def read_pickle(path):\n",
    "    with (open(path, \"rb\")) as f:\n",
    "        return pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c61f7a0-3529-424a-ae27-0e3fc65b75b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_nb_code(path_nb: str) -> str:\n",
    "    d = nbformat.read(path_nb, as_version=4)\n",
    "    \n",
    "    code = \"\\n\".join(\n",
    "        [cell[\"source\"] for cell in d.cells if cell[\"cell_type\"] == \"code\"]\n",
    "    )\n",
    "    code = TransformerManager().transform_cell(code)\n",
    "    return code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "488023ae-75d1-4b82-baad-764d8a4d18a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_nb(path_nb):\n",
    "    try:\n",
    "        code = get_nb_code(path_nb)\n",
    "    except:\n",
    "        return [{\"error\": \"Parsing notebook\"}]\n",
    "    try:\n",
    "        tree = ast.parse(code)\n",
    "    except:\n",
    "        return [{\"error\": \"Parsing AST\"}]\n",
    "    \n",
    "    res = []\n",
    "    for node in ast.walk(tree):\n",
    "        if isinstance(node, ast.Import):\n",
    "            for alias in node.names:\n",
    "                res.append({\"from\": None, \"name\": alias.name, \"as\": alias.asname})\n",
    "\n",
    "        if isinstance(node, ast.ImportFrom):\n",
    "            for alias in node.names:\n",
    "                res.append({\"from\": node.module, \"name\": alias.name, \"as\": alias.asname})\n",
    "        \n",
    "        if isinstance(node, ast.Attribute):\n",
    "            if isinstance(node.value, ast.Name):\n",
    "                res.append({\"from\": node.value.id, \"call\": node.attr})\n",
    "                \n",
    "        if isinstance(node, ast.Call):\n",
    "            if isinstance(node.func, ast.Name):\n",
    "                res.append({\"from\": \"\", \"call\": node.func.id})\n",
    "                \n",
    "            elif isinstance(node.func, ast.Attribute):\n",
    "                if isinstance(node.func.value, ast.Name):\n",
    "                    res.append({\"from\": node.func.value.id, \"call\": node.func.attr})\n",
    "                #else: \n",
    "                    #res.append({\"type\": type(node.func.value)})\n",
    "            #else: \n",
    "                #res.append({\"type\": type(node.func)})\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39784fdd-c071-4ef6-bc0a-f7e34309992b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_plotly(data, filename):\n",
    "    fig = px.bar(\n",
    "        x=[c[0] for c in data],\n",
    "        y=[c[1] for c in data],\n",
    "        height=2160,\n",
    "        width=3840,\n",
    "    )\n",
    "    fig.update_xaxes(\n",
    "        title_font = {\"size\": 28, \"family\": \"Verdana\"},\n",
    "        title_standoff = 28*2,\n",
    "        title_text =\"Pandas calls\",\n",
    "        tickfont=dict(family='Source Code Pro', size=28),\n",
    "    )\n",
    "    fig.update_yaxes(\n",
    "        title_font = {\"size\": 28, \"family\": \"Verdana\"},\n",
    "        title_standoff = 28*2,\n",
    "        title_text =\"Notebook appearances\",\n",
    "        tickfont=dict(family='Source Code Pro', size=28)\n",
    "    )\n",
    "    fig.write_image(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df3d8efa-8cff-4ee0-a3d3-d402ca736be2",
   "metadata": {},
   "source": [
    "### Parsing all notebooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4979860-e69a-41e0-82e4-dd28393fe8fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder = Path(\"path_to_folder_with_extracted_notebooks\")\n",
    "all_nb_paths = list(folder.glob(\"./*.ipynb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18277fc5-a2e3-4221-b815-fec9b0ff711b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# all_info_nest = [parse_nb(p) for p in tqdm(all_nb_paths)]  # this takes too long\n",
    "all_info_nest = Parallel(n_jobs=9)(delayed(parse_nb)(p) for p in tqdm(all_nb_paths))   # multicore version\n",
    "write_pickle(all_info_nest, \"all_info_nest.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eee3375a-473d-4c99-bb5f-2c61346c8db6",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_info = [info_list for info_list in all_info_nest if not any(\"error\" in ele for ele in info_list)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4de90d3-f6c5-47c3-965a-096bc29e39b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "final_info = [\n",
    "    info_list\n",
    "    for info_list in all_info \n",
    "    if len({f\"{i.get('name')}.{i.get('as')}\" for i in info_list if i.get(\"name\")==\"pandas\"})==1\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a444ae8-1d5d-4baa-8e75-78246fcd1afb",
   "metadata": {},
   "source": [
    "### How many were parsed correctly?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35ce708a-72df-4fc0-9e5a-e89a1cafd53b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Counter([not any(\"error\" in ele for ele in info_list) for info_list in all_info_nest])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8650bd7-c879-4962-ac79-c729cab06681",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"Parseable notebooks\")\n",
    "ax = sns.countplot([not any(\"error\" in ele for ele in info_list) for info_list in all_info_nest])\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d03f7c7-4095-4b0f-981f-a60ce2dd61ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"Type of error\")\n",
    "ax = sns.countplot([info_list[0].get(\"error\") for info_list in all_info_nest if any(\"error\" in ele for ele in info_list)])\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5f9905b-e7fd-482d-b97b-4209d3efb91b",
   "metadata": {},
   "source": [
    "### What Pandas aliases are used?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa64c352-f945-4161-973d-1de3aa643e58",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({None: 11268,\n",
       "         'pd': 264032,\n",
       "         'pan': 21,\n",
       "         'pds': 70,\n",
       "         'py': 4,\n",
       "         'pnd': 82,\n",
       "         'p': 99,\n",
       "         'PD': 8,\n",
       "         'adorable': 1,\n",
       "         'pn': 72,\n",
       "         'pda': 8,\n",
       "         'pa': 57,\n",
       "         'ps': 93,\n",
       "         'panda': 13,\n",
       "         'pandas': 33,\n",
       "         'np': 14,\n",
       "         'arquivo': 2,\n",
       "         'bib': 8,\n",
       "         'pd2': 1,\n",
       "         'PANDAS': 6,\n",
       "         'pp': 1,\n",
       "         'pt': 1,\n",
       "         'df': 2,\n",
       "         'Pd': 1,\n",
       "         'dataframe': 2,\n",
       "         'teddy': 2,\n",
       "         'pdf': 1,\n",
       "         'pandu': 4,\n",
       "         '_pnd': 4,\n",
       "         'pdn': 1,\n",
       "         'pf': 3,\n",
       "         'apd': 1,\n",
       "         'pand': 1,\n",
       "         'P': 1,\n",
       "         'pdbear': 1,\n",
       "         'pdSeries': 1,\n",
       "         'px': 1,\n",
       "         'od': 1,\n",
       "         'pdusers': 1,\n",
       "         'pdmovies': 3,\n",
       "         'pdratings': 2,\n",
       "         'pb': 3,\n",
       "         'pdp': 2,\n",
       "         'pdm': 1,\n",
       "         'ds': 2,\n",
       "         'dp': 2,\n",
       "         'pnds': 4,\n",
       "         'pdr7': 1,\n",
       "         'stock': 1,\n",
       "         'ph': 1,\n",
       "         'DataFrame': 1,\n",
       "         'desmond': 1,\n",
       "         'WHATEVER': 2,\n",
       "         'pdOA': 1,\n",
       "         'pdIn': 1})"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(\n",
    "    [\n",
    "        info.get(\"as\")\n",
    "        for info_list in all_info \n",
    "        for info in info_list\n",
    "        if info.get(\"name\")==\"pandas\"\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bda68641-32ba-4e04-9b05-3913a683ab53",
   "metadata": {},
   "source": [
    "### Are people changing pandas aliases midway?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f835fc2-a01f-4a99-a293-88fde98548cb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 253315), (0, 17392), (2, 977), (3, 2)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter([\n",
    "    len({f\"{i.get('name')}.{i.get('as')}\" for i in info_list if i.get(\"name\")==\"pandas\"})\n",
    "    for info_list in all_info\n",
    "    \n",
    "]).most_common(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eec3378f-bcf1-414c-89fc-676be092ef76",
   "metadata": {},
   "source": [
    "- 0 = probably pandas in markdown\n",
    "- 2/3 = yes there are, less than 1000 on 200_000, let's just remove them"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8b66756-954a-407e-a4ca-7993430bd934",
   "metadata": {},
   "source": [
    "## 3. Counting Pandas calls"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66d44114-1627-46e4-a3ca-ee692a31f5ee",
   "metadata": {},
   "source": [
    "### Top level calls\n",
    "\n",
    "We only count distinct calls per notebook. If 10 pd.Dataframe in notebook, only counts as one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48992d1a-67ed-4574-9274-a7d15e17864f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_top_level_calls(arr):\n",
    "    def compute_alias(d):\n",
    "        top_level_alias = list({i.get('as') for i in d if i.get(\"name\")==\"pandas\"})[0]\n",
    "        if top_level_alias is None:\n",
    "            top_level_alias = \"pandas\"\n",
    "        return top_level_alias\n",
    "        \n",
    "    aliases = [compute_alias(info_list) for info_list in arr]\n",
    "    \n",
    "    res = [\n",
    "        imp\n",
    "        for alias, info_list in zip(aliases, arr)\n",
    "        for imp in {i.get(\"call\") for i in info_list if i.get(\"from\")==alias and \"call\" in i}\n",
    "    ]\n",
    "        \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55ba809d-2927-45d8-ba2c-96c60f770e0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('read_csv', 146753),\n",
       " ('DataFrame', 101974),\n",
       " ('concat', 34973),\n",
       " ('Series', 24485),\n",
       " ('to_datetime', 19266),\n",
       " ('merge', 15445),\n",
       " ('get_dummies', 14061),\n",
       " ('set_option', 11247),\n",
       " ('read_excel', 9359),\n",
       " ('read_table', 6723)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_level_counts = Counter(\n",
    "    find_top_level_calls(final_info)\n",
    ").most_common(10)\n",
    "top_level_counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de3a9329-a108-4679-a02d-ead5c49fdbe2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"Top Level Calls\")\n",
    "ax = sns.barplot(\n",
    "    x=[c[0] for c in top_level_counts],\n",
    "    y=[c[1] for c in top_level_counts],\n",
    ")\n",
    "fig.savefig(\"top_level.png\")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e927b2df-c11b-4360-8979-6c84c22c6ed7",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plotly(top_level_counts, \"top_level.svg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c68686d-03eb-4dcb-8f91-91c71df6f17b",
   "metadata": {},
   "source": [
    "### Compare calls to list of members in inspected Pandas/DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f42afc6e-bf8e-40b9-ba32-e7916842e98b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('BooleanDtype', pandas.core.arrays.boolean.BooleanDtype),\n",
       " ('Categorical', pandas.core.arrays.categorical.Categorical),\n",
       " ('CategoricalDtype', pandas.core.dtypes.dtypes.CategoricalDtype),\n",
       " ('CategoricalIndex', pandas.core.indexes.category.CategoricalIndex),\n",
       " ('DataFrame', pandas.core.frame.DataFrame),\n",
       " ('DateOffset', pandas._libs.tslibs.offsets.DateOffset),\n",
       " ('DatetimeIndex', pandas.core.indexes.datetimes.DatetimeIndex),\n",
       " ('DatetimeTZDtype', pandas.core.dtypes.dtypes.DatetimeTZDtype),\n",
       " ('ExcelFile', pandas.io.excel._base.ExcelFile),\n",
       " ('ExcelWriter', pandas.io.excel._base.ExcelWriter),\n",
       " ('Flags', pandas.core.flags.Flags),\n",
       " ('Float32Dtype', pandas.core.arrays.floating.Float32Dtype),\n",
       " ('Float64Dtype', pandas.core.arrays.floating.Float64Dtype),\n",
       " ('Float64Index', pandas.core.indexes.numeric.Float64Index),\n",
       " ('Grouper', pandas.core.groupby.grouper.Grouper),\n",
       " ('HDFStore', pandas.io.pytables.HDFStore),\n",
       " ('Index', pandas.core.indexes.base.Index),\n",
       " ('Int16Dtype', pandas.core.arrays.integer.Int16Dtype),\n",
       " ('Int32Dtype', pandas.core.arrays.integer.Int32Dtype),\n",
       " ('Int64Dtype', pandas.core.arrays.integer.Int64Dtype),\n",
       " ('Int64Index', pandas.core.indexes.numeric.Int64Index),\n",
       " ('Int8Dtype', pandas.core.arrays.integer.Int8Dtype),\n",
       " ('Interval', pandas._libs.interval.Interval),\n",
       " ('IntervalDtype', pandas.core.dtypes.dtypes.IntervalDtype),\n",
       " ('IntervalIndex', pandas.core.indexes.interval.IntervalIndex),\n",
       " ('MultiIndex', pandas.core.indexes.multi.MultiIndex),\n",
       " ('NamedAgg', pandas.core.groupby.generic.NamedAgg),\n",
       " ('Period', pandas._libs.tslibs.period.Period),\n",
       " ('PeriodDtype', pandas.core.dtypes.dtypes.PeriodDtype),\n",
       " ('PeriodIndex', pandas.core.indexes.period.PeriodIndex),\n",
       " ('RangeIndex', pandas.core.indexes.range.RangeIndex),\n",
       " ('Series', pandas.core.series.Series),\n",
       " ('SparseDtype', pandas.core.arrays.sparse.dtype.SparseDtype),\n",
       " ('StringDtype', pandas.core.arrays.string_.StringDtype),\n",
       " ('Timedelta', pandas._libs.tslibs.timedeltas.Timedelta),\n",
       " ('TimedeltaIndex', pandas.core.indexes.timedeltas.TimedeltaIndex),\n",
       " ('Timestamp', pandas._libs.tslibs.timestamps.Timestamp),\n",
       " ('UInt16Dtype', pandas.core.arrays.integer.UInt16Dtype),\n",
       " ('UInt32Dtype', pandas.core.arrays.integer.UInt32Dtype),\n",
       " ('UInt64Dtype', pandas.core.arrays.integer.UInt64Dtype),\n",
       " ('UInt64Index', pandas.core.indexes.numeric.UInt64Index),\n",
       " ('UInt8Dtype', pandas.core.arrays.integer.UInt8Dtype),\n",
       " ('option_context', pandas._config.config.option_context)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inspect.getmembers(pandas, predicate=inspect.isclass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43466f88-9766-48ba-b878-3fb288e8905e",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_pandas_methods = [func[0] for func in inspect.getmembers(pandas, predicate=inspect.isfunction) if not func[0].startswith(\"__\")]\n",
    "all_pandas_members = [func[0] for func in inspect.getmembers(pandas) if not func[0].startswith(\"__\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a7d92a5-a0bf-47c1-87da-2e281ecc0f30",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_dataframe_methods = [func[0] for func in inspect.getmembers(pandas.DataFrame, predicate=inspect.isfunction) if not func[0].startswith(\"_\")]\n",
    "all_dataframe_members = [func[0] for func in inspect.getmembers(pandas.DataFrame) if not func[0].startswith(\"_\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35d4f37d-5d17-4772-a9df-0135428826bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_pandas_method_calls(arr):    \n",
    "    res = [\n",
    "        imp\n",
    "        for info_list in arr\n",
    "        for imp in {i.get(\"call\") for i in info_list if \"call\" in i and i.get(\"call\") in all_pandas_methods}\n",
    "    ]\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff03bf2f-0839-4f1b-be80-524dda604ce7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_pandas_calls(arr):    \n",
    "    res = [\n",
    "        imp\n",
    "        for info_list in arr\n",
    "        for imp in {i.get(\"call\") for i in info_list if \"call\" in i and i.get(\"call\") in all_pandas_members}\n",
    "    ]\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ef4e559-f946-4c1f-8cb4-a53731ee6ace",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_dataframe_method_calls(arr):    \n",
    "    res = [\n",
    "        imp\n",
    "        for info_list in arr\n",
    "        for imp in {i.get(\"call\") for i in info_list if \"call\" in i and i.get(\"call\") in all_dataframe_methods}\n",
    "    ]\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "803a81c2-b949-4b62-a16a-f1f9a1a4b340",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_dataframe_calls(arr):    \n",
    "    res = [\n",
    "        imp\n",
    "        for info_list in arr\n",
    "        for imp in {i.get(\"call\") for i in info_list if \"call\" in i and i.get(\"call\") in all_dataframe_members}\n",
    "    ]\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b7b2fa2-2b19-4944-8505-d0fcdff9e66b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_answer(arr):    \n",
    "    all_m = [i for i in all_dataframe_members + all_pandas_members] # if i not in [\"unique\", \"\"]]\n",
    "    res = [\n",
    "        imp\n",
    "        for info_list in arr\n",
    "        for imp in {i.get(\"call\") for i in info_list if \"call\" in i and i.get(\"call\") in all_m}\n",
    "    ]\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34b60583-4e46-444b-9c93-438356a96b5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd_level_method_counts = Counter(\n",
    "    find_pandas_method_calls(final_info)\n",
    ").most_common(10)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"Pandas Method calls\")\n",
    "ax = sns.barplot(\n",
    "    x=[c[0] for c in pd_level_method_counts],\n",
    "    y=[c[1] for c in pd_level_method_counts],\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8058110-01c3-4a1b-8bff-c1415e342e76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd_level_member_counts = Counter(\n",
    "    find_pandas_calls(final_info)\n",
    ").most_common(10)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"Pandas Member calls\")\n",
    "ax = sns.barplot(\n",
    "    x=[c[0] for c in pd_level_member_counts],\n",
    "    y=[c[1] for c in pd_level_member_counts],\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a015f91f-2ddd-4a61-bd27-3cf83b0cfb8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_level_method_counts = Counter(\n",
    "    find_dataframe_method_calls(final_info)\n",
    ").most_common(10)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"DataFrame Method calls\")\n",
    "ax = sns.barplot(\n",
    "    x=[c[0] for c in df_level_method_counts],\n",
    "    y=[c[1] for c in df_level_method_counts],\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ffdc854-2028-4a09-950f-b67533833271",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_level_counts = Counter(\n",
    "    find_dataframe_calls(final_info)\n",
    ").most_common(10)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"DataFrame Member calls\")\n",
    "ax = sns.barplot(\n",
    "    x=[c[0] for c in df_level_counts],\n",
    "    y=[c[1] for c in df_level_counts],\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0a6cacd-6423-4e2c-b9fe-319a88052613",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "this_is_it = Counter(\n",
    "    final_answer(final_info)\n",
    ").most_common(10)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,6))\n",
    "\n",
    "ax.set_title(\"All Pandas/DataFrame calls\")\n",
    "ax = sns.barplot(\n",
    "    x=[c[0] for c in this_is_it],\n",
    "    y=[c[1] for c in this_is_it],\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c262711-46f8-4716-83f3-4a8fe84d739c",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plotly(df_level_counts, \"df_level.svg\")\n",
    "save_plotly(df_level_method_counts, \"df_level_methods.svg\")\n",
    "save_plotly(this_is_it, \"this_is_it.svg\")"
   ]
  }
 ],
 "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}