CloudWatchClient.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c9de93fc-9a69-4d25-b16d-e3ae7bf48652",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting /home/studio-lab-user/.aws/credentials\n"
     ]
    }
   ],
   "source": [
    "%%writefile ~/.aws/credentials\n",
    "[default]\n",
    "aws_access_key_id = AKIAUTN6EEHRLIVGYRVQ\n",
    "aws_secret_access_key = 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8ead85b4-97af-4927-a613-f7e739505238",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta\n",
    "import logging\n",
    "from pprint import pprint\n",
    "import random\n",
    "import time\n",
    "import boto3\n",
    "from botocore.exceptions import ClientError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "78398495-2a68-4cd4-8289-e3d3cb18ed8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "logger = logging.getLogger(__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d7e1b02b-6118-4d18-a52d-0eadc2a5095a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CloudWatchWrapper:\n",
    "    \"\"\"Encapsulates Amazon CloudWatch functions.\"\"\"\n",
    "    def __init__(self, cloudwatch_resource):\n",
    "        \"\"\"\n",
    "        :param cloudwatch_resource: A Boto3 CloudWatch resource.\n",
    "        \"\"\"\n",
    "        self.cloudwatch_resource = cloudwatch_resource\n",
    "\n",
    "    def list_metrics(self, namespace, name, recent=False):\n",
    "        \"\"\"\n",
    "        Gets the metrics within a namespace that have the specified name.\n",
    "        If the metric has no dimensions, a single metric is returned.\n",
    "        Otherwise, metrics for all dimensions are returned.\n",
    "\n",
    "        :param namespace: The namespace of the metric.\n",
    "        :param name: The name of the metric.\n",
    "        :param recent: When True, only metrics that have been active in the last\n",
    "                       three hours are returned.\n",
    "        :return: An iterator that yields the retrieved metrics.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            kwargs = {'Namespace': namespace, 'MetricName': name}\n",
    "            if recent:\n",
    "                kwargs['RecentlyActive'] = 'PT3H'  # List past 3 hours only\n",
    "            metric_iter = self.cloudwatch_resource.metrics.filter(**kwargs)\n",
    "            logger.info(\"Got metrics for %s.%s.\", namespace, name)\n",
    "        except ClientError:\n",
    "            logger.exception(\"Couldn't get metrics for %s.%s.\", namespace, name)\n",
    "            raise\n",
    "        else:\n",
    "            return metric_iter\n",
    "\n",
    "    def put_metric_data(self, namespace, name, value, unit):\n",
    "        \"\"\"\n",
    "        Sends a single data value to CloudWatch for a metric. This metric is given\n",
    "        a timestamp of the current UTC time.\n",
    "\n",
    "        :param namespace: The namespace of the metric.\n",
    "        :param name: The name of the metric.\n",
    "        :param value: The value of the metric.\n",
    "        :param unit: The unit of the metric.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            metric = self.cloudwatch_resource.Metric(namespace, name)\n",
    "            metric.put_data(\n",
    "                Namespace=namespace,\n",
    "                MetricData=[{\n",
    "                    'MetricName': name,\n",
    "                    'Value': value,\n",
    "                    'Unit': unit\n",
    "                }]\n",
    "            )\n",
    "            logger.info(\"Put data for metric %s.%s\", namespace, name)\n",
    "        except ClientError:\n",
    "            logger.exception(\"Couldn't put data for metric %s.%s\", namespace, name)\n",
    "            raise\n",
    "\n",
    "    def put_metric_data_set(self, namespace, name, timestamp, unit, data_set):\n",
    "        \"\"\"\n",
    "        Sends a set of data to CloudWatch for a metric. All of the data in the set\n",
    "        have the same timestamp and unit.\n",
    "\n",
    "        :param namespace: The namespace of the metric.\n",
    "        :param name: The name of the metric.\n",
    "        :param timestamp: The UTC timestamp for the metric.\n",
    "        :param unit: The unit of the metric.\n",
    "        :param data_set: The set of data to send. This set is a dictionary that\n",
    "                         contains a list of values and a list of corresponding counts.\n",
    "                         The value and count lists must be the same length.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            metric = self.cloudwatch_resource.Metric(namespace, name)\n",
    "            metric.put_data(\n",
    "                Namespace=namespace,\n",
    "                MetricData=[{\n",
    "                    'MetricName': name,\n",
    "                    'Timestamp': timestamp,\n",
    "                    'Values': data_set['values'],\n",
    "                    'Counts': data_set['counts'],\n",
    "                    'Unit': unit}])\n",
    "            logger.info(\"Put data set for metric %s.%s.\", namespace, name)\n",
    "        except ClientError:\n",
    "            logger.exception(\"Couldn't put data set for metric %s.%s.\", namespace, name)\n",
    "            raise\n",
    "\n",
    "    def get_metric_statistics(self, namespace, name, start, end, period, stat_types):\n",
    "        \"\"\"\n",
    "        Gets statistics for a metric within a specified time span. Metrics are grouped\n",
    "        into the specified period.\n",
    "\n",
    "        :param namespace: The namespace of the metric.\n",
    "        :param name: The name of the metric.\n",
    "        :param start: The UTC start time of the time span to retrieve.\n",
    "        :param end: The UTC end time of the time span to retrieve.\n",
    "        :param period: The period, in seconds, in which to group metrics. The period\n",
    "                       must match the granularity of the metric, which depends on\n",
    "                       the metric's age. For example, metrics that are older than\n",
    "                       three hours have a one-minute granularity, so the period must\n",
    "                       be at least 60 and must be a multiple of 60.\n",
    "        :param stat_types: The type of statistics to retrieve, such as average value\n",
    "                           or maximum value.\n",
    "        :return: The retrieved statistics for the metric.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            metric = self.cloudwatch_resource.Metric(namespace, name)\n",
    "            stats = metric.get_statistics(\n",
    "                StartTime=start, EndTime=end, Period=period, Statistics=stat_types)\n",
    "            logger.info(\n",
    "                \"Got %s statistics for %s.\", len(stats['Datapoints']), stats['Label'])\n",
    "        except ClientError:\n",
    "            logger.exception(\"Couldn't get statistics for %s.%s.\", namespace, name)\n",
    "            raise\n",
    "        else:\n",
    "            return stats\n",
    "\n",
    "    def create_metric_alarm(\n",
    "            self, metric_namespace, metric_name, alarm_name, stat_type, period,\n",
    "            eval_periods, threshold, comparison_op):\n",
    "        \"\"\"\n",
    "        Creates an alarm that watches a metric.\n",
    "\n",
    "        :param metric_namespace: The namespace of the metric.\n",
    "        :param metric_name: The name of the metric.\n",
    "        :param alarm_name: The name of the alarm.\n",
    "        :param stat_type: The type of statistic the alarm watches.\n",
    "        :param period: The period in which metric data are grouped to calculate\n",
    "                       statistics.\n",
    "        :param eval_periods: The number of periods that the metric must be over the\n",
    "                             alarm threshold before the alarm is set into an alarmed\n",
    "                             state.\n",
    "        :param threshold: The threshold value to compare against the metric statistic.\n",
    "        :param comparison_op: The comparison operation used to compare the threshold\n",
    "                              against the metric.\n",
    "        :return: The newly created alarm.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            metric = self.cloudwatch_resource.Metric(metric_namespace, metric_name)\n",
    "            alarm = metric.put_alarm(\n",
    "                AlarmName=alarm_name,\n",
    "                Statistic=stat_type,\n",
    "                Period=period,\n",
    "                EvaluationPeriods=eval_periods,\n",
    "                Threshold=threshold,\n",
    "                ComparisonOperator=comparison_op)\n",
    "            logger.info(\n",
    "                \"Added alarm %s to track metric %s.%s.\", alarm_name, metric_namespace,\n",
    "                metric_name)\n",
    "        except ClientError:\n",
    "            logger.exception(\n",
    "                \"Couldn't add alarm %s to metric %s.%s\", alarm_name, metric_namespace,\n",
    "                metric_name)\n",
    "            raise\n",
    "        else:\n",
    "            return alarm\n",
    "\n",
    "    def get_metric_alarms(self, metric_namespace, metric_name):\n",
    "        \"\"\"\n",
    "        Gets the alarms that are currently watching the specified metric.\n",
    "\n",
    "        :param metric_namespace: The namespace of the metric.\n",
    "        :param metric_name: The name of the metric.\n",
    "        :returns: An iterator that yields the alarms.\n",
    "        \"\"\"\n",
    "        metric = self.cloudwatch_resource.Metric(metric_namespace, metric_name)\n",
    "        alarm_iter = metric.alarms.all()\n",
    "        logger.info(\"Got alarms for metric %s.%s.\", metric_namespace, metric_name)\n",
    "        return alarm_iter\n",
    "\n",
    "    def enable_alarm_actions(self, alarm_name, enable):\n",
    "        \"\"\"\n",
    "        Enables or disables actions on the specified alarm. Alarm actions can be\n",
    "        used to send notifications or automate responses when an alarm enters a\n",
    "        particular state.\n",
    "\n",
    "        :param alarm_name: The name of the alarm.\n",
    "        :param enable: When True, actions are enabled for the alarm. Otherwise, they\n",
    "                       disabled.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            alarm = self.cloudwatch_resource.Alarm(alarm_name)\n",
    "            if enable:\n",
    "                alarm.enable_actions()\n",
    "            else:\n",
    "                alarm.disable_actions()\n",
    "            logger.info(\n",
    "                \"%s actions for alarm %s.\", \"Enabled\" if enable else \"Disabled\",\n",
    "                alarm_name)\n",
    "        except ClientError:\n",
    "            logger.exception(\n",
    "                \"Couldn't %s actions alarm %s.\", \"enable\" if enable else \"disable\",\n",
    "                alarm_name)\n",
    "            raise\n",
    "\n",
    "    def delete_metric_alarms(self, metric_namespace, metric_name):\n",
    "        \"\"\"\n",
    "        Deletes all of the alarms that are currently watching the specified metric.\n",
    "\n",
    "        :param metric_namespace: The namespace of the metric.\n",
    "        :param metric_name: The name of the metric.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            metric = self.cloudwatch_resource.Metric(metric_namespace, metric_name)\n",
    "            metric.alarms.delete()\n",
    "            logger.info(\n",
    "                \"Deleted alarms for metric %s.%s.\", metric_namespace, metric_name)\n",
    "        except ClientError:\n",
    "            logger.exception(\n",
    "                \"Couldn't delete alarms for metric %s.%s.\", metric_namespace,\n",
    "                metric_name)\n",
    "            raise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fb8261dd-c0d5-4dd7-a750-3b4e1ed4f2d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "35e27975-36d4-4441-a321-c9cfdf0abc65",
   "metadata": {},
   "outputs": [],
   "source": [
    "cw_wrapper = CloudWatchWrapper(boto3.resource('cloudwatch'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bdbb552d-dce3-4b3c-8937-a4ae5c220dca",
   "metadata": {},
   "outputs": [],
   "source": [
    "minutes = 20\n",
    "metric_namespace = 'doc-example-metric'\n",
    "metric_name = 'page_views'\n",
    "start = datetime.utcnow() - timedelta(minutes=minutes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c38101b4-bf32-42f5-8440-d666acb9589c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Putting data into metric doc-example-metric.page_views spanning the last 20 minutes.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Putting data into metric {metric_namespace}.{metric_name} spanning the \"\n",
    "      f\"last {minutes} minutes.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1012957e-8f9b-400d-b5c1-216efe2fc30f",
   "metadata": {},
   "outputs": [],
   "source": [
    "for offset in range(0, minutes):\n",
    "    stamp = start + timedelta(minutes=offset)\n",
    "    cw_wrapper.put_metric_data_set(\n",
    "        metric_namespace, metric_name, stamp, 'Count', {\n",
    "            'values': [\n",
    "                random.randint(bound, bound * 2)\n",
    "                for bound in range(offset + 1, offset + 11)],\n",
    "            'counts': [random.randint(1, offset + 1) for _ in range(10)]\n",
    "        })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a13bdc4a-4f62-4e94-bf51-409053d8056d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating alarm high_page_views for metric page_views.\n",
      "Alarm ARN is arn:aws:cloudwatch:us-east-1:316615696866:alarm:high_page_views.\n",
      "Current alarm state is: INSUFFICIENT_DATA.\n"
     ]
    }
   ],
   "source": [
    "alarm_name = 'high_page_views'\n",
    "period = 60\n",
    "eval_periods = 2\n",
    "print(f\"Creating alarm {alarm_name} for metric {metric_name}.\")\n",
    "alarm = cw_wrapper.create_metric_alarm(\n",
    "    metric_namespace, metric_name, alarm_name, 'Maximum', period, eval_periods,\n",
    "    100, 'GreaterThanThreshold')\n",
    "print(f\"Alarm ARN is {alarm.alarm_arn}.\")\n",
    "print(f\"Current alarm state is: {alarm.state_value}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68fe41aa-806b-4c94-8258-0f7259a27a52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sending data to trigger the alarm. This requires data over the threshold for 2 periods of 60 seconds each.\n",
      "Sending data for the metric.\n",
      "Current alarm state is: INSUFFICIENT_DATA.\n",
      "Waiting for 60 seconds...\n"
     ]
    }
   ],
   "source": [
    "print(f\"Sending data to trigger the alarm. This requires data over the threshold \"\n",
    "      f\"for {eval_periods} periods of {period} seconds each.\")\n",
    "while alarm.state_value == 'INSUFFICIENT_DATA':\n",
    "    print(\"Sending data for the metric.\")\n",
    "    cw_wrapper.put_metric_data(\n",
    "        metric_namespace, metric_name, random.randint(100, 200), 'Count')\n",
    "    alarm.load()\n",
    "    print(f\"Current alarm state is: {alarm.state_value}.\")\n",
    "    if alarm.state_value == 'INSUFFICIENT_DATA':\n",
    "        print(f\"Waiting for {period} seconds...\")\n",
    "        time.sleep(period)\n",
    "    else:\n",
    "        print(\"Wait for a minute for eventual consistency of metric data.\")\n",
    "        time.sleep(period)\n",
    "        if alarm.state_value == 'OK':\n",
    "            alarm.load()\n",
    "            print(f\"Current alarm state is: {alarm.state_value}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4df7e028-d0c5-4446-bd25-f3c4d97f8e6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Got 16 statistics for page_views.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting data for metric doc-example-metric.page_views during timespan of 2022-06-13 17:10:39.545884 to 2022-06-13 17:32:47.790321 (times are UTC).\n",
      "Got 16 data points for metric doc-example-metric.page_views.\n",
      "[{'Average': 343.8353265869365,\n",
      "  'Maximum': 474.0,\n",
      "  'Minimum': 10.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 10, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 367.2035851472471,\n",
      "  'Maximum': 480.0,\n",
      "  'Minimum': 13.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 11, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 348.536409516943,\n",
      "  'Maximum': 489.0,\n",
      "  'Minimum': 14.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 12, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 321.76414273281114,\n",
      "  'Maximum': 474.0,\n",
      "  'Minimum': 12.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 13, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 328.4273127753304,\n",
      "  'Maximum': 480.0,\n",
      "  'Minimum': 13.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 14, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 334.16046831955924,\n",
      "  'Maximum': 483.0,\n",
      "  'Minimum': 16.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 15, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 333.70210135970336,\n",
      "  'Maximum': 500.0,\n",
      "  'Minimum': 14.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 16, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 318.09714795008915,\n",
      "  'Maximum': 494.0,\n",
      "  'Minimum': 16.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 17, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 349.49709114415,\n",
      "  'Maximum': 469.0,\n",
      "  'Minimum': 16.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 18, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 368.43335192414946,\n",
      "  'Maximum': 484.0,\n",
      "  'Minimum': 17.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 19, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 343.1724409448819,\n",
      "  'Maximum': 499.0,\n",
      "  'Minimum': 22.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 20, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 347.2144495412844,\n",
      "  'Maximum': 489.0,\n",
      "  'Minimum': 25.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 21, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 35.02092050209205,\n",
      "  'Maximum': 47.0,\n",
      "  'Minimum': 20.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 22, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 192.0,\n",
      "  'Maximum': 192.0,\n",
      "  'Minimum': 192.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 28, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 173.0,\n",
      "  'Maximum': 173.0,\n",
      "  'Minimum': 173.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 30, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'},\n",
      " {'Average': 110.0,\n",
      "  'Maximum': 110.0,\n",
      "  'Minimum': 110.0,\n",
      "  'Timestamp': datetime.datetime(2022, 6, 13, 17, 31, tzinfo=tzlocal()),\n",
      "  'Unit': 'Count'}]\n"
     ]
    }
   ],
   "source": [
    "print(f\"Getting data for metric {metric_namespace}.{metric_name} during timespan \"\n",
    "      f\"of {start} to {datetime.utcnow()} (times are UTC).\")\n",
    "stats = cw_wrapper.get_metric_statistics(\n",
    "    metric_namespace, metric_name, start, datetime.utcnow(), 60,\n",
    "    ['Average', 'Minimum', 'Maximum'])\n",
    "print(f\"Got {len(stats['Datapoints'])} data points for metric \"\n",
    "      f\"{metric_namespace}.{metric_name}.\")\n",
    "pprint(sorted(stats['Datapoints'], key=lambda x: x['Timestamp']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "10acfeb8-3f28-49c6-9fe7-b45dac0bd622",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Got alarms for metric doc-example-metric.page_views.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting alarms for metric page_views.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Getting alarms for metric {metric_name}.\")\n",
    "alarms = cw_wrapper.get_metric_alarms(metric_namespace, metric_name)\n",
    "for alarm in alarms:\n",
    "    print(f\"Alarm {alarm.name} is currently in state {alarm.state_value}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6058838d-6add-41bb-b1ce-9d643b60df12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deleting alarms for metric page_views.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: Deleted alarms for metric doc-example-metric.page_views.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Deleting alarms for metric {metric_name}.\")\n",
    "cw_wrapper.delete_metric_alarms(metric_namespace, metric_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e4958f3-275d-454b-8402-8fec5b83e5b6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "default:Python",
   "language": "python",
   "name": "conda-env-default-py"
  },
  "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}