jupyter/ExternalDependenciesTypescript.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2f0eabc4",
   "metadata": {},
   "source": [
    "# External Dependencies for Typescript\n",
    "<br>  \n",
    "\n",
    "### References\n",
    "- [jqassistant](https://jqassistant.org)\n",
    "- [Neo4j Python Driver](https://neo4j.com/docs/api/python-driver/current)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4191f259",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plot\n",
    "from neo4j import GraphDatabase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c5dab37",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Please set the environment variable \"NEO4J_INITIAL_PASSWORD\" in your shell \n",
    "# before starting jupyter notebook to provide the password for the user \"neo4j\". \n",
    "# It is not recommended to hardcode the password into jupyter notebook for security reasons.\n",
    "\n",
    "driver = GraphDatabase.driver(uri=\"bolt://localhost:7687\", auth=(\"neo4j\", os.environ.get(\"NEO4J_INITIAL_PASSWORD\")))\n",
    "driver.verify_connectivity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1db254b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cypher_query_from_file(filename):\n",
    "    with open(filename) as file:\n",
    "        return ' '.join(file.readlines())\n",
    "\n",
    "\n",
    "def query_cypher_to_data_frame(filename):\n",
    "    records, summary, keys = driver.execute_query(get_cypher_query_from_file(filename))\n",
    "    return pd.DataFrame([r.values() for r in records], columns=keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da9e8edb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def group_to_others_below_threshold(data_frame : pd.DataFrame, value_column : str, name_column: str, threshold: float) -> pd.DataFrame:    \n",
    "    \"\"\"\n",
    "    Adds a new percentage column for the value column and \n",
    "    groups all values below the given threshold to \"others\" in the name column.\n",
    "\n",
    "    Parameters:\n",
    "    - data_frame (pd.DataFrame): Input pandas DataFrame\n",
    "    - value_column (str): Name of the column that contains the numeric value\n",
    "    - name_column (str): Name of the column that contains the group name that will be replaced by \"others\" for small values\n",
    "    - threshold (float): Threshold in % that is used to group values below it into the \"others\" group\n",
    "\n",
    "    Returns:\n",
    "    int:Returning value\n",
    "\n",
    "    \"\"\"\n",
    "    result_data_frame = data_frame[[name_column, value_column]].copy();\n",
    "\n",
    "    percent_column_name = value_column + 'Percent';\n",
    "\n",
    "    # Add column with the name given in \"percent_column_name\" with the percentage of the value column.\n",
    "    result_data_frame[percent_column_name] = result_data_frame[value_column] / result_data_frame[value_column].sum() * 100.0;\n",
    "\n",
    "    # Convert name column to string values if it wasn't of that type before\n",
    "    result_data_frame[name_column] = result_data_frame[name_column].astype(str)\n",
    "\n",
    "    # Change the group name to \"others\" if it is called less than the specified threshold\n",
    "    result_data_frame.loc[result_data_frame[percent_column_name] < threshold, name_column] = 'others';\n",
    "\n",
    "    # Group by name column (foremost the new \"others\" entries) and sum their percentage\n",
    "    #result_data_frame = result_data_frame.groupby(name_column)[percent_column_name].sum();\n",
    "    result_data_frame = result_data_frame.groupby(name_column).sum();\n",
    "    # Sort by values descending\n",
    "    #return result_data_frame.sort_values(ascending=False).to_frame();\n",
    "    return result_data_frame.sort_values(by=percent_column_name, ascending=False);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe7da2e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_values_below_threshold(data_frame : pd.DataFrame, value_column : str, upper_limit: float = 100.0) -> pd.DataFrame:    \n",
    "    \"\"\"\n",
    "    Adds a new percentage column for the value column and \n",
    "    groups all values below the given threshold to \"others\" in the name column.\n",
    "\n",
    "    Parameters:\n",
    "    - data_frame (pd.DataFrame): Input pandas DataFrame\n",
    "    - value_column (str): Name of the column that contains the numeric value\n",
    "    - upper_limit (float): Defaults to 100%. Filters out all entries exceeding this limit. Intended to drill down \"others\" in a second chart/table.\n",
    "\n",
    "    Returns:\n",
    "    int:Returning value\n",
    "\n",
    "    \"\"\"\n",
    "    result_data_frame = data_frame.copy();\n",
    "\n",
    "    percent_column_name = value_column + 'Percent';\n",
    "\n",
    "    # Add column with the name given in \"percent_column_name\" with the percentage of the value column.\n",
    "    result_data_frame[percent_column_name] = result_data_frame[value_column] / result_data_frame[value_column].sum() * 100.0;\n",
    "\n",
    "    # Limit entries to meet the an optional upper limit (in percentage)\n",
    "    result_data_frame = result_data_frame.query(\"`\" + percent_column_name + \"` <= \" + str(upper_limit))\n",
    "\n",
    "    result_data_frame = result_data_frame.reset_index(drop=True)\n",
    "    return result_data_frame.sort_values(by=percent_column_name, ascending=False);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9deaabce",
   "metadata": {
    "tags": [
     "table-css"
    ]
   },
   "outputs": [],
   "source": [
    "def explode_index_value(input_data_frame: pd.DataFrame, index_value_to_emphasize: str = 'others', base_value: float = 0.02, emphasize_value: float = 0.2):\n",
    "    \"\"\"\n",
    "    \"Explode\" offsets slices in a pie chart plot by a given value.\n",
    "    The specified index value will be emphasized with a larger value to make it stand out in the pie chart plot.\n",
    "\n",
    "    Parameters:\n",
    "    - input_data_frame (pd.DataFrame): Input pandas DataFrame with the data that will be plot. (Required)\n",
    "    - index_value_to_emphasize (str): Value of the index that will be emphasized. (Default= 'others')\n",
    "    - base_value (float): Base value for all pies in the chart. (Default=0.02)\n",
    "    - emphasize_value (float): Value for the emphasized pie in the chart. (Default=0.2)\n",
    "\n",
    "    Returns:\n",
    "    Array with the same size as the number of rows/pies to plot containing the \"explode\" value for each of them\n",
    "\n",
    "    \"\"\"\n",
    "    # Each entry in the list corresponds to an x value\n",
    "    # The comparison with the index_value_to_emphasize produces an array of booleans where nth entry with the emphasized value is \"true\"\n",
    "    # Multiplying it leads to 1 for True and 0 for False therefore \"exploding\" the emphasized entry whilst \n",
    "    return (input_data_frame.index == index_value_to_emphasize) * emphasize_value + base_value     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2496caf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pie_chart(input_data_frame: pd.DataFrame, title: str):\n",
    "    if input_data_frame.empty:\n",
    "        print(\"No data to plot for title '\" + title + \"'.\")\n",
    "        return\n",
    "    \n",
    "    name_of_the_first_column_containing_the_values=input_data_frame.columns[0]\n",
    "    total_sum = input_data_frame[name_of_the_first_column_containing_the_values].sum()\n",
    "    \n",
    "    def custom_auto_percentage_format(percentage):\n",
    "        return '{:1.2f}% ({:.0f})'.format(percentage, total_sum * percentage / 100.0)\n",
    "        \n",
    "    plot.figure();\n",
    "\n",
    "    axis = input_data_frame.plot(\n",
    "        kind='pie',\n",
    "        y=name_of_the_first_column_containing_the_values + 'Percent',\n",
    "        ylabel='',\n",
    "        legend=True,\n",
    "        labeldistance=None,\n",
    "        autopct=custom_auto_percentage_format,\n",
    "        textprops={'fontsize': 6},\n",
    "        pctdistance=1.15,\n",
    "        cmap=main_color_map,\n",
    "        figsize=(9,9),\n",
    "        explode=explode_index_value(input_data_frame, index_value_to_emphasize='others')\n",
    "    )\n",
    "    plot.title(title, pad=15)\n",
    "    axis.legend(bbox_to_anchor=(1.08, 1), loc='upper left')\n",
    "    plot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da9e8edb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#The following cell uses the build-in %html \"magic\" to override the CSS style for tables to a much smaller size.\n",
    "#This is especially needed for PDF export of tables with multiple columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9deaabce",
   "metadata": {
    "tags": [
     "table-css"
    ]
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<style>\n",
    "/* CSS style for smaller dataframe tables. */\n",
    ".dataframe th {\n",
    "    font-size: 8px;\n",
    "}\n",
    ".dataframe td {\n",
    "    font-size: 8px;\n",
    "}\n",
    "</style>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2496caf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Main Colormap\n",
    "main_color_map = 'nipy_spectral'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6705e06a",
   "metadata": {},
   "source": [
    "## External Typescript Module Usage\n",
    "\n",
    "### External Module\n",
    "\n",
    "An external Typescript module is marked with the label `ExternalModule` and the declarations it provides with  `ExternalDeclaration`. In practice, the distinction between internal and external isn't always that clear. When there is a problem following the project configuration like discussed in [Missing Interfaces and other elements in the Graph](https://github.com/jqassistant-plugin/jqassistant-typescript-plugin/issues/35), some internal dependencies might be imported as external ones. \n",
    "\n",
    "To have a second indicator, the property `isNodeModule` is written with [Add_module_properties.cypher](./../cypher/Typescript_Enrichment/Add_module_properties.cypher) in [prepareAnalysis.sh](./../scripts/prepareAnalysis.sh). For most package managers this should then be sufficient. As of now (June 2024), it might not work with [Yarn Plug'n'Play](https://yarnpkg.com/features/pnp)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "334167e4",
   "metadata": {},
   "source": [
    "### Table 1 - Top 20 most used external packages overall\n",
    "\n",
    "This table shows the external packages that are used by the most different internal types overall.\n",
    "Additionally, it shows which types of the external modules are actually used. External annotations are also listed.\n",
    "\n",
    "Only the top 20 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_module_usage_overall_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *externalModuleName* is the name of the external module prepended by its namespace if given. Example: \"@types/react\"\n",
    "- *numberOfExternalCallerModules* is the number of modules that use that external module\n",
    "- *numberOfExternalCallerElements* is the number of elements (functions, classes,...) that use that external module\n",
    "- *numberOfExternalDeclarationCalls* is how often the external declarations of that external module are imported\n",
    "- *numberOfExternalDeclarationCallsWeighted* is how often the external declarations of that external module are actually used\n",
    "- *allModules* contains the total count of all analyzed internal modules\n",
    "- *allInternalElements* contains the total count of all analyzed exported internal elements (function, classes,...)\n",
    "- *exampleStories* contains a list of sentences that contain concrete examples (for explanation and debugging)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff524ac7",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_module_usage=query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_module_usage_overall_for_Typescript.cypher\")\n",
    "\n",
    "# Select columns and only show the first 20 entries (head)\n",
    "external_module_usage.head(20)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1143afcb",
   "metadata": {},
   "source": [
    "#### Table 1 Chart 1a - Most called external modules in % by internal elements (more than 0.7% overall)\n",
    "\n",
    "External modules that are used less than 0.7% are grouped into \"others\" to get a cleaner chart\n",
    "containing the most significant external modules and how ofter they are called by internal elements in percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "243f2908",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_module_by_internal_element_usage_significant = group_to_others_below_threshold(\n",
    "    data_frame=external_module_usage,\n",
    "    value_column='numberOfExternalCallerElements',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.7\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_module_by_internal_element_usage_significant,\n",
    "    title='Top external module usage [%] by internal elements (more than 0.7% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d59d7924",
   "metadata": {},
   "source": [
    "#### Table 1 Chart 1b - Most called external modules in % by internal elements (less than 0.7% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.7% overall) most called external modules. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81be06d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_module_by_internal_element_usage_drill_down_others=filter_values_below_threshold(external_module_usage, 'numberOfExternalCallerElements', 0.7)\n",
    "\n",
    "external_module_by_internal_element_usage_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_module_by_internal_element_usage_drill_down_others,\n",
    "    value_column='numberOfExternalCallerElements',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_module_by_internal_element_usage_significant_drill_down_others,\n",
    "    title='Top external module usage [%] by internal elements  (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84c123dc",
   "metadata": {},
   "source": [
    "#### Table 1 Chart 2a - Most called external modules in % by internal modules (more than 0.7% overall)\n",
    "\n",
    "External modules that are used less than 0.7% are grouped into \"others\" to get a cleaner chart\n",
    "containing the most significant external modules and how ofter they are called by internal modules in percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c165f403",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_module_used_by_internal_modules_significant = group_to_others_below_threshold(\n",
    "    data_frame=external_module_usage,\n",
    "    value_column='numberOfExternalCallerModules',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.7\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_module_used_by_internal_modules_significant,\n",
    "    title='Top external module usage [%] by internal modules (more than 0.7% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5a33ad1",
   "metadata": {},
   "source": [
    "#### Table 1 Chart 2b - Most called external modules in % by internal modules (less than 0.7% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.7% overall) most called external modules. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72104f22",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_module_used_by_internal_modules_drill_down_others=filter_values_below_threshold(external_module_usage, 'numberOfExternalCallerModules', 0.7)\n",
    "\n",
    "external_module_used_by_internal_modules_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_module_used_by_internal_modules_drill_down_others,\n",
    "    value_column='numberOfExternalCallerModules',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_module_used_by_internal_modules_significant_drill_down_others,\n",
    "    title='Top external module usage [%] by internal modules (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb92e603",
   "metadata": {},
   "source": [
    "### Table 2 - Top 20 most used external namespaces\n",
    "\n",
    "This table shows external namespaces that are used by the most different internal elements (functions, classes,...) overall. \n",
    "\n",
    "Additionally, it shows how many of the declarations of the external namespace are actually used.\n",
    "\n",
    "Only the top 20 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_namespace_usage_overall_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *externalNamespaceName* is the name of the external namespace (empty if none). Example: \"@types\". All other columns are aggregated/grouped by it.\n",
    "- *numberOfExternalCallerModules* is the number of modules that use that external module\n",
    "- *numberOfExternalCallerElements* is the number of elements (functions, classes,...) that use that external module\n",
    "- *numberOfExternalDeclarationCalls* is how often the external declarations of that external module are imported\n",
    "- *numberOfExternalDeclarationCallsWeighted* is how often the external declarations of that external module are actually used\n",
    "- *allModules* contains the total count of all analyzed internal modules\n",
    "- *allInternalElements* contains the total count of all analyzed exported internal elements (function, classes,...)\n",
    "- *exampleStories* contains a list of sentences that contain concrete examples (for explanation and debugging)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dc5e771",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_usage=query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_namespace_usage_overall_for_Typescript.cypher\")\n",
    "external_namespace_usage.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "279932a6",
   "metadata": {},
   "source": [
    "#### Table 2 Chart 1a - Most called external namespaces in % by internal element (more than 0.7% overall)\n",
    "\n",
    "External namespaces that are used less than 0.7% are grouped into \"others\" to get a cleaner chart\n",
    "containing the most significant external namespaces and how ofter they are called by internal elements in percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d36043f",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_use_by_internal_elements_significantly = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_usage,\n",
    "    value_column='numberOfExternalCallerElements',\n",
    "    name_column='externalNamespaceName',\n",
    "    threshold= 0.7\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_use_by_internal_elements_significantly,\n",
    "    title='Top external namespace usage [%] by internal elements (more than 0.7% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1372eff1",
   "metadata": {},
   "source": [
    "#### Table 2 Chart 1a - Most called external namespaces in % by internal element (less than 0.7% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.7% overall) most called external namespaces. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ef25c8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_use_by_internal_elements_drill_down_others=filter_values_below_threshold(external_namespace_usage, 'numberOfExternalCallerElements', 0.7)\n",
    "\n",
    "external_namespace_use_by_internal_elements_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_use_by_internal_elements_drill_down_others,\n",
    "    value_column='numberOfExternalCallerElements',\n",
    "    name_column='externalNamespaceName',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_use_by_internal_elements_significant_drill_down_others,\n",
    "    title='Top external namespace usage [%] by internal elements (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43c3e1a3",
   "metadata": {},
   "source": [
    "#### Table 2 Chart 2a - Most called external namespaces in % by internal modules (more than 0.7% overall)\n",
    "\n",
    "External namespaces that are used less than 0.7% are grouped into \"others\" to get a cleaner chart\n",
    "containing the most significant external namespaces and how ofter they are called by internal modules in percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f05314f",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_used_by_internal_modules_significantly = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_usage,\n",
    "    value_column='numberOfExternalCallerModules',\n",
    "    name_column='externalNamespaceName',\n",
    "    threshold= 0.7\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_used_by_internal_modules_significantly,\n",
    "    title='Top external namespace usage [%] by internal modules (more than 0.7% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "665ba73f",
   "metadata": {},
   "source": [
    "#### Table 2 Chart 2b - Most called external namespaces in % by internal modules (less than 0.7% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.7% overall) most called external namespaces. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8107fd74",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_used_by_internal_modules_drill_down_others=filter_values_below_threshold(external_namespace_usage, 'numberOfExternalCallerModules', 0.7)\n",
    "\n",
    "external_namespace_used_by_internal_modules_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_used_by_internal_modules_drill_down_others,\n",
    "    value_column='numberOfExternalCallerModules',\n",
    "    name_column='externalNamespaceName',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_used_by_internal_modules_significant_drill_down_others,\n",
    "    title='Top external namespace usage [%] by internal modules (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fb30664",
   "metadata": {},
   "source": [
    "### Table 3 - Top 20 most widely spread external modules\n",
    "\n",
    "The following tables shows external modules that are used by many different internal modules with the highest number of artifacts first.\n",
    "\n",
    "Statistics like minimum, maximum, average, median and standard deviation are provided for the number of internally exported elements (function, class, ...) and the external declarations they use for every external module. \n",
    "\n",
    "The intuition behind that is to find external modules and the external declarations they provide that are used in a widely spread manner. This can help to distinguish widely used libraries and frameworks from external modules that are used for specific tasks. It can also be used to find external modules that are used sparsely regarding internal modules but where many different external declarations are used. \n",
    "\n",
    "Refactoring with [Hexagonal architecture](https://alistair.cockburn.us/hexagonal-architecture) in mind can be considered for non-framework external modules that are used for very specific tasks and that are used in many different internal locations. This makes the internal code more robust against changes of these external modules or it is easier to update and migrate to newer versions of them. \n",
    "\n",
    "External modules that are only used in very few internal locations overall might be considered for removal if they are easy to replace with a similar library that is already used more often. Or they might also simply be replaced by very few lines of code. Replacing libraries with own code isn't recommended when you need to write a lot of code or for external modules that provide security relevant implementations (encryption, sanitizers, ...), because they will be tracked and maintained globally and security updates need to be adopted fast.\n",
    "\n",
    "Only the top 20 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_module_usage_spread_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *externalModuleName* is the name of the external package prepended by its namespace if given. Example: \"@types/react\"\n",
    "external package.\n",
    "- *numberOfInternalModules* is the number of internal modules that are using that external module\n",
    "- *\\[min,max,med,avg,std\\]NumberOfUsedExternalDeclarations* provide statistics for all internal modules and how their usage of the declarations provided by the external module are distributed. This provides an indicator on how strong the coupling to the external module is. For example, if many (high sum) elements provided by that external module are used constantly (low std), a higher coupling can be presumed. If there is only one (sum) element in use, this could be an indicator for an external module that could get replaced or that there is just one central entry point for it.\n",
    "- *\\[min/max/med/avg/std\\]NumberOfInternalElements* provide statistics for all internal modules and how their usage of the external module is distributed across their internal elements. This provides an indicator on how widely an external module is spread across internal elements and if there are great differences between internal modules (high standard deviation) or not.\n",
    "- *\\[min/max/med/avg/std\\]NumberOfInternalElementsPercentage* is similar to [min/max/med/avg/std]NumberOfUsedExternalDeclarations but provides the value in percent in relation to the total number of internal elements per internal module.\n",
    "- *internalModuleExamples* some examples of included internal modules for debugging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad1a04c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Query the graph database to provide the \n",
    "# most widely spread external dependencies for the tables/charts below.\n",
    "external_module_usage_spread=query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_module_usage_spread_for_Typescript.cypher\")\n",
    "external_module_usage_spread.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ed201cc",
   "metadata": {},
   "source": [
    "### Table 3a - Top 20 most widely spread external packages - number of internal modules\n",
    "\n",
    "This table shows the top 20 most widely spread external packages focussing on the spread across the number of internal modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5fa9f9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_spread_packages=external_module_usage_spread[['externalModuleName', 'numberOfInternalModules', 'minNumberOfInternalElements', 'maxNumberOfInternalElements', 'medNumberOfInternalElements', 'avgNumberOfInternalElements', 'stdNumberOfInternalElements']]\n",
    "external_package_usage_spread_packages.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27c5b75f",
   "metadata": {},
   "source": [
    "### Table 3b - Top 20 most widely spread external packages - percentage of internal modules\n",
    "\n",
    "This table shows the top 20 most widely spread external packages focussing on the spread across the percentage of internal modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4d4273e",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_spread_packages_percentage=external_module_usage_spread[['externalModuleName', 'numberOfInternalModules', 'minNumberOfInternalElementsPercentage', 'maxNumberOfInternalElementsPercentage', 'medNumberOfInternalElementsPercentage', 'avgNumberOfInternalElementsPercentage', 'stdNumberOfInternalElementsPercentage']]\n",
    "external_package_usage_spread_packages_percentage.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7638e05",
   "metadata": {},
   "source": [
    "### Table 3c - Top 20 most widely spread external packages - number of internal elements\n",
    "\n",
    "This table shows the top 20 most widely spread external packages focussing on the spread across the number of internal elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f5af910",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_spread_types=external_module_usage_spread[['externalModuleName', 'numberOfInternalModules', 'minNumberOfInternalElements', 'maxNumberOfInternalElements', 'medNumberOfInternalElements', 'avgNumberOfInternalElements', 'stdNumberOfInternalElements']]\n",
    "external_package_usage_spread_types.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07427cd5",
   "metadata": {},
   "source": [
    "### Table 3d - Top 20 most widely spread external packages - percentage of internal elements\n",
    "\n",
    "This table shows the top 20 most widely spread external packages focussing on the spread across the percentage of internal elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50712f90",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_spread_types_percentage=external_module_usage_spread[['externalModuleName', 'numberOfInternalModules', 'minNumberOfInternalElementsPercentage', 'maxNumberOfInternalElementsPercentage', 'medNumberOfInternalElementsPercentage', 'avgNumberOfInternalElementsPercentage', 'stdNumberOfInternalElementsPercentage']]\n",
    "external_package_usage_spread_types_percentage.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b210eea0",
   "metadata": {},
   "source": [
    "#### Table 3 Chart 1a - Most widely spread external module in % by internal elements (more than 0.5% overall)\n",
    "\n",
    "External modules that are used less than 0.5% are grouped into the name \"others\" to get a cleaner chart with the most significant external module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f41d04c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_module_by_internal_element_usage_spread_significant = group_to_others_below_threshold(\n",
    "    data_frame=external_module_usage_spread,\n",
    "    value_column='sumNumberOfInternalElements',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.5\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_module_by_internal_element_usage_spread_significant,\n",
    "    title='Top external module usage spread [%] by internal elements (more than 0.5% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02b7f814",
   "metadata": {},
   "source": [
    "#### Table 3 Chart 1b - Most widely spread external modules in % by types (less than 0.5% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.5% overall) most widely spread external modules. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a63c9a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_module_by_internal_element_usage_spread_drill_down_others=filter_values_below_threshold(external_module_usage_spread, 'sumNumberOfInternalElements', 0.5)\n",
    "\n",
    "external_module_by_internal_element_usage_spread_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_module_by_internal_element_usage_spread_drill_down_others,\n",
    "    value_column='sumNumberOfInternalElements',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_module_by_internal_element_usage_spread_significant_drill_down_others,\n",
    "    title='Top external module usage spread [%] by internal elements (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c48740e3",
   "metadata": {},
   "source": [
    "#### Table 3 Chart 2a - Most widely spread external modules in % by internal modules (more than 0.5% overall)\n",
    "\n",
    "External modules that are used less than 0.5% are grouped into \"others\" to get a cleaner chart containing the most significant external modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bb7b0d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_modules_used_by_internal_modules_spread_significant = group_to_others_below_threshold(\n",
    "    data_frame=external_module_usage_spread,\n",
    "    value_column='numberOfInternalModules',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.5\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_modules_used_by_internal_modules_spread_significant,\n",
    "    title='Top external module usage spread [%] by internal modules (more than 0.5% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aa7569b",
   "metadata": {},
   "source": [
    "#### Table 3 Chart 2b - Most widely spread external modules in % by internal modules (less than 0.5% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.5% overall) most widely spread external modules. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ce91cf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_modules_used_by_internal_modules_spread_drill_down_others=filter_values_below_threshold(external_module_usage_spread, 'numberOfInternalModules', 0.5)\n",
    "\n",
    "external_modules_used_by_internal_modules_spread_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_modules_used_by_internal_modules_spread_drill_down_others,\n",
    "    value_column='numberOfInternalModules',\n",
    "    name_column='externalModuleName',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_modules_used_by_internal_modules_spread_significant_drill_down_others,\n",
    "    title='Top external module usage spread [%] by internal modules (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d6762ea",
   "metadata": {},
   "source": [
    "### Table 4 - Top 20 most widely spread external namespaces\n",
    "\n",
    "This table shows external namespaces that are used by different internal modules with the most used first. \n",
    "\n",
    "Statistics like minimum, maximum, average, median and standard deviation are provided for the number of internally exported elements (function, class, ...) and the external declarations they use for every external namespace. \n",
    "\n",
    "The intuition behind that is to find external namespaces that are used in a widely spread manner. This can help to distinguish widely used libraries and frameworks from external modules that are used for specific tasks. It can also be used to find external modules that are used sparsely regarding internal modules but where many different external declarations are used. \n",
    "\n",
    "Refactoring with a [Hexagonal architecture](https://alistair.cockburn.us/hexagonal-architecture) in mind can be considered for non-framework external namespaces that are used for very specific tasks and that are used in many different internal locations. This makes the internal code more robust against changes of these external modules or it is easier to update and migrate to newer versions of them. \n",
    "\n",
    "External namespaces that are only used in very few internal locations overall might be considered for removal if they are easy to replace with a similar library that is already used more often. Or they might also simply be replaced by very few lines of code. Replacing libraries with own code isn't recommended when you need to write a lot of code or for external modules that provide security relevant implementations (encryption, sanitizers, ...), because they will be tracked and maintained globally and security updates need to be adopted fast.\n",
    "\n",
    "Only the top 20 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_namespace_usage_spread_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *externalModuleNamespace* identifies the external namespace for at least on external module in use. All other columns contain aggregated data for it.\n",
    "- *numberOfInternalModules* is the number of internal modules that are using that external module\n",
    "- *\\[min,max,med,avg,std\\]NumberOfUsedExternalDeclarations* provide statistics for all internal modules and how their usage of the declarations provided by the external module are distributed. This provides an indicator on how strong the coupling to the external module is. For example, if many (high sum) elements provided by that external module are used constantly (low std), a higher coupling can be presumed. If there is only one (sum) element in use, this could be an indicator for an external module that could get replaced or that there is just one central entry point for it.\n",
    "- *\\[min/max/med/avg/std\\]NumberOfInternalElements* provide statistics for all internal modules and how their usage of the external module is distributed across their internal elements. This provides an indicator on how widely an external module is spread across internal elements and if there are great differences between internal modules (high standard deviation) or not.\n",
    "- *\\[min/max/med/avg/std\\]NumberOfInternalElementsPercentage* is similar to [min/max/med/avg/std]NumberOfUsedExternalDeclarations but provides the value in percent in relation to the total number of internal elements per internal module.\n",
    "- *internalModuleExamples* some examples of included internal modules for debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6cde5e6",
   "metadata": {},
   "source": [
    "### Table 4 - Top 20 most widely spread external namespaces\n",
    "\n",
    "This table shows external namespaces that are used by different internal modules with the most used first. \n",
    "\n",
    "Statistics like minimum, maximum, average, median and standard deviation are provided for the number of internally exported elements (function, class, ...) and the external declarations they use for every external namespace. \n",
    "\n",
    "The intuition behind that is to find external namespaces that are used in a widely spread manner. This can help to distinguish widely used libraries and frameworks from external modules that are used for specific tasks. It can also be used to find external modules that are used sparsely regarding internal modules but where many different external declarations are used. \n",
    "\n",
    "Refactoring with a [Hexagonal architecture](https://alistair.cockburn.us/hexagonal-architecture) in mind can be considered for non-framework external namespaces that are used for very specific tasks and that are used in many different internal locations. This makes the internal code more robust against changes of these external modules or it is easier to update and migrate to newer versions of them. \n",
    "\n",
    "External namespaces that are only used in very few internal locations overall might be considered for removal if they are easy to replace with a similar library that is already used more often. Or they might also simply be replaced by very few lines of code. Replacing libraries with own code isn't recommended when you need to write a lot of code or for external modules that provide security relevant implementations (encryption, sanitizers, ...), because they will be tracked and maintained globally and security updates need to be adopted fast.\n",
    "\n",
    "Only the top 20 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_namespace_usage_spread_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *externalModuleNamespace* identifies the external namespace for at least on external module in use. All other columns contain aggregated data for it.\n",
    "- *numberOfInternalModules* is the number of internal modules that are using that external module\n",
    "- *\\[min,max,med,avg,std\\]NumberOfUsedExternalDeclarations* provide statistics for all internal modules and how their usage of the declarations provided by the external module are distributed. This provides an indicator on how strong the coupling to the external module is. For example, if many (high sum) elements provided by that external module are used constantly (low std), a higher coupling can be presumed. If there is only one (sum) element in use, this could be an indicator for an external module that could get replaced or that there is just one central entry point for it.\n",
    "- *\\[min/max/med/avg/std\\]NumberOfInternalElements* provide statistics for all internal modules and how their usage of the external module is distributed across their internal elements. This provides an indicator on how widely an external module is spread across internal elements and if there are great differences between internal modules (high standard deviation) or not.\n",
    "- *\\[min/max/med/avg/std\\]NumberOfInternalElementsPercentage* is similar to [min/max/med/avg/std]NumberOfUsedExternalDeclarations but provides the value in percent in relation to the total number of internal elements per internal module.\n",
    "- *internalModuleExamples* some examples of included internal modules for debugging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afd344dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_usage_spread=query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_namespace_usage_spread_for_Typescript.cypher\")\n",
    "external_namespace_usage_spread.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04840973",
   "metadata": {},
   "source": [
    "#### Table 4 Chart 1a - Most widely spread external namespaces in % by internal element (less than 0.5% overall)\n",
    "\n",
    "External namespaces that are used less than 0.5% are grouped into \"others\" to get a cleaner chart\n",
    "containing the most significant external namespaces and how ofter they are called in percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5e7c339",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_usage_significant = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_usage_spread,\n",
    "    value_column='sumNumberOfInternalElements',\n",
    "    name_column='externalModuleNamespace',\n",
    "    threshold= 0.5\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_usage_significant,\n",
    "    title='Top external namespace usage spread [%] by internal elements (less than 0.5% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9d4eadb",
   "metadata": {},
   "source": [
    "#### Table 4 Chart 1b - Most widely spread external namespaces in % by internal element (less than 0.5% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.5% overall) most widely spread external namespaces. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cdd53bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_usage_spread_drill_down_others=filter_values_below_threshold(external_namespace_usage_spread, 'sumNumberOfInternalElements', 0.5)\n",
    "\n",
    "external_namespace_usage_spread_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_usage_spread_drill_down_others,\n",
    "    value_column='sumNumberOfInternalElements',\n",
    "    name_column='externalModuleNamespace',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_usage_spread_significant_drill_down_others,\n",
    "    title='Top external namespace usage spread [%] by internal elements (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb678b02",
   "metadata": {},
   "source": [
    "#### Table 4 Chart 2a - Most widely spread external namespace in % by internal modules (more than 0.5% overall)\n",
    "\n",
    "External namespaces that are used less than 0.5% are grouped into \"others\" to get a cleaner chart\n",
    "containing the most significant external namespaces and how ofter they are called in percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d74f8422",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_internal_module_usage_spread_significant = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_usage_spread,\n",
    "    value_column='numberOfInternalModules',\n",
    "    name_column='externalModuleNamespace',\n",
    "    threshold= 0.5\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_internal_module_usage_spread_significant,\n",
    "    title='Top external namespace usage spread [%] by internal modules (more than 0.5% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e766c689",
   "metadata": {},
   "source": [
    "#### Table 4 Chart 2b - Most widely spread external namespace in % by internal modules (less than 0.5% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.5% overall) most widely spread external namespaces. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99dc8d15",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_internal_module_usage_spread_drill_down_others=filter_values_below_threshold(external_namespace_usage_spread, 'numberOfInternalModules', 0.5)\n",
    "\n",
    "external_namespace_internal_module_usage_spread_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_internal_module_usage_spread_drill_down_others,\n",
    "    value_column='numberOfInternalModules',\n",
    "    name_column='externalModuleNamespace',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_internal_module_usage_spread_significant_drill_down_others,\n",
    "    title='Top external namespace usage spread [%] by internal modules (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14e4da22",
   "metadata": {},
   "source": [
    "#### Table 4 Chart 3a - External namespaces with the most used declarations in % (more than 0.5% overall)\n",
    "\n",
    "External namespaces that are used less than 0.5% are grouped into \"others\" to get a cleaner chart\n",
    "containing the most significant external namespaces and how ofter they are called in percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "409db3b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_declaration_usage_significant = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_usage_spread,\n",
    "    value_column='sumNumberOfUsedExternalDeclarations',\n",
    "    name_column='externalModuleNamespace',\n",
    "    threshold= 0.5\n",
    ");\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_declaration_usage_significant,\n",
    "    title='Top external namespace declaration usage [%] (more than 0.5% overall)'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b527d90",
   "metadata": {},
   "source": [
    "#### Table 4 Chart 3b - External namespaces with the most used declarations in % (less than 0.5% overall \"others\" drill-down)\n",
    "\n",
    "Shows the lowest (less than 0.5% overall) external namespaces with the most used declarations. Therefore, this plot breaks down the \"others\" slice of the pie chart above. Values under 0.3% from that will be grouped into \"others\" to get a cleaner plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f3008e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespace_declaration_usage_drill_down_others=filter_values_below_threshold(external_namespace_usage_spread, 'sumNumberOfUsedExternalDeclarations', 0.5)\n",
    "\n",
    "external_namespace_declaration_usage_significant_drill_down_others = group_to_others_below_threshold(\n",
    "    data_frame=external_namespace_declaration_usage_drill_down_others,\n",
    "    value_column='sumNumberOfUsedExternalDeclarations',\n",
    "    name_column='externalModuleNamespace',\n",
    "    threshold= 0.3\n",
    ")\n",
    "plot_pie_chart(\n",
    "    input_data_frame=external_namespace_declaration_usage_significant_drill_down_others,\n",
    "    title='Top external namespace declaration usage (less than 0.7% overall \"others\" drill-down)'\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "29ec2211",
   "metadata": {},
   "source": [
    "### Table 5 - Top 20 least used external modules overall\n",
    "\n",
    "This table identifies external modules that aren't used very often. This could help to find libraries that aren't actually needed or maybe easily replaceable. Some of them might be used sparsely on purpose for example as an adapter to an external library that is actually important. Thus, decisions need to be made on a case-by-case basis.\n",
    "\n",
    "Only the last 20 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_module_usage_overall_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *externalModuleName* identifies the external package as described above\n",
    "- *numberOfExternalDeclarationCalls* includes every invocation or reference to the declarations in the external module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03641b8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sort by number of external type calls\n",
    "external_package_least_used=external_module_usage.sort_values(by='numberOfExternalDeclarationCalls', ascending=True)\n",
    "\n",
    "# Reset index\n",
    "external_package_least_used = external_package_least_used.reset_index(drop=True)\n",
    "\n",
    "# Select columns and only show the first 10 entries (head)\n",
    "external_package_least_used[['externalModuleName','numberOfExternalDeclarationCalls']].head(20)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bd11586",
   "metadata": {},
   "source": [
    "### Table 6 - External usage per internal module sorted by highest external element usage rate descending\n",
    "\n",
    "The following table shows the most used external packages separately for each artifact including external annotations. The results are sorted by the artifacts with the highest external type usage rate descending. \n",
    "\n",
    "The intention of this table is to find artifacts that use a lot of external dependencies in relation to their size and get all the external packages and their usage.\n",
    "\n",
    "Only the first 40 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_module_usage_per_internal_module_sorted_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *internalModuleName* is the internal module that uses the external one. Both are used here as a group for a more detailed analysis.\n",
    "- *externalModuleName* is the external module prepended by its namespace if given. Example: \"@types/react\"\n",
    "- *numberOfExternalDeclarationCaller* is the count of distinct internal elements in the internal module that call the external module\n",
    "- *numberOfExternalDeclarationCalls* is the count of how often the external module is called within the internal module\n",
    "- *numberOfAllElementsInInternalModule* is the total count of all exported elements of the internal module\n",
    "- *numberOfAllExternalDeclarationsUsedInInternalModule* is the total count of all distinct external declarations used in the internal module\n",
    "- *numberOfAllExternalModulesUsedInInternalModule* is the total count of all distinct external modules used in the internal module\n",
    "- *externalDeclarationRate* is the numberOfAllExternalDeclarationsUsedInInternalModule / numberOfAllElementsInInternalModule * 100 of the internal module for all external modules\n",
    "- *externalDeclarationNames* contains a list of actually used external declarations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6be4357",
   "metadata": {},
   "source": [
    "#### Table 6a - External module usage per internal module sorted by highest external element usage rate descending"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8459ede",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_modules_used_by_internal_modules = query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_module_usage_per_internal_module_sorted_for_Typescript.cypher\")\n",
    "external_modules_used_by_internal_modules.head(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2635122d",
   "metadata": {},
   "source": [
    "#### Table 6b - External namespace usage per internal module sorted by highest external element usage rate descending"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10f373b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespaces_used_by_internal_modules = query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_namespace_usage_per_internal_module_sorted_for_Typescript.cypher\")\n",
    "external_namespaces_used_by_internal_modules.head(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb458f01",
   "metadata": {},
   "source": [
    "#### Table 6c - Top 15 used external modules with the internal modules that use them the most\n",
    "\n",
    "The following table uses pivot to show the internal modules in columns, the external modules in rows and the number of internal elements using them as values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd9667a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the percentage for each value based on the global sum of all values\n",
    "def percentage_global(data_frame : pd.DataFrame):\n",
    "    total = data_frame.sum().sum()\n",
    "    return data_frame / total * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ae9ada4",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_modules_used_by_internal_modules_pivot = external_modules_used_by_internal_modules.copy()\n",
    "\n",
    "# Every row represents the number of external module\n",
    "external_modules_used_by_internal_modules_pivot=external_modules_used_by_internal_modules_pivot.pivot(index='externalModuleName', columns='internalModuleName', values='numberOfExternalDeclarationCaller')\n",
    "\n",
    "# Sort by column sum and then take only the first 10 columns\n",
    "sum_of_external_packages_per_artifact = external_modules_used_by_internal_modules_pivot.sum()\n",
    "external_modules_used_by_internal_modules_pivot = external_modules_used_by_internal_modules_pivot[sum_of_external_packages_per_artifact.sort_values(ascending=False).index[:15]]\n",
    "\n",
    "# Fill missing values with zeroes\n",
    "external_modules_used_by_internal_modules_pivot.fillna(0, inplace=True)\n",
    "\n",
    "external_modules_used_by_internal_modules_pivot.astype('int')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b1fed8e",
   "metadata": {},
   "source": [
    "#### Table 6d - Top 15 used external namespaces with the internal modules that use them the most\n",
    "\n",
    "The following table uses pivot to show the internal modules in columns, the external namespaces in rows and the number of internal elements using them as values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "845099fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_namespaces_used_by_internal_modules_pivot = external_namespaces_used_by_internal_modules.copy()\n",
    "\n",
    "# Every row represents the number of external module\n",
    "external_namespaces_used_by_internal_modules_pivot=external_namespaces_used_by_internal_modules_pivot.pivot(index='externalNamespaceName', columns='internalModuleName', values='numberOfExternalDeclarationCaller')\n",
    "\n",
    "# Sort by column sum and then take only the first 10 columns\n",
    "sum_of_external_second_level_packages_per_artifact = external_namespaces_used_by_internal_modules_pivot.sum()\n",
    "external_namespaces_used_by_internal_modules_pivot = external_namespaces_used_by_internal_modules_pivot[sum_of_external_second_level_packages_per_artifact.sort_values(ascending=False).index[:15]]\n",
    "\n",
    "# Fill missing values with zeroes\n",
    "external_namespaces_used_by_internal_modules_pivot.fillna(0, inplace=True)\n",
    "\n",
    "external_namespaces_used_by_internal_modules_pivot.astype('int')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "4fb87c8a",
   "metadata": {},
   "source": [
    "### Table 6e - External usage per internal module and its elements\n",
    "\n",
    "This table lists internal elements and the modules they belong to that use many different external declarations of a specific external module. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58a19ad7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sort by number of packages descending\n",
    "internal_modules_with_highest_external_declaration_usage = external_modules_used_by_internal_modules.copy()\n",
    "internal_modules_with_highest_external_declaration_usage.sort_values(by=['numberOfAllExternalDeclarationsUsedInInternalModule','internalModuleName'], ascending=[False, True]).reset_index(drop=True)\n",
    "internal_modules_with_highest_external_declaration_usage=internal_modules_with_highest_external_declaration_usage[['internalModuleName', 'numberOfAllExternalDeclarationsUsedInInternalModule', 'numberOfAllElementsInInternalModule']]\n",
    "internal_modules_with_highest_external_declaration_usage=internal_modules_with_highest_external_declaration_usage.drop_duplicates()\n",
    "internal_modules_with_highest_external_declaration_usage.head(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43ec339b",
   "metadata": {},
   "source": [
    "#### Table 6 Chart 1 - Top 15 external dependency using artifacts and their external packages stacked\n",
    "\n",
    "The following chart shows the top 15 external package using artifacts and breaks down which external packages they use in how many different internal packages with stacked bars. \n",
    "\n",
    "Note that every external dependency is counted separately so that if on internal package uses two external packages it will be displayed for both and so stacked twice.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d8e8bb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "if external_modules_used_by_internal_modules_pivot.empty:\n",
    "    print(\"No data to plot\")\n",
    "else:\n",
    "    plot.figure();\n",
    "    axes = external_modules_used_by_internal_modules_pivot.transpose().plot(\n",
    "        kind='bar', \n",
    "        grid=True,\n",
    "        title='External module usage by internal modules', \n",
    "        xlabel='internal module',\n",
    "        ylabel='number of elements',\n",
    "        stacked=True,\n",
    "        legend=True,\n",
    "        cmap=main_color_map\n",
    "    ).legend(bbox_to_anchor=(1.0, 1.0))\n",
    "    plot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d577c45",
   "metadata": {},
   "source": [
    "#### Table 6 Chart 2 - Top 15 external dependency using artifacts and their external packages (first 2 levels) stacked\n",
    "\n",
    "The following chart shows the top 15 external package using artifacts and breaks down which external packages (first 2 levels) are used in how many different internal packages with stacked bars. \n",
    "\n",
    "Note that every external dependency is counted separately so that if on internal package uses two external packages it will be displayed for both and so stacked twice.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17fc1572",
   "metadata": {},
   "outputs": [],
   "source": [
    "if external_namespaces_used_by_internal_modules_pivot.empty:\n",
    "    print(\"No data to plot\")\n",
    "else:\n",
    "    plot.figure();\n",
    "    axes = external_namespaces_used_by_internal_modules_pivot.transpose().plot(\n",
    "        kind='bar', \n",
    "        grid=True,\n",
    "        title='External namespaces usage by internal modules', \n",
    "        xlabel='internal module',\n",
    "        ylabel='number of internal elements',\n",
    "        stacked=True,\n",
    "        legend=True,\n",
    "        cmap=main_color_map\n",
    "    ).legend(bbox_to_anchor=(1.0, 1.0))\n",
    "    plot.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5b420f59",
   "metadata": {},
   "source": [
    "### Table 7 - External module usage distribution per internal element\n",
    "\n",
    "This table shows how many internal elements use one external module, how many use two, etc. .\n",
    "This gives an overview of the distribution of external module calls and the overall coupling to external libraries. The higher the count of distinct external modules the lower should be the count of internal elements that use them. \n",
    "More details about which types have the highest external package dependency usage can be in the tables 4 and 5 above.\n",
    "\n",
    "Only the last 40 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_module_usage_per_internal_module_distribution_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *internalModuleName* is the internal module that uses at least one external module. All other columns refer to it.\n",
    "- *numberOfAllInternalElements* the total number of all elements that are exported by the internal module\n",
    "- *externalModuleCount* is the number of distinct external modules used by the internal module\n",
    "- *internalElementCount* is the number of distinct internal elements that use at least one external one\n",
    "- *internalElementsCallingExternalRate* is internalElementCount / numberOfAllInternalElements * 100 (in %)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d750524a",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_per_artifact_distribution = query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_module_usage_per_internal_module_distribution_for_Typescript.cypher\")\n",
    "external_package_usage_per_artifact_distribution_truncated=external_package_usage_per_artifact_distribution[['internalModuleName', 'numberOfAllInternalElements', 'externalModuleCount', 'internalElementCount', 'internalElementsCallingExternalRate']].head(40)\n",
    "external_package_usage_per_artifact_distribution_truncated"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "055e5a36",
   "metadata": {},
   "source": [
    "### Table 8 - External package usage aggregated\n",
    "\n",
    "This table lists all artifacts and their external package dependencies usage aggregated over internal packages. \n",
    "\n",
    "The intention behind this is to find artifacts that use an external dependency across multiple internal packages. This might be intended for frameworks and standardized libraries and helps to quantify how widely those are used. For some external dependencies it might be beneficial to only access it from one package and provide an abstraction for internal usage following a [Hexagonal architecture](https://alistair.cockburn.us/hexagonal-architecture). Thus, this table may also help in finding application for the Hexagonal architecture or similar approaches (Domain Driven Design Anti Corruption Layer). After all it is easier to update or replace such external dependencies when they are used in specific areas and not all over the code.\n",
    "\n",
    "Only the last 40 entries are shown. The whole table can be found in the following CSV report:\n",
    "`External_module_usage_per_internal_module_aggregated_for_Typescript`\n",
    "\n",
    "**Columns:**\n",
    "- *internalModuleName* that contains the type that calls the external package\n",
    "- *internalModuleElementsCount* is the total count of packages in the internal module\n",
    "- *numberOfExternalModules* the number of distinct external packages used\n",
    "- *[min,max,med,avg,std]NumberOfInternalModules* provide statistics based on each external package and its package usage within the internal module\n",
    "- *[min,max,med,avg,std]NumberOfInternalElements* provide statistics based on each external package and its type usage within the internal module\n",
    "- *[min,max,med,avg,std]NumberOfTypePercentage* provide statistics in % based on each external package and its type usage within the internal module in respect to the overall count of packages in the internal module\n",
    "- *numberOfinternalElements* in the internal module where the *numberOfExternalModules* applies\n",
    "- *numberOfTypesPercentage* in the internal module where the *numberOfExternalModules* applies in %"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7850d0a2",
   "metadata": {},
   "source": [
    "#### Table 8a - External module usage aggregated - count of internal modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d01860a",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_aggregated = query_cypher_to_data_frame(\"../cypher/External_Dependencies/External_module_usage_per_internal_module_aggregated_for_Typescript.cypher\")\n",
    "\n",
    "external_package_usage_aggregated_packages = external_package_usage_aggregated[['internalModuleName', 'internalModuleElementsCount', 'numberOfExternalModules', 'minNumberOfInternalModules', 'medNumberOfInternalModules', 'avgNumberOfInternalModules', 'maxNumberOfInternalModules', 'stdNumberOfInternalModules']]\n",
    "external_package_usage_aggregated_packages.head(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c476382",
   "metadata": {},
   "source": [
    "#### Table 8b - External module usage aggregated - count of internal elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40392b95",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_aggregated_types = external_package_usage_aggregated[['internalModuleName', 'internalModuleElementsCount', 'numberOfExternalModules', 'minNumberOfInternalElements', 'medNumberOfInternalElements', 'avgNumberOfInternalElements', 'maxNumberOfInternalElements', 'stdNumberOfInternalElements']]\n",
    "external_package_usage_aggregated_types.head(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eac5b93",
   "metadata": {},
   "source": [
    "#### Table 8c - External module usage aggregated - percentage of internal elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "260cc520",
   "metadata": {},
   "outputs": [],
   "source": [
    "external_package_usage_aggregated_types_percentage = external_package_usage_aggregated[['internalModuleName', 'internalModuleElementsCount', 'numberOfExternalModules', 'minNumberOfInternalElementsPercentage', 'medNumberOfInternalElementsPercentage', 'avgNumberOfInternalElementsPercentage', 'maxNumberOfInternalElementsPercentage', 'stdNumberOfInternalElementsPercentage']]\n",
    "external_package_usage_aggregated_types_percentage.head(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1a16e29",
   "metadata": {},
   "source": [
    "#### Table 8 Chart 1 - External module usage - max percentage of internal types\n",
    "\n",
    "This chart shows per internal module the maximum percentage of internal packages (compared to all packages in that internal module) that use one specific external package. \n",
    "\n",
    "**Example:** One internal module might use 10 external packages where 7 of them are used in one internal package, 2 of them are used in two packages and one external dependency is used in 5 packages. So for this internal module there will be a point at x = 10 (external packages used by the internal module) and 5 (max internal packages). Instead of the count the percentage of internal packages compared to all packages in that internal module is used to get a normalized plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad1db8af",
   "metadata": {},
   "outputs": [],
   "source": [
    "def annotate_plot(data_frame: pd.DataFrame, index: int):\n",
    "    \"\"\"\n",
    "    Annotates the data points identified by the \"index\" in the plot of the \"data_frame\" \n",
    "    \"\"\"\n",
    "    x_position = data_frame.numberOfExternalModules[index].item()\n",
    "    y_position = data_frame.maxNumberOfInternalElementsPercentage[index].item()\n",
    "    artifact_name = data_frame.internalModuleName[index].item()\n",
    "\n",
    "    label_box=dict(boxstyle=\"round4,pad=0.5\", fc=\"w\", alpha=0.8)\n",
    "    plot.annotate(artifact_name\n",
    "        ,xy=(x_position, y_position)\n",
    "        ,xycoords='data'\n",
    "        ,xytext=(-30, -15)\n",
    "        ,textcoords='offset points'\n",
    "        ,size=6\n",
    "        ,bbox=label_box\n",
    "        ,arrowprops=dict(arrowstyle=\"-|>\", mutation_scale=10, color=\"black\")\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66811915",
   "metadata": {},
   "outputs": [],
   "source": [
    "def index_of_sorted(data_frame: pd.DataFrame, highest: list[str] = []):\n",
    "    \"\"\"\n",
    "    Sorts the \"data_frame\" by columns 'numberOfExternalModules','maxNumberOfInternalElementsPercentage','internalModuleElementsCount', 'internalModuleName'\n",
    "    and returns the index of the first row.\n",
    "    Columns that are contained in the list of strings parameter \"highest\" will be sorted descending (highest first).\n",
    "    \"\"\"\n",
    "    by = ['numberOfExternalModules','maxNumberOfInternalElementsPercentage','internalModuleElementsCount', 'internalModuleName']\n",
    "    ascending = [('numberOfExternalModules' not in highest), ('maxNumberOfInternalElementsPercentage' not in highest), False, True]\n",
    "    return data_frame.sort_values(by=by, ascending=ascending).head(1).index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "615238d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "if external_package_usage_aggregated.empty:\n",
    "    print(\"No data to plot\")\n",
    "else:\n",
    "    plot.figure();\n",
    "    axes = external_package_usage_aggregated.plot(\n",
    "        kind='scatter',\n",
    "        title='External package usage - max internal packages %', \n",
    "        x='numberOfExternalModules',\n",
    "        y='maxNumberOfInternalElementsPercentage',\n",
    "        s='internalModuleElementsCount',\n",
    "        c='stdNumberOfInternalElementsPercentage',\n",
    "        xlabel='external module count',\n",
    "        ylabel='max percentage of internal elements',\n",
    "        cmap=main_color_map,\n",
    "    )\n",
    "\n",
    "    # Annotate the largest internal module with the highest number of external packages and max number of packages in percentage\n",
    "    annotation_index = index_of_sorted(highest=['numberOfExternalModules','maxNumberOfInternalElementsPercentage'], data_frame=external_package_usage_aggregated)\n",
    "    annotate_plot(external_package_usage_aggregated, annotation_index)\n",
    "\n",
    "\n",
    "    # Annotate the largest internal module with the lowest number of external packages and the highest max number of packages in percentage\n",
    "    annotation_index = index_of_sorted(highest=['maxNumberOfInternalElementsPercentage'], data_frame=external_package_usage_aggregated)\n",
    "    annotate_plot(external_package_usage_aggregated, annotation_index)\n",
    "\n",
    "    # Annotate the largest internal module with the lowest number of external packages and max number of packages in percentage\n",
    "    annotation_index = index_of_sorted(highest=[], data_frame=external_package_usage_aggregated)\n",
    "    annotate_plot(external_package_usage_aggregated, annotation_index)\n",
    "\n",
    "    plot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b7cff51",
   "metadata": {},
   "source": [
    "#### Table 8 Chart 2 - External package usage - median percentage of internal types\n",
    "\n",
    "This chart shows per internal module the median (0.5 percentile) of internal packages (compared to all packages in that internal module) that use one specific external package. \n",
    "\n",
    "**Example:** One internal module might use 9 external packages where 3 of them are used in 1 internal package, 3 of them are used in 2 package and the last 3 ones are used in 3 packages. So for this internal module there will be a point at x = 10 (external packages used by the internal module) and 2 (median internal packages). Instead of the count the percentage of internal packages compared to all packages in that internal module is used to get a normalized plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34d2595f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if external_package_usage_aggregated.empty:\n",
    "    print(\"No data to plot\")\n",
    "else:\n",
    "    plot.figure();\n",
    "    axes = external_package_usage_aggregated.plot(\n",
    "        kind='scatter',\n",
    "        title='External package usage - median internal packages %', \n",
    "        x='numberOfExternalModules',\n",
    "        y='medNumberOfInternalElementsPercentage',\n",
    "        s='internalModuleElementsCount',\n",
    "        c='stdNumberOfInternalElementsPercentage',\n",
    "        xlabel='external module count',\n",
    "        ylabel='median percentage of internal elements',\n",
    "        cmap=main_color_map,\n",
    "    )\n",
    "    plot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46baa3c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "driver.close()"
   ]
  }
 ],
 "metadata": {
  "authors": [
   {
    "name": "JohT"
   }
  ],
  "celltoolbar": "Tags",
  "code_graph_analysis_pipeline_data_validation": "ValidateTypescriptModuleDependencies",
  "kernelspec": {
   "display_name": "codegraph",
   "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.12.9"
  },
  "title": "External Dependencies for Typescript"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}