{ "cells": [ { "cell_type": "markdown", "id": "25c8380d", "metadata": {}, "source": [ "# Seasonality Charts\n", "\n", "This script allows you to plot seasonality charts for Spark30S and Spark25S freight rates.\n", "\n", "This script uses elements from our API code samples. If you'd like a more basic and informative example of how to pull data via the Spark API, please visit our Github or API website:\n", "\n", "- Github: https://github.com/spark-commodities/api-code-samples/blob/master/jupyter_notebooks/\n", "- API Website: https://www.sparkcommodities.com/api/code-examples/jupyter.html\n", "\n", "\n", "### Have any questions?\n", "\n", "If you have any questions regarding our API, or need help accessing specific datasets, please contact us at:\n", "\n", "__data@sparkcommodities.com__\n", "\n", "or refer to our API website for more information about this endpoint:\n", "https://www.sparkcommodities.com/api/request/contracts.html" ] }, { "cell_type": "markdown", "id": "c5716130", "metadata": {}, "source": [ "## 1. Importing Data\n", "\n", "Here we define the functions that allow us to retrieve the valid credentials to access the Spark API.\n", "\n", "__This section can remain unchanged for most Spark API users.__" ] }, { "cell_type": "code", "execution_count": 19, "id": "33fb0640", "metadata": {}, "outputs": [], "source": [ "import json\n", "import os\n", "import sys\n", "import pandas as pd\n", "import numpy as np\n", "from base64 import b64encode\n", "from pprint import pprint\n", "from urllib.parse import urljoin\n", "from datetime import datetime\n", "\n", "\n", "try:\n", " from urllib import request, parse\n", " from urllib.error import HTTPError\n", "except ImportError:\n", " raise RuntimeError(\"Python 3 required\")\n", "\n", "\n", "API_BASE_URL = \"https://api.sparkcommodities.com\"\n", "\n", "\n", "def retrieve_credentials(file_path=None):\n", " \"\"\"\n", " Find credentials either by reading the client_credentials file or reading\n", " environment variables\n", " \"\"\"\n", " if file_path is None:\n", "\n", " client_id = os.getenv(\"SPARK_CLIENT_ID\")\n", " client_secret = os.getenv(\"SPARK_CLIENT_SECRET\")\n", " if not client_id or not client_secret:\n", " raise RuntimeError(\n", " \"SPARK_CLIENT_ID and SPARK_CLIENT_SECRET environment vars required\"\n", " )\n", " else:\n", " # Parse the file\n", " if not os.path.isfile(file_path):\n", " raise RuntimeError(\"The file {} doesn't exist\".format(file_path))\n", "\n", " with open(file_path) as fp:\n", " lines = [l.replace(\"\\n\", \"\") for l in fp.readlines()]\n", "\n", " if lines[0] in (\"clientId,clientSecret\", \"client_id,client_secret\"):\n", " client_id, client_secret = lines[1].split(\",\")\n", " else:\n", " print(\"First line read: '{}'\".format(lines[0]))\n", " raise RuntimeError(\n", " \"The specified file {} doesn't look like to be a Spark API client \"\n", " \"credentials file\".format(file_path)\n", " )\n", "\n", " print(\">>>> Found credentials!\")\n", " print(\n", " \">>>> Client_id={}, client_secret={}****\".format(client_id, client_secret[:5])\n", " )\n", "\n", " return client_id, client_secret\n", "\n", "\n", "def do_api_post_query(uri, body, headers):\n", " url = urljoin(API_BASE_URL, uri)\n", "\n", " data = json.dumps(body).encode(\"utf-8\")\n", "\n", " # HTTP POST request\n", " req = request.Request(url, data=data, headers=headers)\n", " try:\n", " response = request.urlopen(req)\n", " except HTTPError as e:\n", " print(\"HTTP Error: \", e.code)\n", " print(e.read())\n", " sys.exit(1)\n", "\n", " resp_content = response.read()\n", "\n", " # The server must return HTTP 201. Raise an error if this is not the case\n", " assert response.status == 201, resp_content\n", "\n", " # The server returned a JSON response\n", " content = json.loads(resp_content)\n", "\n", " return content\n", "\n", "\n", "def do_api_get_query(uri, access_token):\n", " url = urljoin(API_BASE_URL, uri)\n", "\n", " headers = {\n", " \"Authorization\": \"Bearer {}\".format(access_token),\n", " \"Accept\": \"application/json\",\n", " }\n", "\n", " # HTTP POST request\n", " req = request.Request(url, headers=headers)\n", " try:\n", " response = request.urlopen(req)\n", " except HTTPError as e:\n", " print(\"HTTP Error: \", e.code)\n", " print(e.read())\n", " sys.exit(1)\n", "\n", " resp_content = response.read()\n", "\n", " # The server must return HTTP 201. Raise an error if this is not the case\n", " assert response.status == 200, resp_content\n", "\n", " # The server returned a JSON response\n", " content = json.loads(resp_content)\n", "\n", " return content\n", "\n", "\n", "def get_access_token(client_id, client_secret):\n", " \"\"\"\n", " Get a new access_token. Access tokens are the thing that applications use to make\n", " API requests. Access tokens must be kept confidential in storage.\n", "\n", " # Procedure:\n", "\n", " Do a POST query with `grantType` and `scopes` in the body. A basic authorization\n", " HTTP header is required. The \"Basic\" HTTP authentication scheme is defined in\n", " RFC 7617, which transmits credentials as `clientId:clientSecret` pairs, encoded\n", " using base64.\n", " \"\"\"\n", "\n", " # Note: for the sake of this example, we choose to use the Python urllib from the\n", " # standard lib. One should consider using https://requests.readthedocs.io/\n", "\n", " payload = \"{}:{}\".format(client_id, client_secret).encode()\n", " headers = {\n", " \"Authorization\": b64encode(payload).decode(),\n", " \"Accept\": \"application/json\",\n", " \"Content-Type\": \"application/json\",\n", " }\n", " body = {\n", " \"grantType\": \"clientCredentials\",\n", " \"scopes\": \"read:prices,read:routes\",\n", " }\n", "\n", " content = do_api_post_query(uri=\"/oauth/token/\", body=body, headers=headers)\n", "\n", " print(\n", " \">>>> Successfully fetched an access token {}****, valid {} seconds.\".format(\n", " content[\"accessToken\"][:5], content[\"expiresIn\"]\n", " )\n", " )\n", "\n", " return content[\"accessToken\"]\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "691c889f", "metadata": {}, "source": [ "## Defining Fetch Request for Available Contracts\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "5e341bdf", "metadata": {}, "outputs": [], "source": [ "def list_contracts(access_token):\n", " \"\"\"\n", " Fetch available contracts. Return contract ticker symbols\n", "\n", " # Procedure:\n", "\n", " Do a GET query to /v1.0/contracts/ with a Bearer token authorization HTTP header.\n", " \"\"\"\n", " content = do_api_get_query(uri=\"/v1.0/contracts/\", access_token=access_token)\n", "\n", " print(\">>>> All the contracts you can fetch\")\n", " tickers = []\n", " tick_names = []\n", " for contract in content[\"data\"]:\n", " print(contract[\"fullName\"])\n", " tickers.append(contract[\"id\"])\n", " tick_names.append(contract[\"fullName\"])\n", "\n", " return tickers,tick_names" ] }, { "cell_type": "markdown", "id": "fd3171a8", "metadata": {}, "source": [ "## N.B. Credentials\n", "\n", "Here we call the above functions, and input the file path to our credentials.\n", "\n", "N.B. You must have downloaded your client credentials CSV file before proceeding. Please refer to the API documentation if you have not dowloaded them already.\n", "\n", "The code then prints the available prices that are callable from the API, and their corresponding Python ticker names are displayed as a list at the bottom of the Output." ] }, { "cell_type": "code", "execution_count": null, "id": "fd7e89bf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>>> Found credentials!\n", ">>>> Client_id=01c23590-ef6c-4a36-8237-c89c3f1a3b2a, client_secret=80763****\n", ">>>> Successfully fetched an access token eyJhb****, valid 604799 seconds.\n", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0eXBlIjoiYWNjZXNzVG9rZW4iLCJzdWIiOiIwMWMyMzU5MC1lZjZjLTRhMzYtODIzNy1jODljM2YxYTNiMmEiLCJzdWJUeXBlIjoib2F1dGgtY2xpZW50IiwiZXhwIjoxNzUzMTg3MDkxLCJoYXNoZWRTZWNyZXQiOiJwYmtkZjJfc2hhMjU2JDYwMDAwMCRoTXRMNDlrMUZUaVVzTE42Njlqc2pPJHVCSXNxcml5b1NHVzJTS1AvaHVLNHh3eTZ4d3VDN001aUdGRm43N2l4S1U9Iiwib3JnVXVpZCI6IjQ5MzhiMGJiLTVmMjctNDE2NC04OTM4LTUyNTdmYmQzNTNmZiIsInNjb3BlcyI6WyJyZWFkOnByaWNlcyIsInJlYWQ6cm91dGVzIl0sImNsaWVudFR5cGUiOiJvYXV0aC1jbGllbnQifQ.y-c8HktUx0pkzPKARoOryXOg_JGHkzAMxA8BCDJLrjk\n", ">>>> All the contracts you can fetch\n", "Spark25F Pacific 160 TFDE\n", "Spark30F Atlantic 160 TFDE\n", "Spark25S Pacific\n", "Spark25Fo Pacific\n", "Spark25FFA Pacific\n", "Spark25FFAYearly Pacific\n", "Spark30S Atlantic\n", "Spark30Fo Atlantic\n", "Spark30FFA Atlantic\n", "Spark30FFAYearly Atlantic\n", "SparkNWE DES 1H\n", "SparkNWE-B 1H\n", "SparkNWE DES 2H\n", "SparkNWE-B 2H\n", "SparkNWE-B F\n", "SparkNWE DES F\n", "SparkNWE-B Fo\n", "SparkNWE DES Fo\n", "SparkNWE-DES-Fin Monthly\n", "SparkNWE-Fin Monthly\n", "SparkSWE-B F\n", "SparkSWE DES F\n", "SparkSWE-B Fo\n", "SparkSWE DES Fo\n", "SparkSWE-DES-Fin Monthly\n", "SparkSWE-Fin Monthly\n" ] } ], "source": [ "#Insert file path to your client credentials here\n", "client_id, client_secret = retrieve_credentials(file_path=\"/tmp/client_credentials.csv\")\n", "\n", "# Authenticate:\n", "access_token = get_access_token(client_id, client_secret)\n", "print(access_token)\n", "\n", "# Fetch all contracts:\n", "tickers, tick_names = list_contracts(access_token)\n" ] }, { "cell_type": "markdown", "id": "a0e0e030", "metadata": {}, "source": [ "# Importing Data\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "ff4d0dcc", "metadata": {}, "outputs": [], "source": [ "def fetch_historical_price_releases(access_token, ticker, limit=4, offset=None, vessel=None):\n", " \"\"\"\n", " For a selected contract, this endpoint returns all the Price Releases you can\n", " access according to your current subscription, ordered by release date descending.\n", "\n", " **Note**: Unlimited access to historical data and full forward curves is only\n", " available to those with Premium access. Get in touch to find out more.\n", "\n", " **Params**\n", "\n", " limit: optional integer value to set an upper limit on the number of price\n", " releases returned by the endpoint. Default here is 4.\n", "\n", " offset: optional integer value to set from where to start returning data.\n", " Default is 0.\n", "\n", " # Procedure:\n", "\n", " Do GET queries to /v1.0/contracts/{contract_ticker_symbol}/price-releases/\n", " with a Bearer token authorization HTTP header.\n", " \"\"\"\n", " print(\">>>> Get price releases for {}\".format(ticker))\n", "\n", " query_params = \"?limit={}\".format(limit)\n", " if offset is not None:\n", " query_params += \"&offset={}\".format(offset)\n", " \n", " # '174-2stroke' or '160-tfde'\n", " if vessel is not None:\n", " query_params += \"&vessel-type={}\".format(vessel)\n", " \n", " \n", " content = do_api_get_query(\n", " uri=\"/v1.0/contracts/{}/price-releases/{}\".format(ticker, query_params),\n", " access_token=access_token,\n", " )\n", "\n", " my_dict = content['data']\n", " \n", " return my_dict\n" ] }, { "cell_type": "markdown", "id": "99be9416", "metadata": {}, "source": [ "### Formatting into a Pandas DataFrame\n", "\n", "Here we define a function that calls the data and formats it into a Pandas Dataframe." ] }, { "cell_type": "code", "execution_count": 23, "id": "399cc46f", "metadata": {}, "outputs": [], "source": [ "def fetch_prices(ticker, my_lim, my_vessel=None):\n", " my_dict_hist = fetch_historical_price_releases(access_token, ticker, limit=my_lim, vessel=my_vessel)\n", " \n", " release_dates = []\n", " period_start = []\n", " ticker = []\n", " usd_day = []\n", " usd_mmbtu = []\n", "\n", " day_min = []\n", " day_max = []\n", " cal_month = []\n", "\n", " for release in my_dict_hist:\n", " release_date = release[\"releaseDate\"]\n", " ticker.append(release['contractId'])\n", "\n", " release_dates.append(release_date)\n", "\n", " data_points = release[\"data\"][0][\"dataPoints\"]\n", "\n", " for data_point in data_points:\n", " period_start_at = data_point[\"deliveryPeriod\"][\"startAt\"]\n", " period_start.append(period_start_at)\n", "\n", " usd_day.append(data_point['derivedPrices']['usdPerDay']['spark'])\n", " day_min.append(data_point['derivedPrices']['usdPerDay']['sparkMin'])\n", " day_max.append(data_point['derivedPrices']['usdPerDay']['sparkMax'])\n", "\n", " usd_mmbtu.append(data_point['derivedPrices']['usdPerMMBtu']['spark'])\n", " cal_month.append(datetime.strptime(period_start_at, '%Y-%m-%d').strftime('%b-%Y'))\n", "\n", "\n", "\n", " ## Storing values in a Pandas DataFrame\n", "\n", " historical_df = pd.DataFrame({\n", " 'ticker': ticker,\n", " 'Period Start': period_start,\n", " 'USDperday': usd_day,\n", " 'USDperdayMax': day_max,\n", " 'USDperdayMin': day_min,\n", " 'USDperMMBtu': usd_mmbtu,\n", " 'Release Date': release_dates})\n", "\n", " historical_df['USDperday'] = pd.to_numeric(historical_df['USDperday'])\n", " historical_df['USDperdayMax'] = pd.to_numeric(historical_df['USDperdayMax'])\n", " historical_df['USDperdayMin'] = pd.to_numeric(historical_df['USDperdayMin'])\n", " historical_df['USDperMMBtu'] = pd.to_numeric(historical_df['USDperMMBtu'])\n", "\n", " historical_df['Release Datetime'] = pd.to_datetime(historical_df['Release Date'])\n", " \n", " return historical_df" ] }, { "cell_type": "markdown", "id": "9dbbdc7f", "metadata": {}, "source": [ "# Yearly Comparisons\n", "Pulling Spark30s and Spark25s historical data using the import function defined above" ] }, { "cell_type": "code", "execution_count": 24, "id": "b425755f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>>> Get price releases for spark30s\n", ">>>> Get price releases for spark30s\n", ">>>> Get price releases for spark25s\n", ">>>> Get price releases for spark25s\n" ] } ], "source": [ "spark30_174 = fetch_prices('spark30s', 1000, my_vessel='174-2stroke')\n", "spark30_160 = fetch_prices('spark30s', 1000, my_vessel='160-tfde')\n", "\n", "spark25_174 = fetch_prices('spark25s', 1000, my_vessel='174-2stroke')\n", "spark25_160 = fetch_prices('spark25s', 1000, my_vessel='160-tfde')" ] }, { "cell_type": "markdown", "id": "59589a6d", "metadata": {}, "source": [ "## Sorting Data\n", "\n", "We then create new columns to categorise the data we have. \n", "- By creating the 'Years' column, we can filter the data by year.\n", "- By creating the 'Day of Year' column, we can plot the yearly data on the same x-axis range.\n", "- Similarly, creating the 'Quarters' and 'Seasons' columns" ] }, { "cell_type": "code", "execution_count": 25, "id": "a93ecb24", "metadata": {}, "outputs": [], "source": [ "from datetime import datetime\n", "\n", "def sort_years(df):\n", " \n", " reldates = df['Release Date'].to_list()\n", "\n", " years = []\n", " months = []\n", " days = []\n", " monthday = []\n", " dayofyear = []\n", " for r in reldates:\n", " rsplit = r.split('-')\n", " years.append(rsplit[0])\n", " months.append(rsplit[1])\n", " days.append(rsplit[2])\n", "\n", " dayofyear.append(datetime.strptime(r, '%Y-%m-%d').timetuple().tm_yday)\n", "\n", " df['Year'] = years\n", " df['Month'] = months\n", " df['Day'] = days\n", " df['Day of Year'] = dayofyear\n", " \n", " seas_check = [['04','05','06','07','08','09'], ['10','11','12','01','02','03']]\n", " quart_check = [['01','02','03'],['04','05','06'],['07','08','09'],['10','11','12']]\n", "\n", " seasons = []\n", " quarters = []\n", "\n", " for i in df['Month'].to_list():\n", " if i in quart_check[0]:\n", " quarters.append('Q1')\n", " if i in quart_check[1]:\n", " quarters.append('Q2')\n", " if i in quart_check[2]:\n", " quarters.append('Q3')\n", " if i in quart_check[3]:\n", " quarters.append('Q4')\n", "\n", " if i in seas_check[0]:\n", " seasons.append('Summer')\n", " if i in seas_check[1]:\n", " seasons.append('Winter')\n", "\n", " df['Quarters'] = quarters\n", " df['Seasons'] = seasons\n", "\n", " return df" ] }, { "cell_type": "code", "execution_count": 26, "id": "af3c1d24", "metadata": {}, "outputs": [], "source": [ "spark30_174 = sort_years(spark30_174)\n", "spark30_160 = sort_years(spark30_160)\n", "\n", "spark25_174 = sort_years(spark25_174)\n", "spark25_160 = sort_years(spark25_160)" ] }, { "cell_type": "markdown", "id": "d6209b17", "metadata": {}, "source": [ "# Plotting" ] }, { "cell_type": "code", "execution_count": 27, "id": "647e2de6", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "sns.set_style()" ] }, { "cell_type": "code", "execution_count": 28, "id": "c1b54663", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['2025', '2024', '2023', '2022', '2021', '2020', '2019']" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(spark30_174['Year'].unique())" ] }, { "cell_type": "markdown", "id": "6f410c0d", "metadata": {}, "source": [ "## Spark30S" ] }, { "cell_type": "code", "execution_count": 29, "id": "e8e314cb", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\Qasim\\AppData\\Local\\Temp\\ipykernel_13452\\1787126235.py:35: UserWarning: FixedFormatter should only be used together with FixedLocator\n", " plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# setting up figure\n", "fig, ax = plt.subplots(figsize=(15,9))\n", "year_list = list(spark30_174['Year'].unique())\n", "\n", "# Iterating through years and plotting data\n", "for y in range(len(year_list)):\n", " hdf = spark30_174[spark30_174['Year']==year_list[y]]\n", " if y != 0: \n", " ax.plot(hdf['Day of Year'], hdf['USDperday'], alpha=0.4, label=year_list[y])\n", " else:\n", " ax.plot(hdf['Day of Year'], hdf['USDperday'], color = '#48C38D', linewidth=3.0, label=year_list[y])\n", "\n", " ax.plot(hdf['Day of Year'], hdf['USDperdayMin'], color = '#48C38D', alpha=0.1)\n", " ax.plot(hdf['Day of Year'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.1)\n", " ax.fill_between(hdf['Day of Year'], hdf['USDperdayMin'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.2)\n", "\n", "\n", "ax.set_title('Yearly Comparison of Spark30S')\n", "plt.xlabel('Price Release Date')\n", "plt.ylabel('USD per day')\n", "plt.legend()\n", "\n", "# Setting custom x-axis ticks location and labels.\n", "xlabels = ['January', 'March', 'May', 'July', 'September', 'November', 'Year End']\n", "\n", "# xpos gives the first day of every other month in terms of 'day of year'\n", "#xpos_allmonths = [1,32,60,91,121,152,182,213,244,274,305,335]\n", "xpos = [1,60,121,182,244,305,365]\n", "\n", "#plt.ylim(0, 100000)\n", "\n", "plt.xticks(xpos, xlabels)\n", "\n", "current_values = plt.gca().get_yticks()\n", "plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n", "\n", "\n", "sns.despine(left=True, bottom=True)\n", "\n", "plt.grid(True)" ] }, { "cell_type": "markdown", "id": "7e8bc38f", "metadata": {}, "source": [ "## Spark25S" ] }, { "cell_type": "code", "execution_count": 30, "id": "95569391", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\Qasim\\AppData\\Local\\Temp\\ipykernel_13452\\2962325131.py:34: UserWarning: FixedFormatter should only be used together with FixedLocator\n", " plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#setting up figure\n", "fig2, ax2 = plt.subplots(figsize=(15,9))\n", "year_list = list(spark25_174['Year'].unique())\n", "\n", "# iterating through years and plotting data\n", "for y in range(len(year_list)):\n", " hdf = spark25_174[spark25_174['Year']==year_list[y]]\n", " if y != 0: \n", " ax2.plot(hdf['Day of Year'], hdf['USDperday'], alpha=0.4, label=year_list[y])\n", " else:\n", " ax2.plot(hdf['Day of Year'], hdf['USDperday'], color = '#48C38D', linewidth=3.0, label=year_list[y])\n", "\n", " ax2.plot(hdf['Day of Year'], hdf['USDperdayMin'], color = '#48C38D', alpha=0.1)\n", " ax2.plot(hdf['Day of Year'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.1)\n", " ax2.fill_between(hdf['Day of Year'], hdf['USDperdayMin'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.2)\n", "\n", "\n", "ax2.set_title('Yearly Comparison of Spark25S')\n", "plt.xlabel('Price Release Date')\n", "plt.ylabel('USD per day')\n", "plt.legend()\n", "\n", "# Setting custom x-axis ticks location and labels.\n", "xlabels = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Year End']\n", "#xlabels = ['January', 'March', 'May', 'July', 'September', 'November', 'Year End']\n", "\n", "# xpos gives the first day of every other month in terms of 'day of year'\n", "xpos = [1,32,60,91,121,152,182,213,244,274,305,335, 365]\n", "#xpos = [1,60,121,182,244,305,365]\n", "\n", "plt.xticks(xpos, xlabels)\n", "\n", "current_values = plt.gca().get_yticks()\n", "plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n", "\n", "\n", "sns.despine(left=True, bottom=True)\n", "plt.grid(True)" ] } ], "metadata": { "kernelspec": { "display_name": "base", "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.5" } }, "nbformat": 4, "nbformat_minor": 5 }