![](\"https://www.medgadget.com/wp-content/uploads/2020/06/IMG_0914-1024x577.jpeg\")
\n",
"\n",
"\n",
"Ever wanted to constantly monitor your blood glucose every 5 minutes, 24/7? With the [Dexcom G6 PRO CGM device](https://provider.dexcom.com/products/dexcom-g6-pro), you can track your glucose levels continuously over time and beam this data back so you can analyze it for yourself. In this notebook, we'll be showing you how to do just that, assuming you already have a Dexcom G6 PRO CGM device set up and tracking.\n",
"\n",
"If you want to know more about the Dexcom G6 PRO CGM device, see the [README](https://github.com/alrojo/wearipedia/tree/main/wearables/dexcom-g6-pro) for a detailed analysis of performances, sensors, data privacy, and extraction pipelines.\n",
"\n",
"We were able to extract glucose levels at a sampling rate of every 5 minutes from the API.\n",
"\n",
"![](\"https://i.imgur.com/j8WBnHH.png\")
\n",
"\n",
"Now we can proceed with the rest of the notebook. Enter your the credentials from the app, and make sure that the redirect URI matches."
],
"metadata": {
"id": "cab7P6_f4eHn"
}
},
{
"cell_type": "code",
"source": [
"#@title Enter your credentials\n",
"\n",
"# for calendar plot\n",
"!pip install -q july\n",
"\n",
"import requests\n",
"import urllib\n",
"import json\n",
"from datetime import datetime\n",
"import http.client\n",
"\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"\n",
"import july\n",
"from july.utils import date_range\n",
"\n",
"\n",
"your_client_secret = \"NtWS1ViwrO9zuNkZ\" #@param {type:\"string\"}\n",
"your_client_id = \"n92KUDE2pumPUO4u3FStNhKmmpUaV7Gw\" #@param {type:\"string\"}\n",
"your_redirect_uri = \"https://www.google.com\" #@param {type:\"string\"}\n",
"your_state_value = '1234'\n",
"\n",
"url = f'https://api.dexcom.com/v2/oauth2/login?client_id={your_client_id}&redirect_uri={your_redirect_uri}&response_type=code&scope=offline_access&state={your_state_value}'\n",
"\n",
"print(url)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"cellView": "form",
"id": "RO3IljoG01Fd",
"outputId": "eecbb6f2-8eb4-4e98-926a-534c57bc4587"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"https://api.dexcom.com/v2/oauth2/login?client_id=n92KUDE2pumPUO4u3FStNhKmmpUaV7Gw&redirect_uri=https://www.google.com&response_type=code&scope=offline_access&state=1234\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"Visit the above URL and authorize yourself. You should see a page like this. In our case, enter `anusridh@stanford.edu` and `Stanford123` as the password.\n",
"\n",
"![](\"https://imgur.com/9QyqTAd.png\")
\n",
"\n",
"You may have to go through a second page where you have to type in your signature. Then, once you go through this portal, copy the URL you were redirected to below. You must do this quickly (there is a one minute expiration countdown).\n",
"\n",
"This will grant us an access token that lasts 10 minutes."
],
"metadata": {
"id": "6TtWtEhq78N9"
}
},
{
"cell_type": "code",
"source": [
"#@title Copy the URL into the text box below\n",
"redirect_url = \"https://www.google.com/?code=6fa48a835c032d81eba4991963106771&state=1234\" #@param {type:\"string\"}\n",
"\n",
"try:\n",
" your_authorization_code = urllib.parse.parse_qs(urllib.parse.urlparse(redirect_url).query)['code'][0]\n",
"except Exception as e:\n",
" print(f'Caught error:\\n{e}\\n')\n",
" print(\"Please copy and paste the entire URL (including https)\")\n",
"\n",
"\n",
"conn = http.client.HTTPSConnection(\"api.dexcom.com\")\n",
"\n",
"payload = f\"client_secret={your_client_secret}&client_id={your_client_id}&code={your_authorization_code}&grant_type=authorization_code&redirect_uri={your_redirect_uri}\"\n",
"\n",
"headers = {\n",
" 'content-type': \"application/x-www-form-urlencoded\",\n",
" 'cache-control': \"no-cache\"\n",
" }\n",
"\n",
"conn.request(\"POST\", \"/v2/oauth2/token\", payload, headers)\n",
"\n",
"res = conn.getresponse()\n",
"data = res.read()\n",
"\n",
"json_response = json.loads(data.decode('utf-8'))\n",
"\n",
"if 'error' in json_response.keys() and json_response['error'] == 'invalid_grant':\n",
" print('The code you got has expired.')\n",
" print('Authorize and enter the redirect URL again.')\n",
"else:\n",
" access_token = json.loads(data.decode('utf-8'))['access_token']\n",
"\n",
" print(f'Entire response was {data.decode(\"utf-8\")}')\n",
" print(f'Our access token is {access_token}')"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "bl-_tkzG1bKr",
"outputId": "257094ab-6011-4996-dbd0-4dd6da2f079f",
"cellView": "form"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"The code you got has expired.\n",
"Authorize and enter the redirect URL again.\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"# 3. Data extraction\n",
"\n",
"Data extraction is fairly simple for this API. For documentation about what endpoints you can hit and what data you can get, see [this official link](https://developer.dexcom.com/endpoint-overview). Here, we'll just extract the time-varying CGM values, which you can see more details for [here](https://developer.dexcom.com/get-egvs).\n",
"\n",
"Note: the start and end dates must be within 90 days of each other."
],
"metadata": {
"id": "M9UupU4kAFW8"
}
},
{
"cell_type": "code",
"source": [
"#@title Enter start and end dates\n",
"\n",
"from datetime import timedelta\n",
"from tqdm import tqdm\n",
"from scipy.ndimage import gaussian_filter\n",
"\n",
"start_day = datetime.strptime('2022-03-31', '%Y-%m-%d')\n",
"\n",
"def lerp(x1, x2, t):\n",
" return t * x2 + (1 - t) * x1\n",
"\n",
"base_keypoints = [100] * 4 + [120] * 4 + [130] * 8 + [120] * 4 + [100] * 4\n",
"\n",
"def create_synth_df():\n",
" datetimes = []\n",
" glucoses = []\n",
"\n",
" for day_offset in tqdm(range(12)):\n",
" if day_offset != 0:\n",
" overlap = keypoints[-1]\n",
" keypoints = list(np.random.randn(24) * 10 + np.array(base_keypoints))\n",
" if day_offset != 0:\n",
" keypoints[0] = overlap\n",
"\n",
" keypoints = keypoints + [keypoints[0]]\n",
"\n",
" for minute_offset in range(0, 24 * 60, 5):\n",
" minute = start_day + timedelta(days=day_offset) + timedelta(minutes=minute_offset)\n",
"\n",
" scaled_offset = minute_offset / 60\n",
"\n",
" k1 = keypoints[np.floor(scaled_offset).astype('int')]\n",
" k2 = keypoints[np.ceil(scaled_offset).astype('int')]\n",
"\n",
" value = lerp(k1, k2, scaled_offset % 1)\n",
" if value > 130:\n",
" scaling = 30\n",
" else:\n",
" scaling = 15\n",
" value += np.random.randn() * scaling\n",
"\n",
" datetimes.append(minute)\n",
" glucoses.append(value)\n",
"\n",
" synth_df = pd.DataFrame()\n",
"\n",
" synth_df['datetime'] = datetimes\n",
" synth_df['glucose_level'] = gaussian_filter(glucoses, 2, mode='constant')\n",
"\n",
" synth_df['Time of Day'] = ['Day' if dt.hour in range(8, 20) else 'Night' for dt in datetimes]\n",
" synth_df['Rates of change'] = np.random.randn(synth_df.shape[0])\n",
" synth_df['Rates of change'].iloc[np.where(synth_df['Time of Day'] == 'Day')[0]] *= 3\n",
"\n",
" # take out some rows to create missing values\n",
"\n",
" missing_start = datetime.strptime('2022-04-06', '%Y-%m-%d') + timedelta(hours=14)\n",
" missing_end = missing_start + timedelta(minutes=70)\n",
"\n",
" synth_df = synth_df.drop(np.where(np.logical_and(synth_df.datetime > missing_start, synth_df.datetime < missing_end))[0])\n",
"\n",
" return synth_df\n",
"\n",
"start_date = \"2022-02-16\" #@param {type:\"date\"}\n",
"end_date = \"2022-05-16\" #@param {type:\"date\"}\n",
"synthetic = True #@param {type:\"boolean\"}\n",
"\n",
"if synthetic:\n",
" df = create_synth_df()\n",
"else:\n",
" start_date = start_date + 'T15:30:00'\n",
" end_date = end_date + 'T15:45:00'\n",
"\n",
" headers = {\n",
" 'authorization': f\"Bearer {access_token}\"\n",
" }\n",
"\n",
" endpoint = f'https://api.dexcom.com/v2/users/self/egvs?startDate={start_date}&endDate={end_date}'\n",
"\n",
" out = json.loads(requests.get(endpoint, headers=headers).text)\n",
"\n",
" if 'errors' in out.keys():\n",
" print(f'Got error(s) {out[\"errors\"]}. Fix start and end dates and rerun.')\n",
" elif 'fault' in out.keys():\n",
" print(f'Got fault {out[\"fault\"]}. You might need to request another access token.')\n",
" else:\n",
" def dt_string_to_obj(dt_str):\n",
" # converts string like \"2022-04-10T10:13:00\" to a datetime object\n",
" return datetime.strptime(dt_str, '%Y-%m-%dT%H:%M:%S')\n",
" \n",
"\n",
" data_dict = [{'datetime': dt_string_to_obj(x['displayTime']), 'glucose_level': x['realtimeValue']} for x in out['egvs'][::-1]]\n",
"\n",
" df = pd.DataFrame.from_dict(data_dict)"
],
"metadata": {
"cellView": "form",
"id": "I93tIZpKCjQ7",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "da774499-1d71-46c9-ec61-fd59400811ba"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"100%|██████████| 12/12 [00:00<00:00, 124.69it/s]\n",
"/usr/local/lib/python3.7/dist-packages/pandas/core/indexing.py:1732: SettingWithCopyWarning: \n",
"A value is trying to be set on a copy of a slice from a DataFrame\n",
"\n",
"See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
" self._setitem_single_block(indexer, value, name)\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"The code hidden above initialized `df`, a Pandas dataframe that represents the time series values for glucose. If we look at the `glucose_level` column without time information, we'll see the following..."
],
"metadata": {
"id": "rNVJFNSJLLR8"
}
},
{
"cell_type": "code",
"source": [
"df.glucose_level.describe()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "nYrn9JpDNWoF",
"outputId": "d1223f52-6a36-4b8f-c141-592f03302a12"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"count 3443.000000\n",
"mean 115.135375\n",
"std 15.332945\n",
"min 53.110343\n",
"25% 103.611643\n",
"50% 117.088519\n",
"75% 125.586401\n",
"max 168.108454\n",
"Name: glucose_level, dtype: float64"
]
},
"metadata": {},
"execution_count": 4
}
]
},
{
"cell_type": "markdown",
"source": [
"As we can see, this user's glucose levels are around 100 mg/dL on average.\n",
"\n",
"And if we see how quickly the values were sampled at, we can see that they tend to be sampled in increments of 300 seconds, or 5 minutes."
],
"metadata": {
"id": "91Opux_fNbUS"
}
},
{
"cell_type": "code",
"source": [
"diffs = np.diff(df.datetime.apply(lambda x: x.timestamp()))\n",
"pd.DataFrame(diffs).describe()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 300
},
"id": "Czf8IGuaPo6S",
"outputId": "7bdd5b4c-16a8-4594-bb30-98f42a85bd80"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" 0\n",
"count 3442.000000\n",
"mean 301.133062\n",
"std 66.475127\n",
"min 300.000000\n",
"25% 300.000000\n",
"50% 300.000000\n",
"75% 300.000000\n",
"max 4200.000000"
],
"text/html": [
"\n",
" ![](\"https://imgur.com/qQwXJIv.png\")
\n",
"\n",
"*This graph is taken directly from an exported PDF from the online webapp*\n",
"\n",
"First, we'll aggregate across all days and get aggregate glucose level statistics for every 15 minute interval. Then, we'll create a custom plot by leveraging lots of matplotlib functionality, including by poking deeper into the [Matplotlib architecture](https://www.aosabook.org/en/matplotlib.html) into the Artist layer and directly adding rounded rectangles to the plot (the error bars).\n",
"\n",
"Disclaimer: We aren't sure exactly how the error bars are derived, so the reproduced output is different."
],
"metadata": {
"id": "ZoVI0AkBNw9v"
}
},
{
"cell_type": "code",
"source": [
"#@title Aggregated day-long glucose level plot\n",
"from matplotlib.ticker import (MultipleLocator, FormatStrFormatter,\n",
" AutoMinorLocator)\n",
"import matplotlib.patches as patches\n",
"\n",
"def dt_to_raw_min(dt_obj):\n",
" return int(datetime.strftime(dt_obj, '%H')) * 60 + int(datetime.strftime(dt_obj, '%M'))\n",
"\n",
"raw_mins = np.array([dt_to_raw_min(x) for x in df.datetime])\n",
"\n",
"stats = []\n",
"\n",
"for i in range(0, 24 * 60, 15):\n",
" idxes_of_interest = np.where(np.logical_and(i < raw_mins, raw_mins < i + 15))[0]\n",
"\n",
" levels = np.array(df.glucose_level.iloc[idxes_of_interest])\n",
"\n",
" median_level = np.median(levels)\n",
"\n",
" mean_level = np.mean(levels)\n",
"\n",
" std_level = np.std(levels)\n",
" stde_level = np.std(levels) / np.sqrt(levels.shape[0])\n",
"\n",
" stats.append([median_level, mean_level, std_level, stde_level])\n",
"\n",
"\n",
"# now let's actually plot\n",
"\n",
"fig, ax = plt.subplots(figsize=(15, 4))\n",
"\n",
"# background color in vertical-wise intervals accordingly\n",
"for i in range(0, 500, 100):\n",
" plt.axhspan(i, i + 50, facecolor='whitesmoke')#, alpha=0.5)\n",
"\n",
"for i in range(50, 550, 100):\n",
" plt.axhspan(i, i + 50, facecolor='white')\n",
"\n",
"# now do the actual data\n",
"\n",
"# add 7 to make it all centered\n",
"plt.plot(range(7, 24 * 60 + 7, 15), [x[0] for x in stats], marker='o', markerfacecolor='black', markeredgecolor='white', color='black')\n",
"\n",
"RECT_WIDTH = 5\n",
"\n",
"for i, (median, mean, std, stde) in enumerate(stats):\n",
" rect_center = 15 * i + 7\n",
" rect_height = stde * 7\n",
" rect = patches.FancyBboxPatch((rect_center - RECT_WIDTH / 2, mean - rect_height / 2),\n",
" RECT_WIDTH, rect_height,\n",
" boxstyle=\"round,pad=-0.0040,rounding_size=5.5\",\n",
" #boxstyle='round',\n",
" linewidth=3, fc='silver', ec='silver')\n",
"\n",
" ax.add_patch(rect)\n",
"\n",
"# now plot horizontal lines\n",
"plt.plot([0, 24 * 60], [180, 180], color='orange', linewidth=2)\n",
"plt.plot([0, 24 * 60], [70, 70], color='red', linewidth=2)\n",
"\n",
"\n",
"# now in the rest of the code we'll handle the ticks and borders etc.\n",
"plt.ylim(25, 425)\n",
"\n",
"plt.xticks(ticks=np.linspace(0, 24 * 60, 9), labels=['12am', '3', '6', '9', '12pm', '3', '6', '9', '12am'])\n",
"\n",
"# make sure both major and minor x ticks are visible\n",
"plt.tick_params(\n",
" axis='x', # changes apply to the x-axis\n",
" which='both', # both major and minor ticks are affected\n",
" bottom=True, # ticks along the bottom edge are off\n",
" labelsize=16\n",
")\n",
"\n",
"# make major x ticks longer\n",
"plt.tick_params(\n",
" axis='x',\n",
" which='major',\n",
" length=10\n",
")\n",
"\n",
"plt.yticks(np.linspace(100, 400, 4).astype(int))\n",
"\n",
"plt.tick_params(\n",
" axis='y', # changes apply to the x-axis\n",
" which='both', # both major and minor ticks are affected\n",
" right=True, # ticks along the bottom edge are off\n",
" labelsize=12\n",
")\n",
"\n",
"# 2 and 1 minor ticks per major tick on x and y-axis, respectively (https://matplotlib.org/3.1.1/gallery/ticks_and_spines/major_minor_demo.html)\n",
"plt.gca().xaxis.set_minor_locator(AutoMinorLocator(3))\n",
"plt.gca().yaxis.set_minor_locator(AutoMinorLocator(2))\n",
"\n",
"# disable vertical and horizontal grid lines\n",
"plt.gca().xaxis.grid(False, which='both')\n",
"plt.gca().yaxis.grid(False, which='both')\n",
"\n",
"# get the y-axis ticks to appear on the right\n",
"plt.gca().yaxis.tick_right()\n",
"\n",
"# show the borders of the box (https://stackoverflow.com/questions/9750699/how-to-display-only-a-left-and-bottom-box-border-in-matplotlib)\n",
"for side in ['left', 'right', 'top', 'bottom']:\n",
" plt.gca().spines[side].set_visible(True)\n",
" plt.gca().spines[side].set_color('black')\n",
"\n",
"# https://stackoverflow.com/questions/42045767/how-can-i-change-the-x-axis-in-matplotlib-so-there-is-no-white-space\n",
"plt.margins(x=0)\n",
"\n",
"plt.show()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 277
},
"id": "DUSoIsoYIYFj",
"outputId": "8f547874-21e2-43a7-8f51-092dd7f02205",
"cellView": "form"
},
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"![](\"https://i.imgur.com/w4x37Ua.png\")
\n",
"\n",
"*Above is a plot taken directly from the Dexcom Clarity website!*\n",
"\n",
"Just enter any date you would like to plot, and the code below will plot its glucose levels, including missing values."
],
"metadata": {
"id": "quK9m2VKOAJ2"
}
},
{
"cell_type": "code",
"source": [
"#@title Visualize single day glucose levels\n",
"date_to_visualize = \"2022-04-06\" #@param {type:\"date\"}\n",
"\n",
"date_to_visualize_orig = date_to_visualize\n",
"date_to_visualize = '-'.join(date_to_visualize.split('-')[1:])\n",
"\n",
"from matplotlib.ticker import (MultipleLocator, FormatStrFormatter,\n",
" AutoMinorLocator)\n",
"import matplotlib.patches as patches\n",
"\n",
"import warnings\n",
"warnings.filterwarnings(\"ignore\")\n",
"\n",
"# restore rcParams\n",
"plt.rcParams.update(IPython_default)\n",
"\n",
"def dt_to_raw_min(dt_obj):\n",
" return int(datetime.strftime(dt_obj, '%H')) * 60 + int(datetime.strftime(dt_obj, '%M'))\n",
"\n",
"raw_mins = np.array([dt_to_raw_min(x) for x in df.datetime])\n",
"\n",
"idxes = np.where(df.datetime.apply(lambda x: datetime.strftime(x, '%m-%d')) == date_to_visualize)[0]\n",
"raw_mins = df.datetime.iloc[idxes].apply(lambda x: dt_to_raw_min(x))\n",
"glucose_levels = df.glucose_level.iloc[idxes]\n",
"\n",
"# now let's actually plot\n",
"\n",
"fig, ax = plt.subplots(figsize=(15, 4))\n",
"\n",
"# background color in vertical-wise intervals accordingly\n",
"for i in range(0, 500, 100):\n",
" plt.axhspan(i, i + 50, facecolor='whitesmoke')\n",
"\n",
"for i in range(50, 550, 100):\n",
" plt.axhspan(i, i + 50, facecolor='white')\n",
"\n",
"# now do the actual data\n",
"\n",
"gaps = list(np.where(np.diff(raw_mins) > 10)[0] + 1)\n",
"cur_start = 0\n",
"for gap in (gaps + [len(raw_mins)]):\n",
" plt.plot(raw_mins.iloc[cur_start:gap],\n",
" glucose_levels.iloc[cur_start:gap], color='black',\n",
" linewidth=2)\n",
" cur_start = gap\n",
"\n",
"# now plot horizontal lines\n",
"plt.plot([0, 24 * 60], [180, 180], color='orange', linewidth=2)\n",
"plt.plot([0, 24 * 60], [70, 70], color='red', linewidth=2)\n",
"\n",
"\n",
"# now in the rest of the code we'll handle the ticks and borders etc.\n",
"plt.ylim(25, 425)\n",
"\n",
"plt.xticks(ticks=np.linspace(0, 24 * 60, 9), labels=['12am', '3', '6', '9', '12pm', '3', '6', '9', '12am'])\n",
"\n",
"# make sure both major and minor x ticks are visible\n",
"plt.tick_params(\n",
" axis='x', # changes apply to the x-axis\n",
" which='both', # both major and minor ticks are affected\n",
" bottom=True, # ticks along the bottom edge are off\n",
" labelsize=16\n",
")\n",
"\n",
"# make major x ticks longer\n",
"plt.tick_params(\n",
" axis='x',\n",
" which='major',\n",
" length=10\n",
")\n",
"\n",
"plt.yticks(np.linspace(100, 400, 4).astype(int))\n",
"\n",
"plt.tick_params(\n",
" axis='y', # changes apply to the x-axis\n",
" which='both', # both major and minor ticks are affected\n",
" right=True, # ticks along the bottom edge are off\n",
" labelsize=12\n",
")\n",
"\n",
"# 2 and 1 minor ticks per major tick on x and y-axis, respectively (https://matplotlib.org/3.1.1/gallery/ticks_and_spines/major_minor_demo.html)\n",
"plt.gca().xaxis.set_minor_locator(AutoMinorLocator(3))\n",
"plt.gca().yaxis.set_minor_locator(AutoMinorLocator(2))\n",
"\n",
"# disable vertical and horizontal grid lines\n",
"plt.gca().xaxis.grid(False, which='both')\n",
"plt.gca().yaxis.grid(False, which='both')\n",
"\n",
"# get the y-axis ticks to appear on the right\n",
"plt.gca().yaxis.tick_left()\n",
"\n",
"# show the borders of the box (https://stackoverflow.com/questions/9750699/how-to-display-only-a-left-and-bottom-box-border-in-matplotlib)\n",
"for side in ['left', 'right', 'top', 'bottom']:\n",
" plt.gca().spines[side].set_visible(True)\n",
" plt.gca().spines[side].set_color('black')\n",
"\n",
"# https://stackoverflow.com/questions/42045767/how-can-i-change-the-x-axis-in-matplotlib-so-there-is-no-white-space\n",
"plt.margins(x=0)\n",
"\n",
"date_to_visualize_fmted = datetime.strftime(datetime.strptime(date_to_visualize_orig, '%Y-%m-%d'), '%a, %b %-d, %Y')\n",
"\n",
"plt.title(f'{date_to_visualize_fmted}', fontsize=15, fontweight='bold')\n",
"\n",
"plt.show()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 295
},
"cellView": "form",
"id": "bNsSk5Pbp7ob",
"outputId": "691ee9a2-cc21-456e-faf4-32e170449034"
},
"execution_count": null,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"