rainviewer_api.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "172328f0",
   "metadata": {},
   "source": [
    "# Berlin Rain Map with RAINVIEWER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53c65f5c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "fa573445",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "from geopy.geocoders import Nominatim\n",
    "\n",
    "from timezonefinder import TimezoneFinder\n",
    "from datetime import datetime, timedelta\n",
    "import pytz\n",
    "\n",
    "from PIL import Image, ImageDraw, ImageFont, ImageSequence\n",
    "from io import BytesIO\n",
    "\n",
    "import glob\n",
    "import os\n",
    "\n",
    "import pandas as pd\n",
    "# import geopandas as gpd  # isn't used\n",
    "import plotly.express as px"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "fd4f390b",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# import matplotlib.pyplot as plt\n",
    "# import geoplot as gplt\n",
    "# import geoplot.crs as gcrs\n",
    "# import pyproj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "9ce2aa04",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2d0fa45f",
   "metadata": {},
   "source": [
    "## 1. Getting the coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "13cba98c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# input the name of the city\n",
    "\n",
    "location_name = \"Berlin\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "f7ed0dc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Location address: Berlin\n",
      "Latitude and Longitude of the said address: (52.5170365, 13.3888599)\n"
     ]
    }
   ],
   "source": [
    "location = Nominatim(user_agent=\"RainRadar\").geocode(location_name) # user_agent=\"geoapiExercises\"\n",
    "my_coordinates = [location.latitude, location.longitude]\n",
    "# my_coordinates = [52.5170365, 13.3888599]\n",
    "\n",
    "print(\"Location address:\", location_name)\n",
    "print(\"Latitude and Longitude of the said address:\", (my_coordinates[0], my_coordinates[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "836e2802",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Europe/Berlin\n"
     ]
    }
   ],
   "source": [
    "obj = TimezoneFinder()\n",
    "tz_value = obj.timezone_at(lat=my_coordinates[0], lng=my_coordinates[1])\n",
    "tz_value = pytz.timezone(tz_value)\n",
    "\n",
    "print(tz_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e52c2704",
   "metadata": {},
   "source": [
    "## 2. Conneting to API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee8e00fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.rainviewer.com/api/weather-maps-api.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "9a756fe1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weather_url = \"https://api.rainviewer.com/public/weather-maps.json\"\n",
    "weather_response = requests.get(weather_url)\n",
    "weather_response.status_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "d398a166",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'User-Agent': 'python-requests/2.28.1', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'}"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# weather_response.text\n",
    "weather_request = weather_response.request\n",
    "weather_request.headers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "700c57fc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# weather_response.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "d0625fed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time of request:\n",
      "2023-05-21 10:45:23 CEST\n"
     ]
    }
   ],
   "source": [
    "print(\"Time of request:\")\n",
    "request_time = datetime.fromtimestamp(weather_response.json()['generated'], tz=tz_value)\n",
    "print(request_time.strftime(\"%Y-%m-%d %H:%M:%S %Z\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27bd9750",
   "metadata": {},
   "source": [
    "## 3. Plotting the geomap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "da7520bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_zoom = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "e71cf4af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>iso2</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Tokyo</td>\n",
       "      <td>35.6897</td>\n",
       "      <td>139.6922</td>\n",
       "      <td>JP</td>\n",
       "      <td>37732000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jakarta</td>\n",
       "      <td>-6.1750</td>\n",
       "      <td>106.8275</td>\n",
       "      <td>ID</td>\n",
       "      <td>33756000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Delhi</td>\n",
       "      <td>28.6100</td>\n",
       "      <td>77.2300</td>\n",
       "      <td>IN</td>\n",
       "      <td>32226000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Guangzhou</td>\n",
       "      <td>23.1300</td>\n",
       "      <td>113.2600</td>\n",
       "      <td>CN</td>\n",
       "      <td>26940000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Mumbai</td>\n",
       "      <td>19.0761</td>\n",
       "      <td>72.8775</td>\n",
       "      <td>IN</td>\n",
       "      <td>24973000.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        city      lat       lng iso2  population\n",
       "0      Tokyo  35.6897  139.6922   JP  37732000.0\n",
       "1    Jakarta  -6.1750  106.8275   ID  33756000.0\n",
       "2      Delhi  28.6100   77.2300   IN  32226000.0\n",
       "3  Guangzhou  23.1300  113.2600   CN  26940000.0\n",
       "4     Mumbai  19.0761   72.8775   IN  24973000.0"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities = pd.read_csv(\"worldcities.csv\")\n",
    "cities_coord = cities[['city', 'lat', 'lng', 'iso2', 'population']].sort_values('population', ascending=False)\n",
    "cities_coord.head()\n",
    "\n",
    "# cities_coord = gpd.GeoDataFrame(\n",
    "#     cities_coord, geometry=gpd.points_from_xy(cities_coord.lng, cities_coord.lat), crs=\"EPSG:4326\"\n",
    "# )\n",
    "# cities_coord.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "d4688e6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "center_dict = {'lat': my_coordinates[0], 'lon': my_coordinates[1]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "bf79d836",
   "metadata": {},
   "outputs": [],
   "source": [
    "back_dir = \"background_png\"\n",
    "\n",
    "# os.mkdir(back_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "6ceab6b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.scatter_mapbox(cities_coord[cities_coord['population'] >= 500000], \n",
    "                        lat=\"lat\", lon=\"lng\",\n",
    "                        color_discrete_sequence=[\"darkblue\"], # \"fuchsia\"\n",
    "                        zoom=my_zoom, height=512, width=512,\n",
    "                        center=center_dict,\n",
    "                        size='population', size_max=20)\n",
    "fig.update_layout(mapbox_style=\"open-street-map\")\n",
    "fig.update_layout(margin={\"r\":0,\"t\":0,\"l\":0,\"b\":0})\n",
    "# fig.show()\n",
    "fig.write_image(back_dir + \"/\" + str.lower(location_name) + \"_zoom_\" + str(my_zoom) + \".png\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c20fb971",
   "metadata": {},
   "source": [
    "## 4. Saving images and creating a gif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "f7ea7feb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function: \n",
    "\n",
    "def download_png_by_url(weather_response, my_coordinates, size, zoom, color, smooth, snow, key, save_flg):\n",
    "    '''\n",
    "    Parameters:\n",
    "        weather_response: response from https://api.rainviewer.com/public/weather-maps.json\n",
    "        my_coordinates: list of 2 float elements (latitude, longitude)\n",
    "        size: 256, 512\n",
    "        zoom: 0, 1, 2, ...\n",
    "        color: meanings see https://www.rainviewer.com/api/color-schemes.html\n",
    "        smooth: 0 (don't blur radar data), 1 (blur radar data)\n",
    "        snow: 0 (don't display snow), 1 (display snow in separate colors on the tiles)\n",
    "        key: 'past', 'nowcast'\n",
    "        save_flg: 0 (don't save the image in the folder), 1 (save)\n",
    "    '''\n",
    "    for dd in weather_response.json()['radar'][key]:\n",
    "        img_url = (weather_response.json()['host'] + dd['path'] \n",
    "                   + '/' + str(size)\n",
    "                   + '/' + str(zoom) \n",
    "                   + '/' + '/'.join(list(map(str, my_coordinates))) \n",
    "                   + '/' + str(color) + \n",
    "                   '/' + str(smooth) + '_' + str(snow) + \n",
    "                   '.png')\n",
    "#         print(img_url)\n",
    "        dttm = datetime.fromtimestamp(dd['time'], tz=tz_value) # pytz.utc\n",
    "#         print(dttm.strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "        img_response = requests.get(img_url)\n",
    "        img = Image.open(BytesIO(img_response.content))\n",
    "        \n",
    "        draw = ImageDraw.Draw(img) \n",
    "        text1 = f\"{dttm:%Y-%m-%d %H:%M:%S %Z}\"\n",
    "#         font1 = ImageFont.truetype('arial.ttf', 280) # 'Cantarell-VF.otf' 'Inconsolata-Light.ttf' 'Sacramento-Regular.ttf'\n",
    "        position = (10, 10)\n",
    "        left, top, right, bottom = draw.textbbox(position, text1) # , font=font1\n",
    "        draw.rectangle((left-5, top-5, right+5, bottom+5), fill=\"lightgrey\")\n",
    "        draw.text(position, text=text1, fill=\"black\") # , font=font1\n",
    "#         img.show() # instead of display(img)\n",
    "#         display(img) # doesn't work in GitHub Actions\n",
    "\n",
    "        if save_flg == 1:\n",
    "            if key == 'past':\n",
    "                dir_name = png_past_dir\n",
    "            elif key == 'nowcast':\n",
    "                dir_name = png_nowcast_dir\n",
    "            else:\n",
    "                break\n",
    "            img = img.save(dir_name + \"/\" + str.lower(location_name) + \"_{}.png\".format(dd['time']))\n",
    "            \n",
    "#         print(\"OK:\", dttm.strftime(\"%Y-%m-%d %H:%M:%S %Z\"))\n",
    "        print(\"Done:\", text1)\n",
    "    return 1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "14813079",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function: deleting all files in given directory\n",
    "\n",
    "def clear_folder(folder):\n",
    "    files = glob.glob(folder + '/*')\n",
    "    for f in files:\n",
    "        os.remove(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "4ec6efd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filename_key(x):\n",
    "    return int(x.split('_')[-1].split('.')[0])\n",
    "\n",
    "# check if timestamp is not more than 2 days from request time\n",
    "def filter_by_dttm(x):\n",
    "#     datetime.timedelta(days=2, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)\n",
    "    if request_time - datetime.fromtimestamp(filename_key(x), tz=tz_value) <= timedelta(days=2):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "def make_gif(source_folder, target_folder):\n",
    "    frames = [Image.open(image) for image in sorted(glob.glob(f\"{source_folder}/*.png\"), key=lambda x: filename_key(x)) if filter_by_dttm(image) is True]\n",
    "    frame_one = frames[0]\n",
    "    frame_one.save(target_folder + \"/\" + str.lower(location_name) + f\"{request_time: %Y-%m-%d %H:%M:%S %Z}.gif\", format=\"GIF\", append_images=frames,\n",
    "               save_all=True, duration=300, loop=0, transparency=0, disposal=2)\n",
    "\n",
    "# disposal=2 - for replacement instead of overlaying \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "c98fdb0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gif_merge_back(gif_path, back_path, output_folder):\n",
    "    gif_im = Image.open(gif_path)\n",
    "    background = Image.open(back_path)\n",
    "    frames = []\n",
    "    for im_frame in ImageSequence.Iterator(gif_im):\n",
    "        frame = background.copy()\n",
    "        frame.paste(im_frame, mask=im_frame.convert(\"LA\"))\n",
    "        frames.append(frame)\n",
    "    gif_name = gif_path.split('/')[-1].split('.')[0]\n",
    "    frames[0].save(output_folder + \"/\" + gif_name + \"_back.gif\", save_all=True, duration=300, append_images=frames[1:], loop=0)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "b63fb48c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining directories for saving images and gifs\n",
    "\n",
    "png_past_dir = 'past_png'\n",
    "png_nowcast_dir = 'nowcast_png'\n",
    "gif_dir = 'past_gif'\n",
    "\n",
    "# os.mkdir(png_past_dir)\n",
    "# os.mkdir(png_nowcast_dir)\n",
    "# os.mkdir(gif_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "f4891b43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done: 2023-05-21 08:40:00 CEST\n",
      "Done: 2023-05-21 08:50:00 CEST\n",
      "Done: 2023-05-21 09:00:00 CEST\n",
      "Done: 2023-05-21 09:10:00 CEST\n",
      "Done: 2023-05-21 09:20:00 CEST\n",
      "Done: 2023-05-21 09:30:00 CEST\n",
      "Done: 2023-05-21 09:40:00 CEST\n",
      "Done: 2023-05-21 09:50:00 CEST\n",
      "Done: 2023-05-21 10:00:00 CEST\n",
      "Done: 2023-05-21 10:10:00 CEST\n",
      "Done: 2023-05-21 10:20:00 CEST\n",
      "Done: 2023-05-21 10:30:00 CEST\n",
      "Done: 2023-05-21 10:40:00 CEST\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# saving images for past timestamps\n",
    "\n",
    "download_png_by_url(weather_response, my_coordinates, \n",
    "                    size=512, zoom=my_zoom, color=4, smooth=0, snow=0, key='past', save_flg=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "68055217",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done: 2023-05-21 10:50:00 CEST\n",
      "Done: 2023-05-21 11:00:00 CEST\n",
      "Done: 2023-05-21 11:10:00 CEST\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# saving forecast images\n",
    "\n",
    "download_png_by_url(weather_response, my_coordinates, \n",
    "                    size=512, zoom=my_zoom, color=4, smooth=0, snow=0, key='nowcast', save_flg=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "7d580186",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a new gif file instead of a previous gif\n",
    "\n",
    "clear_folder(gif_dir)\n",
    "make_gif(png_past_dir, gif_dir)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "37bddea2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding the map background under the rain mask\n",
    "                    \n",
    "gif_path = [f for f in glob.glob(gif_dir + '/*.gif')][0]\n",
    "back_path = [f for f in glob.glob(back_dir + '/*.png')][0]\n",
    "output_folder = gif_dir\n",
    "\n",
    "gif_merge_back(gif_path, back_path, output_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "370c629a",
   "metadata": {},
   "source": [
    "# ====== NOTES:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8633aa8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Radar Object\n",
    "\n",
    "# KEY\t\t\tDESCRIPTION\t\t\t\t\t\t\t\t\t\t\t\t\tVALUES\n",
    "# past\t\t\tPast weather radar frames. 2 hours, with 10-minute steps.\tArray(Frame Object)\t \n",
    "# nowcast\t\tFuture weather radar frames. 30 minutes.\t\t\t\t\tArray(Frame Object)\t \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ad1f9fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Frame Object\n",
    "\n",
    "# KEY\tDESCRIPTION\tVALUES\tEXAMPLE\n",
    "# time\tMap frame generation data in UNIX timestamp format (UTC). The map frame typically contains the images (radar, satellite) from different times, so this is not the time of the data rather than frame generation time.\tInt(8)\t1609401600\n",
    "# path\tBase path for the images of that frame. For information on its usage, refer to the next How to use host and path information section of this page\tString(255)\t/v2/satellite/0680143a9470\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4113de2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# {path}/{size}/{z}/{x}/{y}/{color}/{options}.png\n",
    "# Radar data: displays one tile with the composite radar reflectivity data, with specified size, color scheme, and additional options.\n",
    "\n",
    "# {path}/{size}/{z}/{lat}/{lon}/{color}/{options}.png\n",
    "# Radar data: same as the link above, but with the center at specified coordinates (EPSG:4326) with desired zoom size. Great for widgets\n",
    "\n",
    "# {path}/{big_size}/{color}/{options}.png\n",
    "# Composite image with radar reflectivity for the entire world. Generates slowly, up to 10 seconds per image loads. Cannot be smoothed. IMPORTANT: color scheme and the snow mask for satellite data should always be “0”.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79603394",
   "metadata": {},
   "outputs": [],
   "source": [
    "# {ts} – one of the available Unix timestamps from the API.\n",
    "# {x}, {y}, {z} – x, y, and zoom level of the tile that you want to download. Read more about tiles\n",
    "# {latitude}, {longitude} - latitude and longitude of specific coordinates accordingly. \n",
    "#     Decimal format. Must contain a dot in the number. Example: -32.7892, 108.67821.\n",
    "# {size} – image size, can be 256 or 512.\n",
    "# {big_size} – can be 2000, 4000, 8000, 16000, or 24000 (24000x12000 px or ~2km per pixel). \n",
    "#     For square images use 4096, 8196, and 16384 accordingly.\n",
    "# {color} - the number of the color scheme from the provided list.\n",
    "# {options} – list of options separated by the _ symbol. For example: \n",
    "#     ‘1_0’ means smoothed (1) image without snow color scheme (0). Now two options are available: {smooth}_{snow}\n",
    "#     {smooth} - blur (1) or not (0) radar data. Large composite images are always not smoothed due to performance issues.\n",
    "#     {snow} - display (1) or not (0) snow in separate colors on the tiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d33a8f07",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Radar data: \n",
    "    \n",
    "#     displays one tile with the composite radar reflectivity data, \n",
    "#     with specified size, color scheme, and additional options.\n",
    "#     with the center at specified coordinates (EPSG:4326) with desired zoom size.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}