moderne-visualizations-misc 0.76.0__tar.gz → 1.0.0__tar.gz

{moderne_visualizations_misc-0.76.0/moderne_visualizations_misc.egg-info → moderne_visualizations_misc-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moderne_visualizations_misc
-Version: 0.76.0
+Version: 1.0.0
 Summary: Miscellaneous visualizations for the Moderne platform
 Author-email: Jonathan Schneider <jonathan@moderne.io>, Kyle Scully <kyle@moderne.io>
 License: Apache-2.0
@@ -10,12 +10,12 @@ License-File: LICENSE
 Requires-Dist: code-data-science==2.1.2
 Requires-Dist: graphviz==0.20.1
 Requires-Dist: ipython==8.13.0
-Requires-Dist: matplotlib==3.7.1
+Requires-Dist: matplotlib<4.0,>=3.8
 Requires-Dist: nbformat==5.9.0
 Requires-Dist: pandas==2.0.3
 Requires-Dist: plotly==5.14.1
 Requires-Dist: typing-extensions
 Requires-Dist: umap-learn==0.5.5
 Requires-Dist: networkx==3.1
-Requires-Dist: numpy==1.24.4
+Requires-Dist: numpy<2.0,>=1.26
 Dynamic: license-file

{moderne_visualizations_misc-0.76.0 → moderne_visualizations_misc-1.0.0}/moderne_visualizations_misc/composite_recipe_results_sankey.ipynb

@@ -31,8 +31,9 @@
     "# Filter the data frame to only include rows where repositoryWithBranch contain\n",
     "# a term in the repository_filter (case insensitive)\n",
     "if len(repository_filter) > 0:\n",
-    "    df = df[df[\"repositoryWithBranch\"].str.contains(\n",
-    "        \"|\".join(repository_filter), case=False)]"
+    "    df = df[\n",
+    "        df[\"repositoryWithBranch\"].str.contains(\"|\".join(repository_filter), case=False)\n",
+    "    ]"
    ]
   },
   {
@@ -145,7 +146,6 @@
     "                color=colors,\n",
     "                customdata=all_nodes,\n",
     "                hovertemplate=\"<b>%{customdata}</b><extra></extra>\",\n",
-    "\n",
     "            ),\n",
     "            link=dict(\n",
     "                source=source,\n",
@@ -165,13 +165,13 @@
     "    height=max(len(all_nodes) * 10, 500),\n",
     ")\n",
     "\n",
-    "fig.show()\n"
+    "fig.show()"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".python",
+   "display_name": "moderne-visualizations-misc",
    "language": "python",
    "name": "python3"
   },

moderne_visualizations_misc-1.0.0/moderne_visualizations_misc/cyclomatic_complexity_heatmap.ipynb

@@ -0,0 +1,246 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "tags": [
+     "parameters"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "repository_filter: list[str] = []\n",
+    "top_n_classes: int = 50"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import warnings\n",
+    "import plotly.graph_objects as go\n",
+    "import plotly.express as px\n",
+    "import code_data_science.data_table as dt\n",
+    "import numpy as np\n",
+    "\n",
+    "warnings.simplefilter(\"ignore\")\n",
+    "\n",
+    "df = dt.read_csv(\"../samples/cyclomatic_complexity.csv\")\n",
+    "\n",
+    "# Filter the data frame to only include rows where repositoryPath contains\n",
+    "# a term in the repository_filter (case insensitive)\n",
+    "if len(repository_filter) > 0:\n",
+    "    df = df[df[\"repositoryPath\"].str.contains(\"|\".join(repository_filter), case=False)]\n",
+    "\n",
+    "# Exit early if there are no records and render a plot with a message\n",
+    "if len(df) == 0:\n",
+    "    fig = go.Figure()\n",
+    "    fig.add_annotation(\n",
+    "        text=\"No data available for the selected repositories\",\n",
+    "        xref=\"paper\",\n",
+    "        yref=\"paper\",\n",
+    "        x=0.5,\n",
+    "        y=0.5,\n",
+    "        showarrow=False,\n",
+    "        font=dict(size=14),\n",
+    "    )\n",
+    "    fig.update_layout(\n",
+    "        xaxis=dict(visible=False),\n",
+    "        yaxis=dict(visible=False),\n",
+    "        margin=dict(l=0, r=0, t=60, b=60),\n",
+    "        title=\"Cyclomatic Complexity Heatmap\",\n",
+    "    )\n",
+    "    fig.show(render=\"plotly_mimetype\")\n",
+    "else:\n",
+    "    # Aggregate complexity metrics by repository and class\n",
+    "    class_metrics = (\n",
+    "        df.groupby([\"repositoryPath\", \"className\"])\n",
+    "        .agg({\"complexity\": [\"sum\", \"mean\", \"max\", \"count\"]})\n",
+    "        .reset_index()\n",
+    "    )\n",
+    "\n",
+    "    # Flatten column names\n",
+    "    class_metrics.columns = [\n",
+    "        \"repository\",\n",
+    "        \"className\",\n",
+    "        \"total_complexity\",\n",
+    "        \"avg_complexity\",\n",
+    "        \"max_complexity\",\n",
+    "        \"method_count\",\n",
+    "    ]\n",
+    "\n",
+    "    # Get short class names for display\n",
+    "    class_metrics[\"classShortName\"] = class_metrics[\"className\"].str.split(\".\").str[-1]\n",
+    "\n",
+    "    # Get top N classes by total complexity\n",
+    "    top_classes = class_metrics.nlargest(\n",
+    "        min(top_n_classes, len(class_metrics)), \"total_complexity\"\n",
+    "    )\n",
+    "\n",
+    "    # Create pivot table for heatmap\n",
+    "    # We'll show different metrics as columns\n",
+    "    metrics_data = []\n",
+    "    for _, row in top_classes.iterrows():\n",
+    "        metrics_data.append(\n",
+    "            {\n",
+    "                \"class\": f\"{row['repository'].split('/')[-1]}::{row['classShortName']}\",\n",
+    "                \"metric\": \"Total Complexity\",\n",
+    "                \"value\": row[\"total_complexity\"],\n",
+    "            }\n",
+    "        )\n",
+    "        metrics_data.append(\n",
+    "            {\n",
+    "                \"class\": f\"{row['repository'].split('/')[-1]}::{row['classShortName']}\",\n",
+    "                \"metric\": \"Avg Complexity\",\n",
+    "                \"value\": row[\"avg_complexity\"],\n",
+    "            }\n",
+    "        )\n",
+    "        metrics_data.append(\n",
+    "            {\n",
+    "                \"class\": f\"{row['repository'].split('/')[-1]}::{row['classShortName']}\",\n",
+    "                \"metric\": \"Max Complexity\",\n",
+    "                \"value\": row[\"max_complexity\"],\n",
+    "            }\n",
+    "        )\n",
+    "        metrics_data.append(\n",
+    "            {\n",
+    "                \"class\": f\"{row['repository'].split('/')[-1]}::{row['classShortName']}\",\n",
+    "                \"metric\": \"Method Count\",\n",
+    "                \"value\": row[\"method_count\"],\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "    metrics_df = pd.DataFrame(metrics_data)\n",
+    "    pivot_table = metrics_df.pivot(index=\"class\", columns=\"metric\", values=\"value\")\n",
+    "\n",
+    "    # Reorder columns\n",
+    "    pivot_table = pivot_table[\n",
+    "        [\"Method Count\", \"Avg Complexity\", \"Max Complexity\", \"Total Complexity\"]\n",
+    "    ]\n",
+    "\n",
+    "    # Sort by total complexity to maintain order\n",
+    "    pivot_table = pivot_table.sort_values(\"Total Complexity\", ascending=False)\n",
+    "\n",
+    "    # Normalize values for each metric (0-1 scale) for better color representation\n",
+    "    normalized_data = pivot_table.copy()\n",
+    "    for col in normalized_data.columns:\n",
+    "        col_min = normalized_data[col].min()\n",
+    "        col_max = normalized_data[col].max()\n",
+    "        if col_max > col_min:\n",
+    "            normalized_data[col] = (normalized_data[col] - col_min) / (\n",
+    "                col_max - col_min\n",
+    "            )\n",
+    "\n",
+    "    # Create custom hover text\n",
+    "    hover_text = []\n",
+    "    for i in range(len(pivot_table)):\n",
+    "        hover_row = []\n",
+    "        for j, col in enumerate(pivot_table.columns):\n",
+    "            value = pivot_table.iloc[i, j]\n",
+    "            if col == \"Avg Complexity\":\n",
+    "                hover_row.append(f\"{col}: {value:.1f}\")\n",
+    "            else:\n",
+    "                hover_row.append(f\"{col}: {int(value)}\")\n",
+    "        hover_text.append(hover_row)\n",
+    "\n",
+    "    # Create the heatmap\n",
+    "    fig = go.Figure(\n",
+    "        data=go.Heatmap(\n",
+    "            z=normalized_data.values,\n",
+    "            x=normalized_data.columns,\n",
+    "            y=normalized_data.index,\n",
+    "            colorscale=[\n",
+    "                [0, \"#E8F5E9\"],\n",
+    "                [0.2, \"#A5D6A7\"],\n",
+    "                [0.4, \"#FFE082\"],\n",
+    "                [0.6, \"#FFB74D\"],\n",
+    "                [0.8, \"#FF8A65\"],\n",
+    "                [1, \"#EF5350\"],\n",
+    "            ],\n",
+    "            colorbar=dict(title=\"Normalized<br>Complexity\", thickness=15, len=0.7),\n",
+    "            text=hover_text,\n",
+    "            texttemplate=\"\",\n",
+    "            hovertemplate=(\"<b>%{y}</b><br>\" + \"%{text}\" + \"<extra></extra>\"),\n",
+    "        )\n",
+    "    )\n",
+    "\n",
+    "    # Add text annotations for actual values\n",
+    "    annotations = []\n",
+    "    for i in range(len(pivot_table)):\n",
+    "        for j, col in enumerate(pivot_table.columns):\n",
+    "            value = pivot_table.iloc[i, j]\n",
+    "            if col == \"Avg Complexity\":\n",
+    "                text = f\"{value:.1f}\"\n",
+    "            else:\n",
+    "                text = str(int(value))\n",
+    "\n",
+    "            annotations.append(\n",
+    "                go.layout.Annotation(\n",
+    "                    text=text,\n",
+    "                    x=j,\n",
+    "                    y=i,\n",
+    "                    xref=\"x\",\n",
+    "                    yref=\"y\",\n",
+    "                    showarrow=False,\n",
+    "                    font=dict(\n",
+    "                        size=10,\n",
+    "                        color=\"black\" if normalized_data.iloc[i, j] < 0.6 else \"white\",\n",
+    "                    ),\n",
+    "                )\n",
+    "            )\n",
+    "\n",
+    "    # Update layout\n",
+    "    fig.update_layout(\n",
+    "        title=dict(\n",
+    "            text=f\"Cyclomatic Complexity Heatmap by Class<br><sub>Top {len(pivot_table)} classes by total complexity</sub>\",\n",
+    "            font=dict(size=16),\n",
+    "        ),\n",
+    "        xaxis=dict(\n",
+    "            title=\"Complexity Metrics\",\n",
+    "            tickfont=dict(size=12),\n",
+    "            showgrid=False,\n",
+    "            side=\"bottom\",\n",
+    "        ),\n",
+    "        yaxis=dict(\n",
+    "            title=\"Repository::Class\",\n",
+    "            tickfont=dict(size=10),\n",
+    "            showgrid=False,\n",
+    "            autorange=\"reversed\",  # Put highest complexity at top\n",
+    "        ),\n",
+    "        annotations=annotations,\n",
+    "        margin=dict(l=250, r=50, t=100, b=80),\n",
+    "        height=max(600, len(pivot_table) * 25 + 200),\n",
+    "        plot_bgcolor=\"white\",\n",
+    "    )\n",
+    "\n",
+    "    # Show the figure\n",
+    "    fig.show(render=\"plotly_mimetype\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "moderne-visualizations-misc",
+   "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

{moderne_visualizations_misc-0.76.0 → moderne_visualizations_misc-1.0.0}/moderne_visualizations_misc/cyclomatic_complexity_risk_matrix.ipynb

@@ -1840,9 +1840,7 @@
     "# Filter the data frame to only include rows where repositoryPath contains\n",
     "# a term in the repository_filter (case insensitive)\n",
     "if len(repository_filter) > 0:\n",
-    "    df = df[\n",
-    "        df[\"repositoryPath\"].str.contains(\"|\".join(repository_filter), case=False)\n",
-    "    ]\n",
+    "    df = df[df[\"repositoryPath\"].str.contains(\"|\".join(repository_filter), case=False)]\n",
     "\n",
     "# Exit early if there are no records and render a plot with a message\n",
     "if len(df) == 0:\n",
@@ -1854,86 +1852,95 @@
     "        x=0.5,\n",
     "        y=0.5,\n",
     "        showarrow=False,\n",
-    "        font=dict(size=14)\n",
+    "        font=dict(size=14),\n",
     "    )\n",
     "    fig.update_layout(\n",
     "        xaxis=dict(visible=False),\n",
     "        yaxis=dict(visible=False),\n",
     "        margin=dict(l=0, r=0, t=60, b=60),\n",
-    "        title=\"Cyclomatic Complexity Risk Matrix\"\n",
+    "        title=\"Cyclomatic Complexity Risk Matrix\",\n",
     "    )\n",
     "    fig.show(render=\"plotly_mimetype\")\n",
     "else:\n",
     "    # Calculate metrics for each repository\n",
-    "    repo_metrics = df.groupby('repositoryPath').agg({\n",
-    "        'complexity': ['mean', 'count', lambda x: (x >= complexity_threshold).sum()]\n",
-    "    }).reset_index()\n",
-    "    \n",
+    "    repo_metrics = (\n",
+    "        df.groupby(\"repositoryPath\")\n",
+    "        .agg(\n",
+    "            {\n",
+    "                \"complexity\": [\n",
+    "                    \"mean\",\n",
+    "                    \"count\",\n",
+    "                    lambda x: (x >= complexity_threshold).sum(),\n",
+    "                ]\n",
+    "            }\n",
+    "        )\n",
+    "        .reset_index()\n",
+    "    )\n",
+    "\n",
     "    # Flatten column names\n",
-    "    repo_metrics.columns = ['repository', 'avg_complexity', 'total_methods', 'high_complexity_methods']\n",
-    "    \n",
+    "    repo_metrics.columns = [\n",
+    "        \"repository\",\n",
+    "        \"avg_complexity\",\n",
+    "        \"total_methods\",\n",
+    "        \"high_complexity_methods\",\n",
+    "    ]\n",
+    "\n",
     "    # Count unique classes per repository for bubble size\n",
-    "    classes_per_repo = df.groupby('repositoryPath')['className'].nunique().reset_index()\n",
-    "    classes_per_repo.columns = ['repository', 'num_classes']\n",
-    "    \n",
+    "    classes_per_repo = df.groupby(\"repositoryPath\")[\"className\"].nunique().reset_index()\n",
+    "    classes_per_repo.columns = [\"repository\", \"num_classes\"]\n",
+    "\n",
     "    # Merge the metrics\n",
-    "    repo_metrics = repo_metrics.merge(classes_per_repo, on='repository')\n",
-    "    \n",
+    "    repo_metrics = repo_metrics.merge(classes_per_repo, on=\"repository\")\n",
+    "\n",
     "    # Create the scatter plot\n",
     "    fig = go.Figure()\n",
-    "    \n",
+    "\n",
     "    # Add scatter trace\n",
-    "    fig.add_trace(go.Scatter(\n",
-    "        x=repo_metrics['high_complexity_methods'],\n",
-    "        y=repo_metrics['avg_complexity'],\n",
-    "        mode='markers',\n",
-    "        marker=dict(\n",
-    "            size=repo_metrics['num_classes'],\n",
-    "            sizemode='area',\n",
-    "            sizeref=2.*max(repo_metrics['num_classes'])/(100.**2),\n",
-    "            sizemin=4,\n",
-    "            color=repo_metrics['high_complexity_methods'],\n",
-    "            colorscale='YlOrRd',\n",
-    "            showscale=True,\n",
-    "            colorbar=dict(\n",
-    "                title=\"High Complexity<br>Methods\",\n",
-    "                thickness=15,\n",
-    "                len=0.7\n",
-    "            )\n",
-    "        ),\n",
-    "        text=repo_metrics['repository'],\n",
-    "        customdata=repo_metrics[['total_methods', 'num_classes']],\n",
-    "        hovertemplate=(\n",
-    "            '<b>%{text}</b><br>' +\n",
-    "            'Average Complexity: %{y:.2f}<br>' +\n",
-    "            'High Complexity Methods: %{x}<br>' +\n",
-    "            'Total Methods: %{customdata[0]}<br>' +\n",
-    "            'Number of Classes: %{customdata[1]}' +\n",
-    "            '<extra></extra>'\n",
+    "    fig.add_trace(\n",
+    "        go.Scatter(\n",
+    "            x=repo_metrics[\"high_complexity_methods\"],\n",
+    "            y=repo_metrics[\"avg_complexity\"],\n",
+    "            mode=\"markers\",\n",
+    "            marker=dict(\n",
+    "                size=repo_metrics[\"num_classes\"],\n",
+    "                sizemode=\"area\",\n",
+    "                sizeref=2.0 * max(repo_metrics[\"num_classes\"]) / (100.0**2),\n",
+    "                sizemin=4,\n",
+    "                color=repo_metrics[\"high_complexity_methods\"],\n",
+    "                colorscale=\"YlOrRd\",\n",
+    "                showscale=True,\n",
+    "                colorbar=dict(\n",
+    "                    title=\"High Complexity<br>Methods\", thickness=15, len=0.7\n",
+    "                ),\n",
+    "            ),\n",
+    "            text=repo_metrics[\"repository\"],\n",
+    "            customdata=repo_metrics[[\"total_methods\", \"num_classes\"]],\n",
+    "            hovertemplate=(\n",
+    "                \"<b>%{text}</b><br>\"\n",
+    "                + \"Average Complexity: %{y:.2f}<br>\"\n",
+    "                + \"High Complexity Methods: %{x}<br>\"\n",
+    "                + \"Total Methods: %{customdata[0]}<br>\"\n",
+    "                + \"Number of Classes: %{customdata[1]}\"\n",
+    "                + \"<extra></extra>\"\n",
+    "            ),\n",
     "        )\n",
-    "    ))\n",
-    "    \n",
+    "    )\n",
+    "\n",
     "    # Add quadrant lines\n",
     "    # Calculate median values for quadrant boundaries\n",
-    "    median_high_complexity = repo_metrics['high_complexity_methods'].median()\n",
-    "    median_avg_complexity = repo_metrics['avg_complexity'].median()\n",
-    "    \n",
+    "    median_high_complexity = repo_metrics[\"high_complexity_methods\"].median()\n",
+    "    median_avg_complexity = repo_metrics[\"avg_complexity\"].median()\n",
+    "\n",
     "    # Add vertical line at median high complexity methods\n",
     "    fig.add_vline(\n",
-    "        x=median_high_complexity,\n",
-    "        line_dash=\"dash\",\n",
-    "        line_color=\"gray\",\n",
-    "        opacity=0.5\n",
+    "        x=median_high_complexity, line_dash=\"dash\", line_color=\"gray\", opacity=0.5\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    # Add horizontal line at median average complexity\n",
     "    fig.add_hline(\n",
-    "        y=median_avg_complexity,\n",
-    "        line_dash=\"dash\",\n",
-    "        line_color=\"gray\",\n",
-    "        opacity=0.5\n",
+    "        y=median_avg_complexity, line_dash=\"dash\", line_color=\"gray\", opacity=0.5\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    # Add quadrant labels\n",
     "    annotations = [\n",
     "        # High Risk (top right)\n",
@@ -1946,7 +1953,7 @@
     "            showarrow=False,\n",
     "            bgcolor=\"rgba(255,0,0,0.1)\",\n",
     "            borderpad=4,\n",
-    "            font=dict(size=10)\n",
+    "            font=dict(size=10),\n",
     "        ),\n",
     "        # Systemic Complexity (top left)\n",
     "        dict(\n",
@@ -1958,7 +1965,7 @@
     "            showarrow=False,\n",
     "            bgcolor=\"rgba(255,165,0,0.1)\",\n",
     "            borderpad=4,\n",
-    "            font=dict(size=10)\n",
+    "            font=dict(size=10),\n",
     "        ),\n",
     "        # Localized Issues (bottom right)\n",
     "        dict(\n",
@@ -1970,7 +1977,7 @@
     "            showarrow=False,\n",
     "            bgcolor=\"rgba(255,255,0,0.1)\",\n",
     "            borderpad=4,\n",
-    "            font=dict(size=10)\n",
+    "            font=dict(size=10),\n",
     "        ),\n",
     "        # Low Risk (bottom left)\n",
     "        dict(\n",
@@ -1982,36 +1989,38 @@
     "            showarrow=False,\n",
     "            bgcolor=\"rgba(0,255,0,0.1)\",\n",
     "            borderpad=4,\n",
-    "            font=dict(size=10)\n",
-    "        )\n",
+    "            font=dict(size=10),\n",
+    "        ),\n",
     "    ]\n",
-    "    \n",
+    "\n",
     "    # Update layout\n",
     "    fig.update_layout(\n",
     "        title=dict(\n",
     "            text=f\"Cyclomatic Complexity Risk Matrix<br><sub>Bubble size represents number of classes | Threshold: {complexity_threshold}</sub>\",\n",
-    "            font=dict(size=16)\n",
+    "            font=dict(size=16),\n",
     "        ),\n",
     "        xaxis=dict(\n",
-    "            title=\"Number of High Complexity Methods (≥\" + str(complexity_threshold) + \")\",\n",
-    "            gridcolor='rgba(128,128,128,0.2)',\n",
+    "            title=\"Number of High Complexity Methods (≥\"\n",
+    "            + str(complexity_threshold)\n",
+    "            + \")\",\n",
+    "            gridcolor=\"rgba(128,128,128,0.2)\",\n",
     "            showgrid=True,\n",
     "            zeroline=True,\n",
-    "            zerolinecolor='rgba(128,128,128,0.2)'\n",
+    "            zerolinecolor=\"rgba(128,128,128,0.2)\",\n",
     "        ),\n",
     "        yaxis=dict(\n",
     "            title=\"Average Complexity per Repository\",\n",
-    "            gridcolor='rgba(128,128,128,0.2)',\n",
+    "            gridcolor=\"rgba(128,128,128,0.2)\",\n",
     "            showgrid=True,\n",
     "            zeroline=True,\n",
-    "            zerolinecolor='rgba(128,128,128,0.2)'\n",
+    "            zerolinecolor=\"rgba(128,128,128,0.2)\",\n",
     "        ),\n",
     "        margin=dict(l=60, r=120, t=100, b=60),\n",
-    "        plot_bgcolor='white',\n",
+    "        plot_bgcolor=\"white\",\n",
     "        annotations=annotations,\n",
-    "        hovermode='closest'\n",
+    "        hovermode=\"closest\",\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    # Show the figure\n",
     "    fig.show(render=\"plotly_mimetype\")"
    ]

{moderne_visualizations_misc-0.76.0 → moderne_visualizations_misc-1.0.0}/moderne_visualizations_misc/dependency_usage_violin_gradle.ipynb

@@ -152,7 +152,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.11"
+   "version": "3.12.8"
   }
  },
  "nbformat": 4,