{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "25c8380d",
   "metadata": {},
   "source": [
    "# FFA Seasonality Charts\n",
    "\n",
    "This script allows you to plot seasonality charts for a specific contract month from our Spark30FFA and Spark25FFA 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": 40,
   "id": "fcb94776",
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing packages for calling the API\n",
    "import json\n",
    "import os\n",
    "import sys\n",
    "from base64 import b64encode\n",
    "from pprint import pprint\n",
    "from urllib.parse import urljoin\n",
    "from datetime import datetime\n",
    "import pandas as pd\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",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "9a0e42dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining functions for API request\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",
    "        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",
    "    \"\"\"\n",
    "    OAuth2 authentication requires a POST request with client credentials before accessing the API. \n",
    "    This POST request will return an Access Token which will be used for the API GET request.\n",
    "    \"\"\"\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",
    "    \"\"\"\n",
    "    After receiving an Access Token, we can request information from the API.\n",
    "    \"\"\"\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:lng-freight-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\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "691c889f",
   "metadata": {},
   "source": [
    "### Defining Fetch Request\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "7d5fad75",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining function for collecting the list of contracts\n",
    "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",
    "    for contract in content[\"data\"]:\n",
    "        print(contract[\"fullName\"])\n",
    "        tickers.append(contract[\"id\"])\n",
    "\n",
    "    return tickers"
   ]
  },
  {
   "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. Instructions for downloading your credentials can be found here:\n",
    "\n",
    "https://api.sparkcommodities.com/redoc#section/Authentication/Create-an-Oauth2-Client\n",
    "\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": "602d2492",
   "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.eyJ0eXBlIjoiYWNjZXNzVG9rZW4iLCJzdWIiOiIwMWMyMzU5MC1lZjZjLTRhMzYtODIzNy1jODljM2YxYTNiMmEiLCJzdWJUeXBlIjoib2F1dGgtY2xpZW50IiwiZXhwIjoxNzUzMTg2NjQ5LCJoYXNoZWRTZWNyZXQiOiJwYmtkZjJfc2hhMjU2JDYwMDAwMCRoTXRMNDlrMUZUaVVzTE42Njlqc2pPJHVCSXNxcml5b1NHVzJTS1AvaHVLNHh3eTZ4d3VDN001aUdGRm43N2l4S1U9Iiwib3JnVXVpZCI6IjQ5MzhiMGJiLTVmMjctNDE2NC04OTM4LTUyNTdmYmQzNTNmZiIsInNjb3BlcyI6WyJyZWFkOnByaWNlcyIsInJlYWQ6cm91dGVzIl0sImNsaWVudFR5cGUiOiJvYXV0aC1jbGllbnQifQ.RpCcMnBsKm-gCSHfYO3NUgTqlNIr2Bs5VpjtRU6c93k\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 = list_contracts(access_token)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0e0e030",
   "metadata": {},
   "source": [
    "# Data Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3302a85f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_historical_price_releases(access_token, ticker, limit, offset=None):\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",
    "    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": [
    "### Function to call data and store as a DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32d6eb83",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the function\n",
    "def fetch_ffa_prices(my_tick, my_lim):\n",
    "    print(my_tick)\n",
    "\n",
    "    my_dict_hist = fetch_historical_price_releases(access_token, my_tick, limit=my_lim)\n",
    "\n",
    "    release_dates = []\n",
    "\n",
    "    period_start = []\n",
    "    period_end = []\n",
    "    period_name = []\n",
    "    cal_month = []\n",
    "    ticker = []\n",
    "    usd_day = []\n",
    "    day_min = []\n",
    "    day_max = []\n",
    "\n",
    "    for release in my_dict_hist:\n",
    "        release_date = release[\"releaseDate\"]\n",
    "        data = release[\"data\"]\n",
    "\n",
    "        for d in data:\n",
    "            data_points = d[\"dataPoints\"]\n",
    "            for data_point in data_points:\n",
    "                period_start_at = data_point[\"deliveryPeriod\"][\"startAt\"]\n",
    "                period_start.append(period_start_at)\n",
    "                period_end_at = data_point[\"deliveryPeriod\"][\"endAt\"]\n",
    "                period_end.append(period_end_at)\n",
    "                period_name.append(data_point[\"deliveryPeriod\"][\"name\"])\n",
    "\n",
    "                release_dates.append(release_date)               \n",
    "                ticker.append(release[\"contractId\"])\n",
    "                cal_month.append(\n",
    "                    datetime.strptime(period_start_at, \"%Y-%m-%d\").strftime(\"%b-%Y\")\n",
    "                )\n",
    "\n",
    "                usd_day.append(int(data_point[\"derivedPrices\"][\"usdPerDay\"][\"spark\"]))\n",
    "                day_min.append(\n",
    "                    int(data_point[\"derivedPrices\"][\"usdPerDay\"][\"sparkMin\"])\n",
    "                )\n",
    "                day_max.append(\n",
    "                    int(data_point[\"derivedPrices\"][\"usdPerDay\"][\"sparkMax\"])\n",
    "                )\n",
    "                \n",
    "\n",
    "\n",
    "    historical_df = pd.DataFrame(\n",
    "        {\n",
    "            \"Release Date\": release_dates,\n",
    "            \"ticker\": ticker,\n",
    "            \"Period Name\": period_name,\n",
    "            \"Period Start\": period_start,\n",
    "            \"Period End\": period_end,\n",
    "            \"Calendar Month\": cal_month,\n",
    "            \"Spark\": usd_day,\n",
    "            \"SparkMin\": day_min,\n",
    "            \"SparkMax\": day_max,\n",
    "        }\n",
    "    )\n",
    "\n",
    "    historical_df['Release Date'] = pd.to_datetime(historical_df['Release Date'],format='%Y-%m-%d')\n",
    "    \n",
    "    historical_df['Period Start'] = pd.to_datetime(historical_df['Period Start'])\n",
    "    historical_df['Period End'] = pd.to_datetime(historical_df['Period End'])\n",
    "    historical_df['Time Diff'] = (historical_df['Release Date'] - historical_df['Period Start']).dt.days\n",
    "\n",
    "    return historical_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7135318a",
   "metadata": {},
   "source": [
    "### Call those functions for Spark30FFA and Spark25FFA\n",
    "\n",
    "We call the function defined above and create two dataframes:\n",
    "\n",
    "- spark25ffa - storing all historical Spark25FFA data\n",
    "- spark30ffa - storing all historical Spark30FFA data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "b367acfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spark25ffa-monthly\n",
      ">>>> Get price releases for spark25ffa-monthly\n",
      "spark30ffa-monthly\n",
      ">>>> Get price releases for spark30ffa-monthly\n"
     ]
    }
   ],
   "source": [
    "spark25ffa = fetch_ffa_prices(tickers[4], 900)\n",
    "\n",
    "spark30ffa = fetch_ffa_prices(tickers[8], 900)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9126aa2b",
   "metadata": {},
   "source": [
    "# FFA Contract Evolution + Seasonality\n",
    "\n",
    "Compare Spark30FFA December contracts from the past 3 years, and track how these contracts have priced in the year leading up to contract settlement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3676a9e1",
   "metadata": {},
   "source": [
    "## Sorting Data\n",
    "\n",
    "We then create new columns to categorise the data we have. By creating the 'Day of Year' column, we can plot the yearly data on the same x-axis range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e698cbfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_years(df):\n",
    "    \n",
    "    reldates = df['Release Date'].to_list()\n",
    "    startdates = df['Period Start'].to_list()\n",
    "    calmonths = df['Calendar Month'].to_list()\n",
    "\n",
    "    dayofyear = []\n",
    "    \n",
    "    for r in reldates:\n",
    "        ir = reldates.index(r)\n",
    "        if r.year - startdates[ir].year == -1:\n",
    "            dayofyear.append(r.timetuple().tm_yday - 365)\n",
    "        elif r.year - startdates[ir].year == -2:\n",
    "            dayofyear.append(r.timetuple().tm_yday - 730)\n",
    "        else:\n",
    "            dayofyear.append(r.timetuple().tm_yday)\n",
    "            \n",
    "    df['Day of Year'] = dayofyear\n",
    "\n",
    "    return df\n",
    "\n",
    "spark30ffa = sort_years(spark30ffa)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbd5a39b",
   "metadata": {},
   "source": [
    "## Group Dataframe by CalMonth and choose contracts to compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73853999",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grouping the Dataframe by Contract\n",
    "groups = spark30ffa.groupby('Calendar Month')\n",
    "years = list(spark30ffa['Release Date'].dt.year.unique())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97eaa066",
   "metadata": {},
   "source": [
    "### Input which month you'd like to compare contracts for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "9e84e0cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "month = 'Dec'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c354e2df",
   "metadata": {},
   "source": [
    "# Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "713215a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1b986ce0e90>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Plotting\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import yarl\n",
    "\n",
    "sns.set_style()\n",
    "sns.set_theme(style=\"whitegrid\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(14, 7))\n",
    "\n",
    "max_dates = []\n",
    "\n",
    "# iterating through years and plotting the data\n",
    "for y in years:\n",
    "    ydf = groups.get_group(month + '-' + str(y))\n",
    "    ydf = sort_years(ydf)\n",
    "    ax.plot(ydf[\"Day of Year\"], ydf[\"Spark\"], label=month + str(y))\n",
    "    max_dates.append(ydf[\"Day of Year\"].max())\n",
    "\n",
    "plt.xlabel(\"Release Date\")\n",
    "plt.ylabel(\"Cost in USD/day\")\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 = ['Y-1', 'March', 'May', 'July', 'September', 'November', 'Y+0', '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 = [0,32,60,91,121,152,182,213,244,274,305,335, 365]\n",
    "xpos = [-365,-305,-244,-183,-121,-60,0,60,121,182,244,305,365]\n",
    "\n",
    "current_values = plt.gca().get_yticks()\n",
    "plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n",
    "\n",
    "plt.xticks(xpos, xlabels)\n",
    "\n",
    "plt.xlim(-365,max(max_dates))\n",
    "\n",
    "# Setting the graph legend\n",
    "plt.legend()\n"
   ]
  }
 ],
 "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
}