V1/features/instruments/Equity Options - Pricing and risk using Black-Scholes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Toggle Docstring\"></form>\n",
       "    \n",
       "         <script>\n",
       "         function code_toggle() {\n",
       "             if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){\n",
       "                 $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "             } else {\n",
       "                 $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "             }\n",
       "         }\n",
       "         </script>\n",
       "\n",
       "     "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from lusidtools.jupyter_tools import toggle_code\n",
    "\n",
    "\"\"\"Equity Option - Pricing and risk\n",
    "\n",
    "Attributes\n",
    "----------\n",
    "equity option\n",
    "inline valuations\n",
    "market value\n",
    "exposure\n",
    "option delta\n",
    "black scholes\n",
    "\"\"\"\n",
    "\n",
    "toggle_code(\"Toggle Docstring\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load_ext lab_black\n",
    "# %load_ext nb_black"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Equity Options - Pricing and risk using LUSID's native valuation engine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we  demonstrate how you can generate a price and risk for equity options using LUSID's valuation engine. We use the Black-Scholes model to produce a price. We also caclulate the option delta, where delta is defined as the rate of change of the price of the option versus the price of the underlying equity instrument. \n",
    "\n",
    "For more details on modelling `EquityOptions` and booking associated cash flows, see [Knowlege Base article](https://support.lusid.com/knowledgebase/article/KA-01755/en-us).\n",
    "\n",
    "\n",
    "## Table of Contents:\n",
    "* [1. Create instruments](#1-create-instruments)\n",
    "* [2. Market data](#2-market-data)\n",
    "* [3. Run valuations](#3-run-valuations)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUSID Environment Initialised\n",
      "LUSID API Version : 0.6.11205.0\n"
     ]
    }
   ],
   "source": [
    "# Import generic non-LUSID packages\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "import json\n",
    "import pytz\n",
    "import time\n",
    "from IPython.core.display import HTML\n",
    "\n",
    "# Import key modules from the LUSID package\n",
    "import lusid as lu\n",
    "import lusid.models as lm\n",
    "\n",
    "# Import key functions from Lusid-Python-Tools and other packages\n",
    "from lusidtools.pandas_utils.lusid_pandas import lusid_response_to_data_frame\n",
    "from lusidtools.lpt.lpt import to_date\n",
    "from lusidjam import RefreshingToken\n",
    "from copy import deepcopy\n",
    "\n",
    "\n",
    "# Set DataFrame display formats\n",
    "pd.set_option(\"display.max_columns\", None)\n",
    "pd.set_option(\"display.max_rows\", None)\n",
    "pd.options.display.float_format = \"{:,.4f}\".format\n",
    "\n",
    "# Set the secrets path\n",
    "secrets_path = os.getenv(\"FBN_SECRETS_PATH\")\n",
    "\n",
    "# For running the notebook locally\n",
    "if secrets_path is None:\n",
    "    secrets_path = os.path.join(os.path.dirname(os.getcwd()), \"secrets.json\")\n",
    "\n",
    "# Authenticate our user and create our API client\n",
    "api_factory = lu.utilities.ApiClientFactory(\n",
    "    token=RefreshingToken(), api_secrets_filename=secrets_path\n",
    ")\n",
    "\n",
    "print(\"LUSID Environment Initialised\")\n",
    "print(\n",
    "    \"LUSID API Version :\",\n",
    "    api_factory.build(lu.api.ApplicationMetadataApi).get_lusid_versions().build_version,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LUSID Variable Definitions\n",
    "instruments_api = api_factory.build(lu.api.InstrumentsApi)\n",
    "quotes_api = api_factory.build(lu.api.QuotesApi)\n",
    "configuration_recipe_api = api_factory.build(lu.api.ConfigurationRecipeApi)\n",
    "aggregration_api = api_factory.build(lu.api.AggregationApi)\n",
    "complex_market_data_api = api_factory.build(lu.api.ComplexMarketDataApi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define scopes\n",
    "scope = \"BlackScholesValuations\"\n",
    "quotes_scope = \"BlackScholesValuations\"\n",
    "portfolio_code = \"equityOptionPortfolio\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Create Instruments <a id='1-create-instruments'></a>\n",
    "\n",
    "First we need to create two instruments:\n",
    "\n",
    "1. An Amazon equity, modelled as `Equity` in LUSID.\n",
    "2. An option on this equity, modelled as `EquityOption` in LUSID.\n",
    "\n",
    "### 1.1 Create the underlying instrument\n",
    "\n",
    "In order to create an Option on an `Equity` Instrument, we must first create that underlying `Equity` instrument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUID_0003B3L7\n"
     ]
    }
   ],
   "source": [
    "# upload AMZN equity\n",
    "\n",
    "equity = lm.Equity(dom_ccy=\"USD\", instrument_type=\"Equity\",)\n",
    "\n",
    "equity_definition = lm.InstrumentDefinition(\n",
    "    name=\"Amazon.com\",\n",
    "    identifiers={\n",
    "        \"ClientInternal\": lm.InstrumentIdValue(\"AMZN\"),\n",
    "        \"RIC\": lm.InstrumentIdValue(\"AMZN\"),\n",
    "    },\n",
    "    definition=equity,\n",
    ")\n",
    "\n",
    "# upsert the instrument\n",
    "upsert_request = {\"AMZN\": equity_definition}\n",
    "upsert_response = instruments_api.upsert_instruments(request_body=upsert_request, scope=scope)\n",
    "equity_luid = upsert_response.values[\"AMZN\"].lusid_instrument_id\n",
    "print(equity_luid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Create the Equity Option\n",
    "\n",
    "Now that we have created the underlying `Equity`, we can create an `EquityOption` on that instrument. This option is a \"European\" option meaning that it can only be exercised on the expiry date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def option_instrument_definition(\n",
    "    option_name,\n",
    "    option_identifier,\n",
    "    start_date,\n",
    "    option_maturity_date,\n",
    "    option_settle_date,\n",
    "    delivery_type,\n",
    "    option_type,\n",
    "    strike,\n",
    "    dom_ccy,\n",
    "    underlying_code,\n",
    "    underlying_identifier,\n",
    "):\n",
    "\n",
    "    option = lm.EquityOption(\n",
    "        instrument_type=\"EquityOption\",\n",
    "        start_date=start_date,\n",
    "        option_maturity_date=option_maturity_date,\n",
    "        option_settlement_date=option_settle_date,\n",
    "        delivery_type=delivery_type,\n",
    "        option_type=option_type,\n",
    "        strike=strike,\n",
    "        dom_ccy=dom_ccy,\n",
    "        underlying_identifier=underlying_identifier,\n",
    "        code=underlying_code,\n",
    "    )\n",
    "\n",
    "    return option\n",
    "\n",
    "\n",
    "def create_option_instrument(option):\n",
    "\n",
    "    # define the instrument to be upserted\n",
    "    option_definition = lm.InstrumentDefinition(\n",
    "        name=option_name,\n",
    "        identifiers={\"ClientInternal\": lm.InstrumentIdValue(option_identifier)},\n",
    "        definition=option,\n",
    "    )\n",
    "\n",
    "    # upsert the instrument\n",
    "    upsert_request = {option_identifier: option_definition}\n",
    "    upsert_response = instruments_api.upsert_instruments(request_body=upsert_request, scope=scope)\n",
    "    option_luid = upsert_response.values[option_identifier].lusid_instrument_id\n",
    "    print(option_luid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the function above to create an `EquityOption`. See the API documentation for the available options for each attribute.\n",
    "Filter for instrumentType=`EquityOptions` under [UpsertInstruments](https://www.lusid.com/docs/api/#operation/UpsertInstruments)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUID_0003B3L8\n"
     ]
    }
   ],
   "source": [
    "option_identifier = \"AMZN_31/12/22_C168\"\n",
    "option_name = option_identifier\n",
    "start_date = datetime(2022, 1, 1, 0, tzinfo=pytz.utc)\n",
    "option_maturity_date = datetime(2022, 12, 31, 0, tzinfo=pytz.utc)\n",
    "option_settle_date = datetime(2022, 12, 31, 0, tzinfo=pytz.utc)\n",
    "delivery_type = \"Cash\"\n",
    "option_type = \"Call\" #see API docs for all configuration options\n",
    "strike = 168\n",
    "dom_ccy = \"USD\"\n",
    "underlying_code = \"AMZN\"\n",
    "underlying_identifier = \"RIC\"\n",
    "\n",
    "option_instrument = option_instrument_definition(\n",
    "    option_name,\n",
    "    option_identifier,\n",
    "    start_date,\n",
    "    option_maturity_date,\n",
    "    option_settle_date,\n",
    "    delivery_type,\n",
    "    option_type,\n",
    "    strike,\n",
    "    dom_ccy,\n",
    "    underlying_code,\n",
    "    underlying_identifier,\n",
    ")\n",
    "\n",
    "\n",
    "create_option_instrument(option_instrument)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Market data <a id='2-market-data'></a>\n",
    "\n",
    "To value and risk the option, we need three sets of market data:\n",
    "\n",
    "1. Equity prices for the underlying `Equity`\n",
    "2. Votality surface data for the underlying stock\n",
    "3. Discount curve\n",
    "\n",
    "The underlying equity prices (#1 above) are loaded into the standard `Quotes` store (via [UpsertQuotes](https://www.lusid.com/docs/api/#operation/UpsertQuotes)) whereas the volatility surface (#2) and [discount curve](https://support.lusid.com/knowledgebase/article/KA-01715/en-us) (#3) are loaded in to the `ComplexMarketData` store. The discount curve is used to calculate the risk-free rate required by the Black-Scholes model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Upload underlying equity prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>date</th>\n",
       "      <th>price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>03/01/2022</td>\n",
       "      <td>171.4000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>04/01/2022</td>\n",
       "      <td>162.5200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>05/01/2022</td>\n",
       "      <td>163.3500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>06/01/2022</td>\n",
       "      <td>164.2500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>07/01/2022</td>\n",
       "      <td>165.5500</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         date    price\n",
       "0  03/01/2022 171.4000\n",
       "1  04/01/2022 162.5200\n",
       "2  05/01/2022 163.3500\n",
       "3  06/01/2022 164.2500\n",
       "4  07/01/2022 165.5500"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices = pd.read_csv(\"data/equity_options_data.csv\")\n",
    "prices.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quote successfully loaded into LUSID. 61 quotes loaded.\n"
     ]
    }
   ],
   "source": [
    "ric = \"AMZN\"\n",
    "currency = \"USD\"\n",
    "\n",
    "# Create quotes request\n",
    "instrument_quotes = {\n",
    "    index: lm.UpsertQuoteRequest(\n",
    "        quote_id=lm.QuoteId(\n",
    "            quote_series_id=lm.QuoteSeriesId(\n",
    "                provider=\"Lusid\",\n",
    "                instrument_id=ric,\n",
    "                instrument_id_type=\"RIC\",\n",
    "                quote_type=\"Price\",\n",
    "                field=\"mid\",\n",
    "            ),\n",
    "            effective_at=to_date(row[\"date\"]).isoformat(),\n",
    "        ),\n",
    "        metric_value=lm.MetricValue(value=row[\"price\"], unit=currency),\n",
    "    )\n",
    "    for index, row in prices.iterrows()\n",
    "}\n",
    "\n",
    "# Upsert the quotes into LUSID\n",
    "response = quotes_api.upsert_quotes(scope=scope, request_body=instrument_quotes)\n",
    "\n",
    "if len(response.failed) == 0:\n",
    "    print(\n",
    "        f\"Quote successfully loaded into LUSID. {len(response.values)} quotes loaded.\"\n",
    "    )\n",
    "\n",
    "else:\n",
    "    print(\n",
    "        f\"Some failures occurred during quotes upsertion, {len(response.failed)} did not get loaded into LUSID.\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Upload volatility surface for the underlying equity\n",
    "\n",
    "For the purposes of demonstration we load a flat vol surface which sets the implied volatility to 60% for the Amazon equity. This is loaded against an ATM option which has a strike price equals to the spot price."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new option where strike price equals the spot price for 1 March 2022\n",
    "\n",
    "option_instrument_for_vol_surface = deepcopy(option_instrument)\n",
    "option_instrument_for_vol_surface.strike = 156"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set marketTypeDate=EquityVolSurfaceData on the API docs to see all parameter options\n",
    "# https://www.lusid.com/docs/api/#operation/UpsertComplexMarketData\n",
    "\n",
    "def upsert_eq_vol(scope, effective_at, market_asset, log_val):\n",
    "\n",
    "    market_data_id = lm.ComplexMarketDataId(\n",
    "        provider=\"Lusid\",\n",
    "        price_source=\"Lusid\",\n",
    "        effective_at=effective_at,\n",
    "        market_asset=market_asset,\n",
    "    )\n",
    "\n",
    "    eq_vol_surface_data = lm.EquityVolSurfaceData(\n",
    "        base_date=effective_at,\n",
    "        instruments=[option_instrument_for_vol_surface],\n",
    "        quotes=[lm.MarketQuote(quote_type=\"LogNormalVol\", value=log_val)],\n",
    "        market_data_type=\"EquityVolSurfaceData\",\n",
    "    )\n",
    "\n",
    "    vol_request = complex_market_data_api.upsert_complex_market_data(\n",
    "        scope=scope,\n",
    "        request_body={\n",
    "            market_asset: lm.UpsertComplexMarketDataRequest(\n",
    "                market_data_id=market_data_id, market_data=eq_vol_surface_data\n",
    "            )\n",
    "        },\n",
    "    )\n",
    "    \n",
    "    return vol_request.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'AMZN/USD/LN': datetime.datetime(2023, 4, 27, 9, 50, 21, 170552, tzinfo=tzlocal())}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "upsert_eq_vol(scope, \"2022-03-01\", \"AMZN/USD/LN\", 0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Upload discount factors\n",
    "\n",
    "We also upload [discount factors](https://support.lusid.com/knowledgebase/article/KA-01715/en-us). The Black-Scholes pricer requires discount factors to discount the expected future cashflow from the maturity of the option to the pricing date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "USD/USDOIS yield curve uploaded into scope=BlackScholesValuations\n"
     ]
    }
   ],
   "source": [
    "# scope used to store our market data\n",
    "market_data_scope = scope\n",
    "# the market data supplier\n",
    "market_supplier = \"Lusid\"\n",
    "\n",
    "\n",
    "def upsert_discount_factors(scope, effective_at, market_asset):\n",
    "\n",
    "    # provide the structured data file source and it's document format\n",
    "    complex_market_data = lm.DiscountFactorCurveData(\n",
    "        base_date=datetime(2022, 3, 1, tzinfo=pytz.utc),\n",
    "        dates=[\n",
    "            datetime(2022, 3, 1, tzinfo=pytz.utc),\n",
    "            datetime(2022, 5, 1, tzinfo=pytz.utc),\n",
    "            datetime(2022, 7, 1, tzinfo=pytz.utc),\n",
    "            datetime(2022, 9, 1, tzinfo=pytz.utc),\n",
    "            datetime(2022, 11, 1, tzinfo=pytz.utc),\n",
    "        ],\n",
    "        discount_factors=[1.0, 0.9883, 0.9826, 0.9789, 0.9756,],\n",
    "        market_data_type=\"DiscountFactorCurveData\",\n",
    "    )\n",
    "\n",
    "    # create a unique identifier for our OIS yield curves\n",
    "    complex_id = lm.ComplexMarketDataId(\n",
    "        provider=\"Lusid\",\n",
    "        price_source=\"Lusid\",\n",
    "        effective_at=effective_at,\n",
    "        market_asset=market_asset,\n",
    "    )\n",
    "\n",
    "    upsert_request = lm.UpsertComplexMarketDataRequest(\n",
    "        market_data_id=complex_id, market_data=complex_market_data\n",
    "    )\n",
    "\n",
    "    # https://www.lusid.com/docs/api#operation/UpsertComplexMarketData\n",
    "    response = complex_market_data_api.upsert_complex_market_data(\n",
    "        scope=scope, request_body={market_asset: upsert_request}\n",
    "    )\n",
    "\n",
    "    if response.failed:\n",
    "        raise StopExecution(\"Failed to upload yield curve {response.failed}\")\n",
    "\n",
    "    print(f\"{market_asset} yield curve uploaded into scope={scope}\")\n",
    "\n",
    "\n",
    "upsert_discount_factors(market_data_scope, \"2022-03-01\", \"USD/USDOIS\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Valuations <a id='3-run-valuations'></a>\n",
    "\n",
    "Finally we run valuations on the option to produce a price and risk metrics. We run the valuation using a custom recipe which has been configured to use the Black-Scholes model for options. There are three market data rules:\n",
    "\n",
    "\n",
    "| Makret data key | Description |\n",
    "| :--------------------- | :----------- |\n",
    "| `Quote.RIC.*` | Load quotes for the underlying equity from the standard `Quotes` store  |\n",
    "| `EquityVol.*.*.*` | Load volatility numbers from the `ComplexMarketDataStore` |\n",
    "| `Rates.*.*` | Load discount curves from the `ComplexMarketDataStore` |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Create Valuation Recipe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Configuration recipe loaded into LUSID at time 2023-04-27 09:50:21.778170+00:00.\n"
     ]
    }
   ],
   "source": [
    "# Set recipe code\n",
    "recipe_code = \"OptValuation\"\n",
    "\n",
    "# Populate recipe parameters\n",
    "configuration_recipe = lm.ConfigurationRecipe(\n",
    "    scope=scope,\n",
    "    code=recipe_code,\n",
    "    market=lm.MarketContext(\n",
    "        market_rules=[\n",
    "\n",
    "            lm.MarketDataKeyRule(\n",
    "                key=\"Quote.RIC.*\",\n",
    "                supplier=\"Lusid\",\n",
    "                data_scope=scope,\n",
    "                quote_type=\"Price\",\n",
    "                field=\"mid\",\n",
    "                quote_interval=\"5D.0D\",\n",
    "            ),\n",
    "            lm.MarketDataKeyRule(\n",
    "                key=\"EquityVol.*.*.*\",\n",
    "                supplier=\"Lusid\",\n",
    "                data_scope=scope,\n",
    "                price_source=\"Lusid\",\n",
    "                quote_type=\"Price\",\n",
    "                field=\"mid\",\n",
    "                quote_interval=\"30D.0D\",\n",
    "            ),\n",
    "            lm.MarketDataKeyRule(\n",
    "                key=\"Rates.*.*\",\n",
    "                supplier=\"Lusid\",\n",
    "                data_scope=scope,\n",
    "                price_source=\"Lusid\",\n",
    "                quote_type=\"Price\",\n",
    "                field=\"mid\",\n",
    "                quote_interval=\"30D.0D\",\n",
    "            ),\n",
    "        ],\n",
    "    ),\n",
    "    pricing=lm.PricingContext(\n",
    "        model_rules=[\n",
    "            lm.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"BlackScholes\",\n",
    "                instrument_type=\"EquityOption\",\n",
    "                parameters=\"{}\",\n",
    "            )\n",
    "        ],\n",
    "    ),\n",
    ")\n",
    "\n",
    "response = configuration_recipe_api.upsert_configuration_recipe(\n",
    "    upsert_recipe_request=lm.UpsertRecipeRequest(\n",
    "        configuration_recipe=configuration_recipe\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "print(f\"Configuration recipe loaded into LUSID at time {response.value}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Create inline valuation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_inline_valuation(effective_at):\n",
    "\n",
    "    recipe_id = lm.ResourceId(scope=scope, code=recipe_code)\n",
    "\n",
    "    valuation_schedule = lm.ValuationSchedule(effective_at=effective_at)\n",
    "\n",
    "    instruments = [\n",
    "        lm.WeightedInstrument(\n",
    "            quantity=100, holding_identifier=\"inst_001\", instrument=option_instrument\n",
    "        )\n",
    "    ]\n",
    "\n",
    "    metrics = [\n",
    "        lm.AggregateSpec(\"Instrument/default/Name\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Instrument/Definition/ContractSize\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Quotes/Price\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Holding/default/Units\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Valuation/PV/Amount\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Valuation/Delta\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Valuation/CleanPriceKey\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Instrument/OTC/EquityOption/Strike\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Instrument/OTC/EquityOption/OptionMaturityDate\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Instrument/OTC/EquityOption/Code\", \"Value\"),\n",
    "    ]\n",
    "\n",
    "    group_by = [\"Instrument/default/Name\"]\n",
    "\n",
    "    valuation = aggregration_api.get_valuation_of_weighted_instruments(\n",
    "        inline_valuation_request=lm.InlineValuationRequest(\n",
    "            recipe_id=recipe_id,\n",
    "            as_at=None,\n",
    "            metrics=metrics,\n",
    "            group_by=group_by,\n",
    "            filters=None,\n",
    "            sort=None,\n",
    "            report_currency=None,\n",
    "            equip_with_subtotals=None,\n",
    "            valuation_schedule=valuation_schedule,\n",
    "            instruments=instruments,\n",
    "            local_vars_configuration=None,\n",
    "        )\n",
    "    )\n",
    "\n",
    "    valuation_df = pd.DataFrame(valuation.data)\n",
    "\n",
    "    rename_cols = {\n",
    "        \"Instrument/OTC/EquityOption/Code\": \"OptionCode\",\n",
    "        \"Valuation/PV/Amount\": \"PresentValue\",\n",
    "        \"Instrument/Definition/ContractSize\": \"ContractSize\",\n",
    "        \"Instrument/OTC/EquityOption/Strike\": \"StrikePrice\",\n",
    "        \"Instrument/OTC/EquityOption/OptionMaturityDate\": \"OptionMaturityDate\",\n",
    "        \"Holding/default/Units\": \"Units\",\n",
    "        \"Quotes/Price\": \"PriceOfUnderlying\",\n",
    "        \"Valuation/CleanPriceKey\": \"OptionPrice\",\n",
    "        \"Valuation/Delta\": \"Delta\",\n",
    "    }\n",
    "\n",
    "    valuation_df = valuation_df.rename(columns=rename_cols)[rename_cols.values()]\n",
    "\n",
    "    valuation_df = valuation_df.astype({\"Units\": \"int32\", \"ContractSize\": \"int32\"})\n",
    "\n",
    "    valuation_df.OptionMaturityDate = valuation_df.OptionMaturityDate.apply(\n",
    "        lambda x: x[:10]\n",
    "    )\n",
    "\n",
    "    return valuation_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Run valuations\n",
    "\n",
    "In this section, we run a valuation to produce the following:\n",
    "\n",
    "* A present value for the option (using the Option's price which is calculated per Black-Scholes)\n",
    "* A delta value for the option\n",
    "\n",
    "\n",
    "The <b>Present Value</b> (also referred to as \"Market Value\") is calculated as follows:\n",
    "\n",
    "> *Present Value = OptionPrice * ContractSize * Units*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example below, we have priced an \"in the money\" (ITM) option. It costs us USD 40.09 to buy the right (not not obligation) to purchase Amazon stock for USD 168.00 on 31 December 2022."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>OptionCode</th>\n",
       "      <th>PresentValue</th>\n",
       "      <th>ContractSize</th>\n",
       "      <th>StrikePrice</th>\n",
       "      <th>OptionMaturityDate</th>\n",
       "      <th>Units</th>\n",
       "      <th>PriceOfUnderlying</th>\n",
       "      <th>OptionPrice</th>\n",
       "      <th>Delta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AMZN</td>\n",
       "      <td>4,009.5771</td>\n",
       "      <td>1</td>\n",
       "      <td>168.0000</td>\n",
       "      <td>2022-12-31</td>\n",
       "      <td>100</td>\n",
       "      <td>171.4000</td>\n",
       "      <td>40.0958</td>\n",
       "      <td>0.6234</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  OptionCode  PresentValue  ContractSize  StrikePrice OptionMaturityDate  \\\n",
       "0       AMZN    4,009.5771             1     168.0000         2022-12-31   \n",
       "\n",
       "   Units  PriceOfUnderlying  OptionPrice  Delta  \n",
       "0    100           171.4000      40.0958 0.6234  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "option_valuaton_df = run_inline_valuation(\"2022-03-01\")\n",
    "option_valuaton_df"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "0b1a8f40ac34a0a7180ca16e2fc61472e328a883cde40034bd253e0b81ec5e34"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}