examples/use-cases/valuation/Model selection using instrument features and properties.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "data": {
      "text/plain": "'Model selection using instrument features and properties\\n\\nDemonstration of how to configure model selectio for valuation based on instrument features as well as instrument properties.\\n\\nAttributes\\n----------\\nInstruments\\nDerived instrument properties\\nModel selection\\nInstrument features\\n'"
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Model selection using instrument features and properties\n",
    "\n",
    "Demonstration of how to configure model selectio for valuation based on instrument features as well as instrument properties.\n",
    "\n",
    "Attributes\n",
    "----------\n",
    "Instruments\n",
    "Derived instrument properties\n",
    "Model selection\n",
    "Instrument features\n",
    "\"\"\""
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Model selection using instrument features and properties\n",
    "\n",
    "In this notebook, we demonstrate how models can be chosen within configuration recipe in LUSID. We show how one can select model for an instrument based on instrument features as well as (derived) instrument properties. Here the instrument features are labels attached onto an instrument (by the system) outlining its features for example an FX option might have feature of category ExerciseType with value American or feature of category DeliveryType with value Physical. Instrument properties on the other hand are labels assigned by the user themselves on per instrument basis. This allows a myriad of ways to control how model selection occurs in the valuation call. Instrument features can be seen from the UI but they can also be requested via API endpoint, this and more about the features is outlined in section 7."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "<style>.container { width:90% !important; }</style>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUSID Environment Initialised\n",
      "LUSID API Version : 0.6.11346.0\n"
     ]
    }
   ],
   "source": [
    "# Import generic non-LUSID packages\n",
    "import os\n",
    "import pandas as pd\n",
    "from datetime import datetime, timedelta\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import json\n",
    "import pytz\n",
    "from uuid import uuid4\n",
    "from IPython.core.display import HTML\n",
    "\n",
    "# Import key modules from the LUSID package\n",
    "import lusid\n",
    "import lusid.models as lm\n",
    "import lusid.api as la\n",
    "from lusid.utilities import ApiClientFactory\n",
    "\n",
    "# Import key functions from Lusid-Python-Tools and other packages\n",
    "from lusidjam import RefreshingToken\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",
    "display(HTML(\"<style>.container { width:90% !important; }</style>\"))\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 : ApiClientFactory = ApiClientFactory(\n",
    "    token=RefreshingToken(),\n",
    "    api_secrets_filename = secrets_path)\n",
    "\n",
    "print ('LUSID Environment Initialised')\n",
    "print ('LUSID API Version :', api_factory.build(lusid.api.ApplicationMetadataApi).get_lusid_versions().build_version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set required APIs\n",
    "portfolio_api = api_factory.build(lusid.api.PortfoliosApi)\n",
    "transaction_portfolios_api = api_factory.build(lusid.api.TransactionPortfoliosApi)\n",
    "instruments_api = api_factory.build(lusid.api.InstrumentsApi)\n",
    "properties_api = api_factory.build(lusid.PropertyDefinitionsApi)\n",
    "quotes_api = api_factory.build(lusid.api.QuotesApi)\n",
    "configuration_recipe_api = api_factory.build(lusid.api.ConfigurationRecipeApi)\n",
    "complex_market_data_api = api_factory.build(lusid.api.ComplexMarketDataApi)\n",
    "aggregation_api = api_factory.build(lusid.api.AggregationApi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define global variables\n",
    "random_hex = uuid4().hex\n",
    "scope = \"ibor-opt-vmr-\" + random_hex\n",
    "market_data_scope = \"ibor-opt-vmr-\" + random_hex\n",
    "market_supplier = \"Lusid\"\n",
    "portfolio_code = \"pf_code-opt-vmr-\" + random_hex\n",
    "recipe_code = \"OptValuation-vmr\" + random_hex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Create Portfolio\n",
    "\n",
    "We begin by creating a portfolio that will contain the FX option instruments that we will be looking to price. We will be grouping the OTC deals using a sub-holding key, this will then keep the transactions associated with a particular deal (and not instrument which is the default LUSID behaviour) linked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Property definition created with the following key: Transaction/ibor-opt-vmr-b818834bafa046f2ab35a56dd726c095/DealId\n"
     ]
    }
   ],
   "source": [
    "# Obtain the LUSID Property Definition API\n",
    "property_definition_api = api_factory.build(la.PropertyDefinitionsApi)\n",
    "\n",
    "# Create a property definition for the SHK in the 'Transaction' domain, with a unique scope and code\n",
    "property_definition = lm.CreatePropertyDefinitionRequest(\n",
    "    domain = \"Transaction\",\n",
    "    scope = scope,\n",
    "    code = \"DealId\",\n",
    "    display_name = \"Deal ID\",\n",
    "    data_type_id = lm.ResourceId(\n",
    "        scope = \"system\",\n",
    "        code = \"string\"\n",
    "    )\n",
    ")\n",
    "\n",
    "# Upsert property definition to LUSID\n",
    "try:\n",
    "    upsert_property_definition_response = property_definition_api.create_property_definition(\n",
    "        create_property_definition_request = property_definition\n",
    "    )\n",
    "    print(f\"Property definition created with the following key: {upsert_property_definition_response.key}\")\n",
    "except lusid.ApiException as e:\n",
    "    if json.loads(e.body)[\"name\"] == \"PropertyAlreadyExists\":\n",
    "            print(f\"Property definition with the following key already exists: {property_definition.domain}/{property_definition.scope}/{property_definition.code}\")\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "try:\n",
    "    transaction_portfolios_api.create_portfolio(\n",
    "        scope=scope,\n",
    "        create_transaction_portfolio_request=lm.CreateTransactionPortfolioRequest(\n",
    "            display_name=portfolio_code,\n",
    "            code=portfolio_code,\n",
    "            base_currency=\"EUR\",\n",
    "            created=\"2010-01-01\",\n",
    "            instrument_scopes=[scope]\n",
    "        ),\n",
    "    )\n",
    "\n",
    "except lusid.ApiException as e:\n",
    "    if json.loads(e.body)['name'] == \"PortfolioWithIdAlreadyExists\":\n",
    "        print(\"Portfolio with this id already exists.\")\n",
    "    else:\n",
    "        raise e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Create Instrument\n",
    "\n",
    "We create a helper function to create and upsert the fxOption instrument into LUSID, this will reference the SDK models to populate the required parameters for creating an FX Option. We then populate the instrument variables, and make a call to persist the instrument in LUSID.\n",
    "\n",
    "We are creating 3 fx options with transactions to demonstrate valuation with advanced model selection. The three instruments we will be inserting are as follows:\n",
    "\n",
    "1. Option_Special_EUR:  A 1M vanilla european option with instrument property \"Instrument/{scope}/special\" set to \"yes\",\n",
    "2. Option_Not_Special_EUR:  A 4M vanilla european option with instrument property \"Instrument/{scope}/special\" set to \"no\",\n",
    "3. Option_AMER:  A 2M vanilla american option with no instrument property set.\n",
    "\n",
    "Instrument properties and instrument features can be used to select models used for instrument pricing. Demonstrating how this is done is the main intention behind this notebook this is why \"Instrument/{scope}/special\" property is being created here and attached to some instruments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define function that creates an FX option\n",
    "\n",
    "def create_fx_option(strike, dom_ccy, fgn_ccy, start_date, maturity_date, settlement_date, is_call, is_fx_delivery = True, is_payoff_digital = False, exercise_type : str = \"European\"):\n",
    "    \n",
    "    return lm.FxOption(\n",
    "        strike = strike,\n",
    "        dom_ccy = dom_ccy,\n",
    "        fgn_ccy = fgn_ccy,\n",
    "        start_date = start_date,\n",
    "        option_maturity_date = maturity_date,\n",
    "        option_settlement_date = settlement_date,\n",
    "        is_call_not_put = is_call,\n",
    "        is_delivery_not_cash = is_fx_delivery,\n",
    "        is_payoff_digital = is_payoff_digital,\n",
    "        exercise_type = exercise_type,\n",
    "        instrument_type = \"FxOption\",\n",
    "        dom_amount = 1\n",
    "    )\n",
    "\n",
    "# Define a function to upsert instrument\n",
    "def upsert_instrument_to_lusid(instr_scope, instrument_definition, name, identifier, identifier_type, props = None):\n",
    "        return instruments_api.upsert_instruments(\n",
    "            request_body={\n",
    "                identifier: lm.InstrumentDefinition(\n",
    "                    name=name,\n",
    "                    identifiers={\n",
    "                        identifier_type: lm.InstrumentIdValue(value=identifier)\n",
    "                    },\n",
    "                    definition=instrument_definition,\n",
    "                    properties=props\n",
    "                )\n",
    "            },\n",
    "            scope = instr_scope\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "# Set common  trade variables\n",
    "trade_date = datetime(2021, 1, 20, tzinfo=pytz.utc)\n",
    "start_date = trade_date\n",
    "settle_days = 2\n",
    "units = 1000000\n",
    "dom_ccy = \"EUR\"\n",
    "fgn_ccy = \"USD\"\n",
    "strike = 1.2050\n",
    "premium_currency = \"EUR\"\n",
    "identifier_type = \"ClientInternal\""
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "# Create instrument property\n",
    "\n",
    "properties = lm.ModelProperty(key=f\"Instrument/{scope}/special\")\n",
    "try:\n",
    "    properties_api.create_property_definition(\n",
    "        create_property_definition_request=lm.CreatePropertyDefinitionRequest(\n",
    "            domain=\"Instrument\",\n",
    "            scope=scope,\n",
    "            code=\"special\",\n",
    "            display_name=\"special\",\n",
    "            data_type_id=lm.ResourceId(code=\"string\", scope=\"system\"),\n",
    "        )\n",
    "    )\n",
    "except lusid.ApiException as e:\n",
    "    if json.loads(e.body)[\"name\"] == \"PropertyAlreadyExists\":\n",
    "        print(\"Such property is already upserted.\")\n",
    "    else:\n",
    "        raise e"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUID_0007BF0O : EURUSDEuropeanSpecialOptionDemo\n"
     ]
    }
   ],
   "source": [
    "# 1. Option_Special_EUR:  A 1M vanilla european option with instrument property \"Instrument/{scope}/special\" set to \"yes\"\n",
    "maturity_date = trade_date + timedelta(days = 30)\n",
    "settlement_date = maturity_date + timedelta(days = 2)\n",
    "\n",
    "option_special_eur_name = \"EUR/USD European Special FX Option \" + maturity_date.strftime(\"%m/%d/%Y\")  + \" \" + str(strike)\n",
    "option_special_eur_identifier = \"EURUSDEuropeanSpecialOptionDemo\"\n",
    "\n",
    "# Create the Instrument\n",
    "option_special_eur_definition = create_fx_option(\n",
    "    strike = strike,\n",
    "    dom_ccy = dom_ccy,\n",
    "    fgn_ccy = fgn_ccy,\n",
    "    start_date = start_date,\n",
    "    maturity_date = maturity_date,\n",
    "    settlement_date = settlement_date,\n",
    "    is_call = True,\n",
    "    is_fx_delivery = True,\n",
    "    is_payoff_digital = False,\n",
    "    exercise_type = \"European\"\n",
    ")\n",
    "\n",
    "# Upsert the instrument\n",
    "upsert_response = upsert_instrument_to_lusid(\n",
    "    scope,\n",
    "    option_special_eur_definition,\n",
    "    option_special_eur_name,\n",
    "    option_special_eur_identifier,\n",
    "    identifier_type,\n",
    "    [lm.ModelProperty(f\"Instrument/{scope}/special\", value=lm.PropertyValue(label_value=\"yes\"))]\n",
    ")\n",
    "\n",
    "luid_opt1 = upsert_response.values[option_special_eur_identifier].lusid_instrument_id\n",
    "print(f\"{luid_opt1} : {option_special_eur_identifier}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUID_0007BF0P : EURUSDEuropeanNotSpecialOptionDemo\n"
     ]
    }
   ],
   "source": [
    "# 2. Option_Not_Special_EUR:  A 4M vanilla european option with instrument property \"Instrument/{scope}/special\" set to \"no\"\n",
    "maturity_date = trade_date + timedelta(days = 120)\n",
    "settlement_date = maturity_date + timedelta(days = 2)\n",
    "\n",
    "option_not_special_eur_name = \"EUR/USD European Not Special FX Option \" + maturity_date.strftime(\"%m/%d/%Y\")  + \" \" + str(strike)\n",
    "option_not_special_eur_identifier = \"EURUSDEuropeanNotSpecialOptionDemo\"\n",
    "\n",
    "# Create the Instrument\n",
    "option_not_special_eur_definition = create_fx_option(\n",
    "    strike = strike,\n",
    "    dom_ccy = dom_ccy,\n",
    "    fgn_ccy = fgn_ccy,\n",
    "    start_date = start_date,\n",
    "    maturity_date = maturity_date,\n",
    "    settlement_date = settlement_date,\n",
    "    is_call = True,\n",
    "    is_fx_delivery = True,\n",
    "    is_payoff_digital = False,\n",
    "    exercise_type = \"European\"\n",
    ")\n",
    "\n",
    "# Upsert the instrument\n",
    "upsert_response = upsert_instrument_to_lusid(\n",
    "    scope,\n",
    "    option_not_special_eur_definition,\n",
    "    option_not_special_eur_name,\n",
    "    option_not_special_eur_identifier,\n",
    "    identifier_type,\n",
    "    [lm.ModelProperty(f\"Instrument/{scope}/special\", value=lm.PropertyValue(label_value=\"no\"))]\n",
    ")\n",
    "\n",
    "luid_opt2 = upsert_response.values[option_not_special_eur_identifier].lusid_instrument_id\n",
    "print(f\"{luid_opt2} : {option_not_special_eur_identifier}\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUID_0007BF0Q : EURUSDAmericanOptionDemo\n"
     ]
    }
   ],
   "source": [
    "# 3. Option_AMER:  A 2M vanilla american option with no instrument property set.\n",
    "maturity_date = trade_date + timedelta(days = 60)\n",
    "settlement_date = maturity_date + timedelta(days = 2)\n",
    "\n",
    "option_amer_name = \"EUR/USD American FX Option \" + maturity_date.strftime(\"%m/%d/%Y\")  + \" \" + str(strike)\n",
    "option_amer_identifier = \"EURUSDAmericanOptionDemo\"\n",
    "\n",
    "# Create the Instrument\n",
    "option_amer_definition = create_fx_option(\n",
    "    strike = strike,\n",
    "    dom_ccy = dom_ccy,\n",
    "    fgn_ccy = fgn_ccy,\n",
    "    start_date = start_date,\n",
    "    maturity_date = maturity_date,\n",
    "    settlement_date = settlement_date,\n",
    "    is_call = True,\n",
    "    is_fx_delivery = True,\n",
    "    is_payoff_digital = False,\n",
    "    exercise_type = \"American\"\n",
    ")\n",
    "\n",
    "# Upsert the instrument\n",
    "upsert_response = upsert_instrument_to_lusid(\n",
    "    scope,\n",
    "    option_amer_definition,\n",
    "    option_amer_name,\n",
    "    option_amer_identifier,\n",
    "    identifier_type\n",
    ")\n",
    "\n",
    "luid_opt3 = upsert_response.values[option_amer_identifier].lusid_instrument_id\n",
    "print(f\"{luid_opt3} : {option_amer_identifier}\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Upsert Transactions\n",
    "\n",
    "Having created the portfolio and the Instruments, we add a Buy transaction against the option to create a position with the costs incurred representing the premium for the option."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction successfully updated at time: 2023-05-22 09:07:32.547495+00:00\n",
      "Transaction successfully updated at time: 2023-05-22 09:07:32.901784+00:00\n",
      "Transaction successfully updated at time: 2023-05-22 09:07:33.242887+00:00\n"
     ]
    }
   ],
   "source": [
    "premium = 0.02\n",
    "\n",
    "txs = {\n",
    "    \"TXN001\": option_special_eur_identifier,\n",
    "    \"TXN002\": option_not_special_eur_identifier,\n",
    "    \"TXN003\": option_amer_identifier\n",
    "}\n",
    "for tx in txs:\n",
    "    opt_txn = lm.TransactionRequest(\n",
    "        transaction_id= tx,\n",
    "        type=\"Buy\",\n",
    "        instrument_identifiers={\"Instrument/default/ClientInternal\": txs[tx]},\n",
    "        transaction_date=trade_date.isoformat(),\n",
    "        settlement_date=(trade_date + timedelta(days = settle_days)).isoformat(),\n",
    "        units=units,\n",
    "        transaction_price=lm.TransactionPrice(price=premium,type=\"Price\"),\n",
    "        total_consideration=lm.CurrencyAndAmount(amount=premium*units,currency=premium_currency),\n",
    "        exchange_rate=1,\n",
    "        transaction_currency=premium_currency\n",
    "    )\n",
    "\n",
    "    response = transaction_portfolios_api.upsert_transactions(scope=scope,\n",
    "                                                        code=portfolio_code,\n",
    "                                                        transaction_request=[opt_txn])\n",
    "\n",
    "    print(f\"Transaction successfully updated at time: {response.version.as_at_date}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Upsert Market Data\n",
    "\n",
    "Next we will be loading the required marked data into the quotes store. In this particular example to value an option, we will be using the standard Black-Scholes pricing model. To understand what economic dependencies we may call instrument capabilities endpoint for guidance, for example for the first european fx option if we want to use BlackScholes model we need the following economic dependencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'date': datetime.datetime(2021, 2, 19, 0, 0, tzinfo=tzutc()),\n",
      " 'dependency_type': 'FxDependency',\n",
      " 'domestic_currency': 'EUR',\n",
      " 'foreign_currency': 'USD'}\n",
      "{'date': datetime.datetime(1, 1, 1, 0, 0, tzinfo=tzutc()),\n",
      " 'dependency_type': 'FxDependency',\n",
      " 'domestic_currency': 'EUR',\n",
      " 'foreign_currency': 'USD'}\n",
      "{'currency': 'EUR',\n",
      " 'date': datetime.datetime(1, 1, 1, 0, 0, tzinfo=tzutc()),\n",
      " 'dependency_type': 'CashDependency'}\n",
      "{'currency': 'USD',\n",
      " 'date': datetime.datetime(1, 1, 1, 0, 0, tzinfo=tzutc()),\n",
      " 'dependency_type': 'CashDependency'}\n",
      "{'currency': 'EUR',\n",
      " 'date': datetime.datetime(1, 1, 1, 0, 0, tzinfo=tzutc()),\n",
      " 'dependency_type': 'DiscountingDependency'}\n"
     ]
    }
   ],
   "source": [
    "capabilities = instruments_api.get_existing_instrument_capabilities(identifier=luid_opt1, model=\"BlackScholes\", instrument_scope=scope) # Here luid_opt1 corresponds to \"EUR/USD European Special FX Option\"\n",
    "for econ_dep in capabilities.economic_dependencies:\n",
    "    print(econ_dep)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "In particular, we require the following data:\n",
    "1. EUR/USD Spot Rates - this is the value of the underlying of the option\n",
    "2. EUR and USD discount curves - these curves are required for 2 things: to calculate the implied fx forward rate; and as the option is expiring and maturing in the future, to discount future cash flows\n",
    "3. EURUSD volatility surface - the value of an option is closely related to the expected volatility of the underlying over the period of the option"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 FX Spot Rates\n",
    "\n",
    "We begin by adding the FX spot rates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "                       Date   Rate     Pair\n0 2021-01-01 00:00:00+00:00 1.2215  EUR/USD\n1 2021-01-04 00:00:00+00:00 1.2248  EUR/USD\n2 2021-01-05 00:00:00+00:00 1.2298  EUR/USD\n3 2021-01-06 00:00:00+00:00 1.2327  EUR/USD\n4 2021-01-07 00:00:00+00:00 1.2272  EUR/USD",
      "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>Rate</th>\n      <th>Pair</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2021-01-01 00:00:00+00:00</td>\n      <td>1.2215</td>\n      <td>EUR/USD</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2021-01-04 00:00:00+00:00</td>\n      <td>1.2248</td>\n      <td>EUR/USD</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2021-01-05 00:00:00+00:00</td>\n      <td>1.2298</td>\n      <td>EUR/USD</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2021-01-06 00:00:00+00:00</td>\n      <td>1.2327</td>\n      <td>EUR/USD</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2021-01-07 00:00:00+00:00</td>\n      <td>1.2272</td>\n      <td>EUR/USD</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read fx spot rates and make datetimes timezone aware\n",
    "quotes_df = pd.read_csv(\"data/eurusd_spot.csv\")\n",
    "quotes_df[\"Date\"] = pd.to_datetime(quotes_df[\"Date\"], dayfirst=True)\n",
    "quotes_df[\"Date\"] = quotes_df[\"Date\"].apply(lambda x: x.replace(tzinfo=pytz.utc))\n",
    "quotes_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quotes successfully loaded into LUSID. 223 quotes loaded.\n"
     ]
    }
   ],
   "source": [
    "# Create quotes request\n",
    "instrument_quotes = {\n",
    "            index: lm.UpsertQuoteRequest(\n",
    "            quote_id=lm.QuoteId(\n",
    "                quote_series_id=lm.QuoteSeriesId(\n",
    "                    provider=market_supplier,\n",
    "                    instrument_id=row[\"Pair\"],\n",
    "                    instrument_id_type=\"CurrencyPair\",\n",
    "                    quote_type=\"Rate\",\n",
    "                    field=\"mid\",\n",
    "                ),\n",
    "                effective_at=row[\"Date\"].isoformat(),\n",
    "            ),\n",
    "            metric_value=lm.MetricValue(value=row[\"Rate\"], unit=row[\"Pair\"]),\n",
    "        )\n",
    "    for index, row in quotes_df.iterrows()\n",
    "}\n",
    "\n",
    "# Upsert quotes into LUSID\n",
    "response = quotes_api.upsert_quotes(\n",
    "    scope=market_data_scope, request_body=instrument_quotes\n",
    ")\n",
    "\n",
    "if response.failed == {}:\n",
    "    print(f\"Quotes successfully loaded into LUSID. {len(response.values)} quotes loaded.\")\n",
    "else:\n",
    "    print(f\"Some failures occurred during quotes upsertion, {len(response.failed)} did not get loaded into LUSID.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 EUR & USD Discount curves\n",
    "\n",
    "Next we will read in the EUR and USD Discount factors and create separate OIS curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "   index Tenor  Days  EUR-Rates  USD-Rates  EURdf  USDdf  Vol25D    ATM   \n0      0    1M    30     0.2200     1.2200 0.9998 0.9990  0.1200 0.1000  \\\n1      1    2M    60     0.3700     1.3700 0.9994 0.9978  0.1205 0.1010   \n2      2    3M    90     0.5300     1.5300 0.9987 0.9962  0.1210 0.1020   \n3      3    6M   180     0.9500     1.9500 0.9953 0.9904  0.1215 0.1030   \n4      4    1Y   365     1.3000     2.3000 0.9871 0.9773  0.1220 0.1040   \n5      5   18M   547     1.5000     2.5000 0.9778 0.9632  0.1225 0.1050   \n6      6    2Y   730     1.5000     2.5000 0.9705 0.9513  0.1230 0.1060   \n7      7    3Y  1095     1.4300     2.4300 0.9580 0.9297  0.1235 0.1070   \n8      8    4Y  1460     1.3700     2.3700 0.9467 0.9096  0.1240 0.1080   \n9      9    5Y  1825     1.3100     2.3100 0.9366 0.8909  0.1245 0.1090   \n\n   Vol75D  Strike25D  StrikeATM  Strike75D  \n0  0.1100     1.1850     1.2000     1.2150  \n1  0.1105     1.1850     1.2000     1.2150  \n2  0.1110     1.1850     1.2000     1.2150  \n3  0.1115     1.1850     1.2000     1.2150  \n4  0.1120     1.1850     1.2000     1.2150  \n5  0.1125     1.1850     1.2000     1.2150  \n6  0.1130     1.1850     1.2000     1.2150  \n7  0.1135     1.1850     1.2000     1.2150  \n8  0.1140     1.1850     1.2000     1.2150  \n9  0.1145     1.1850     1.2000     1.2150  ",
      "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>index</th>\n      <th>Tenor</th>\n      <th>Days</th>\n      <th>EUR-Rates</th>\n      <th>USD-Rates</th>\n      <th>EURdf</th>\n      <th>USDdf</th>\n      <th>Vol25D</th>\n      <th>ATM</th>\n      <th>Vol75D</th>\n      <th>Strike25D</th>\n      <th>StrikeATM</th>\n      <th>Strike75D</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>1M</td>\n      <td>30</td>\n      <td>0.2200</td>\n      <td>1.2200</td>\n      <td>0.9998</td>\n      <td>0.9990</td>\n      <td>0.1200</td>\n      <td>0.1000</td>\n      <td>0.1100</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>2M</td>\n      <td>60</td>\n      <td>0.3700</td>\n      <td>1.3700</td>\n      <td>0.9994</td>\n      <td>0.9978</td>\n      <td>0.1205</td>\n      <td>0.1010</td>\n      <td>0.1105</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2</td>\n      <td>3M</td>\n      <td>90</td>\n      <td>0.5300</td>\n      <td>1.5300</td>\n      <td>0.9987</td>\n      <td>0.9962</td>\n      <td>0.1210</td>\n      <td>0.1020</td>\n      <td>0.1110</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>3</td>\n      <td>6M</td>\n      <td>180</td>\n      <td>0.9500</td>\n      <td>1.9500</td>\n      <td>0.9953</td>\n      <td>0.9904</td>\n      <td>0.1215</td>\n      <td>0.1030</td>\n      <td>0.1115</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>4</td>\n      <td>1Y</td>\n      <td>365</td>\n      <td>1.3000</td>\n      <td>2.3000</td>\n      <td>0.9871</td>\n      <td>0.9773</td>\n      <td>0.1220</td>\n      <td>0.1040</td>\n      <td>0.1120</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>5</td>\n      <td>18M</td>\n      <td>547</td>\n      <td>1.5000</td>\n      <td>2.5000</td>\n      <td>0.9778</td>\n      <td>0.9632</td>\n      <td>0.1225</td>\n      <td>0.1050</td>\n      <td>0.1125</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>6</td>\n      <td>2Y</td>\n      <td>730</td>\n      <td>1.5000</td>\n      <td>2.5000</td>\n      <td>0.9705</td>\n      <td>0.9513</td>\n      <td>0.1230</td>\n      <td>0.1060</td>\n      <td>0.1130</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>7</td>\n      <td>3Y</td>\n      <td>1095</td>\n      <td>1.4300</td>\n      <td>2.4300</td>\n      <td>0.9580</td>\n      <td>0.9297</td>\n      <td>0.1235</td>\n      <td>0.1070</td>\n      <td>0.1135</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>8</td>\n      <td>4Y</td>\n      <td>1460</td>\n      <td>1.3700</td>\n      <td>2.3700</td>\n      <td>0.9467</td>\n      <td>0.9096</td>\n      <td>0.1240</td>\n      <td>0.1080</td>\n      <td>0.1140</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>9</td>\n      <td>5Y</td>\n      <td>1825</td>\n      <td>1.3100</td>\n      <td>2.3100</td>\n      <td>0.9366</td>\n      <td>0.8909</td>\n      <td>0.1245</td>\n      <td>0.1090</td>\n      <td>0.1145</td>\n      <td>1.1850</td>\n      <td>1.2000</td>\n      <td>1.2150</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read FX market data - showing first 10 terms\n",
    "df_market_data = pd.read_csv(\"data/EURUSD-MarketData.csv\")\n",
    "df_market_data[\"Days\"]= df_market_data[\"Days\"].astype(int)\n",
    "df_market_data = df_market_data.reset_index()\n",
    "df_market_data.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "We will now upsert discount factors, in particular we will use the `DiscountFactorCurveData` market data type. For information about what categories of complex market data types are available please refer to https://support.lusid.com/knowledgebase/article/KA-02004/en-us."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [],
   "source": [
    "# Set up the OIS curves loader function\n",
    "def upsert_discount_factors(scope, effective_at, market_asset, dates, dfs):\n",
    "\n",
    "    complex_market_data = lm.DiscountFactorCurveData(\n",
    "        base_date=effective_at,\n",
    "        dates=dates,\n",
    "        discount_factors = dfs,\n",
    "        market_data_type=\"DiscountFactorCurveData\"\n",
    "    )\n",
    "\n",
    "    # create a unique identifier for our OIS yield curves\n",
    "    complex_id = lm.ComplexMarketDataId(\n",
    "        provider=market_supplier,\n",
    "        price_source = market_supplier,\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",
    "\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",
    "        print(f\"Failed to upload yield curve {response.failed}\")\n",
    "\n",
    "    print(f\"{market_asset} yield curve uploaded into scope={scope}\")\n",
    "\n",
    "    return complex_id"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EUR/EUROIS yield curve uploaded into scope=ibor-opt-vmr-b818834bafa046f2ab35a56dd726c095\n",
      "USD/USDOIS yield curve uploaded into scope=ibor-opt-vmr-b818834bafa046f2ab35a56dd726c095\n"
     ]
    }
   ],
   "source": [
    "# Set up the OIS curves\n",
    "base_date = trade_date\n",
    "dates = []\n",
    "dfs = []\n",
    "\n",
    "# loading the data for EUR OIS discount curve\n",
    "for index, row in df_market_data.iterrows():\n",
    "    dates.append(base_date + timedelta(days=row[\"Days\"]))\n",
    "    dfs.append(row[\"EURdf\"])\n",
    "\n",
    "curve_id_EUR = upsert_discount_factors(market_data_scope, base_date, \"EUR/EUROIS\", dates, dfs)\n",
    "\n",
    "\n",
    "dates = []\n",
    "dfs = []\n",
    "\n",
    "# loading the data for USD OIS discount curve\n",
    "for index, row in df_market_data.iterrows():\n",
    "    dates.append(base_date + timedelta(days=row[\"Days\"]))\n",
    "    dfs.append(row[\"USDdf\"])\n",
    "    \n",
    "curve_id_USD = upsert_discount_factors(market_data_scope, base_date, \"USD/USDOIS\", dates, dfs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 Create the curve instruments\n",
    "\n",
    "In this section we create a volatility surface, which is constructed using FX option instruments representing different points in terms of maturity, strike and implied volatility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def upsert_fxoption_curve_instruments (df_vol_data):\n",
    "\n",
    "    for index, row in df_vol_data.iterrows():\n",
    "\n",
    "        option_expiry = base_date + timedelta(days=row[\"Days\"])\n",
    "\n",
    "        # Create the Instrument\n",
    "        option_definition = create_fx_option(\n",
    "            strike = row[\"Strike\"],\n",
    "            dom_ccy = dom_ccy,\n",
    "            fgn_ccy = fgn_ccy,\n",
    "            start_date = base_date,\n",
    "            maturity_date = option_expiry,\n",
    "            settlement_date =option_expiry + timedelta(days=2),\n",
    "            is_call = True,\n",
    "            is_payoff_digital = False,\n",
    "            is_fx_delivery = True,\n",
    "        )\n",
    "\n",
    "        option_name = \"EUR/USD \" + \" FX Option \" + option_expiry.strftime(\"%m/%d/%Y\")\n",
    "        option_identifier = (f\"EURUSDVolCurve{index}:{row['Strike']}\")\n",
    "\n",
    "        curve_map.append({option_name : option_identifier})\n",
    "        curve_instruments.append(option_definition)\n",
    "\n",
    "        # Upsert the instrument\n",
    "        upsert_response = upsert_instrument_to_lusid(scope, option_definition, option_name, option_identifier, identifier_type, None)\n",
    "        curve_instruments_id.append(upsert_response.values[option_identifier].lusid_instrument_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 instruments uploaded to create the vol curve\n"
     ]
    }
   ],
   "source": [
    "curve_instruments = []\n",
    "curve_instruments_id = []\n",
    "curve_map = []\n",
    "\n",
    "upsert_fxoption_curve_instruments (df_market_data[[\"Days\", \"Strike25D\"]].rename(columns={\"Strike25D\" : \"Strike\"}))\n",
    "upsert_fxoption_curve_instruments (df_market_data[[\"Days\", \"StrikeATM\"]].rename(columns={\"StrikeATM\" : \"Strike\"}))\n",
    "upsert_fxoption_curve_instruments (df_market_data[[\"Days\", \"Strike75D\"]].rename(columns={\"Strike75D\" : \"Strike\"}))\n",
    "\n",
    "print(f\"{len(curve_instruments)} instruments uploaded to create the vol curve\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.4 Upload Volatility surface\n",
    "\n",
    "Next we create the volatility surface in LUSID, associating volatility quotes with each of the instruments we have loaded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to load the surface into Lusid\n",
    "def upsert_fx_vol(scope, effective_at, market_asset, instruments, vols_low_strike, vols_atm, vols_high_strike):\n",
    "\n",
    "    market_data_id = lm.ComplexMarketDataId(\n",
    "        provider=market_supplier,\n",
    "        price_source=\"Lusid\",\n",
    "        effective_at=effective_at,\n",
    "        market_asset=market_asset,\n",
    "    )\n",
    "    \n",
    "    quotes = []\n",
    "    \n",
    "    for vol in vols_low_strike:\n",
    "        quotes.append(lm.MarketQuote(quote_type=\"LogNormalVol\", value=vol))\n",
    "        \n",
    "    for vol in vols_atm:\n",
    "        quotes.append(lm.MarketQuote(quote_type=\"LogNormalVol\", value=vol))   \n",
    "                \n",
    "    for vol in vols_high_strike:\n",
    "        quotes.append(lm.MarketQuote(quote_type=\"LogNormalVol\", value=vol))   \n",
    "\n",
    "    fx_vol_surface_data = lm.FxVolSurfaceData(\n",
    "        base_date=effective_at,\n",
    "        instruments=instruments,\n",
    "        quotes=quotes,\n",
    "        market_data_type=\"FxVolSurfaceData\"\n",
    "    )  \n",
    "    \n",
    "    response = 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=fx_vol_surface_data\n",
    "            )\n",
    "        },\n",
    "    )\n",
    "    \n",
    "    if len(response.failed) == 0:\n",
    "        print(f\"Quote successfully loaded into LUSID. {len(response.values)} quotes loaded.\")\n",
    "\n",
    "    else:\n",
    "        print(f\"Some failures occurred during quotes upsertion, {len(response.failed)} did not get loaded into LUSID.\")\n",
    "        \n",
    "    return market_data_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quote successfully loaded into LUSID. 1 quotes loaded.\n"
     ]
    }
   ],
   "source": [
    "# Actual load of the data into LUSID\n",
    "EURUSD_vol_curve_id = upsert_fx_vol(market_data_scope, base_date, \"EUR/USD/LN\", curve_instruments, df_market_data[\"Vol25D\"], df_market_data[\"ATM\"], df_market_data[\"Vol75D\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Create Configuration Recipe\n",
    "\n",
    "In order to run a valuation, LUSID will require a recipe that drives how a valuation will be conducted. The below recipe defines what model and market data to use in this context. The aim of this notebook is to demonstrate model selection, this will present itself below as `model_rules`. Each instrument is checked against each rule starting from top. A rule is satisfied if all the property filters are satisfied, the supplier and the instrument type matches. If a rule is satisfied the model stated is selected, the model selection for that instrument ends there, rules further down are not checked for that instrument.\n",
    "\n",
    "You can find out more about the valuation [here](https://support.lusid.com/knowledgebase/article/KA-01729/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Configuration recipe loaded into LUSID at time 2023-05-22 09:07:47.381572+00:00.\n"
     ]
    }
   ],
   "source": [
    "# Populate recipe parameters\n",
    "configuration_recipe = lm.ConfigurationRecipe(\n",
    "    scope=market_data_scope,\n",
    "    code=recipe_code,\n",
    "    market=lm.MarketContext(\n",
    "        market_rules=[\n",
    "            lm.MarketDataKeyRule(\n",
    "                    key=\"FX.CurrencyPair.*\",\n",
    "                    supplier=market_supplier,\n",
    "                    data_scope=market_data_scope,\n",
    "                    quote_type=\"Rate\",\n",
    "                    field=\"mid\",\n",
    "                    quote_interval=\"100D\"\n",
    "                ),\n",
    "            lm.MarketDataKeyRule(\n",
    "                key=\"FXVol.*.*.*\",\n",
    "                supplier=market_supplier,\n",
    "                data_scope=market_data_scope,\n",
    "                price_source=market_supplier,\n",
    "                quote_type=\"Price\",\n",
    "                field=\"mid\",\n",
    "                quote_interval=\"100D\",\n",
    "            ),\n",
    "            lm.MarketDataKeyRule(\n",
    "                key=\"Rates.*.*\",\n",
    "                supplier=market_supplier,\n",
    "                data_scope=market_data_scope,\n",
    "                price_source=market_supplier,\n",
    "                quote_type=\"Price\",\n",
    "                field=\"mid\",\n",
    "                quote_interval=\"100D\",\n",
    "            ),\n",
    "        ],\n",
    "        options=lm.MarketOptions(\n",
    "            default_scope = market_data_scope,\n",
    "            attempt_to_infer_missing_fx=True\n",
    "        ),\n",
    "    ),\n",
    "    pricing=lm.PricingContext(\n",
    "        model_rules=[\n",
    "            # EUR/USD European Special FX Option\n",
    "            # - is an instrument of type FxOption,\n",
    "            # - has ExerciseType feature is \"European\",\n",
    "            # - has a property at Instrument/{scope}/special with value \"yes\"\n",
    "            # and hence satisfies this rule and is valued with model Discounting.\n",
    "            lm.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"Discounting\",\n",
    "                instrument_type=\"FXOption\",\n",
    "                address_key_filters = [\n",
    "                    lm.AddressKeyFilter(\"Instrument/Features/ExerciseType\", \"eq\", lm.ResultValueString(\"European\", result_value_type=\"ResultValueString\")),\n",
    "                    lm.AddressKeyFilter(f\"Instrument/{scope}/special\", \"eq\", lm.ResultValueString(\"yes\", result_value_type=\"ResultValueString\"))\n",
    "                ],\n",
    "                parameters=\"{}\",\n",
    "            ),\n",
    "            # EUR/USD European Not Special FX Option\n",
    "            # - doesn't satisfy the rule above (as it doesn't have property \"Instrument/{scope}/special\" with value \"yes\")\n",
    "            # - an instrument of type FxOption,\n",
    "            # - its ExerciseType feature is \"European\",\n",
    "            # and hence satisfies this rule and is valued with model BlackScholes.\n",
    "            lm.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"BlackScholes\",\n",
    "                instrument_type=\"FXOption\",\n",
    "                address_key_filters = [\n",
    "                    lm.AddressKeyFilter(\"Instrument/Features/ExerciseType\", \"eq\", lm.ResultValueString(\"European\", result_value_type=\"ResultValueString\"))\n",
    "                ],\n",
    "                parameters=\"{}\",\n",
    "            ),\n",
    "            # EUR/USD American FX Option\n",
    "            # - doesn't satisfy the rule above (as its feature ExerciseType is not of value \"European\")\n",
    "            # - an instrument of type FxOption,\n",
    "            # - its ExerciseType feature is \"American\",\n",
    "            # and hence satisfies this rule and is valued with model BjerksundStensland1993.\n",
    "            lm.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"BjerksundStensland1993\",\n",
    "                instrument_type=\"FXOption\",\n",
    "                address_key_filters = [lm.AddressKeyFilter(\"Instrument/Features/ExerciseType\", \"eq\", lm.ResultValueString(\"American\", result_value_type=\"ResultValueString\"))],\n",
    "                parameters=\"{}\",\n",
    "            ),\n",
    "            # No instrument ever reaches this vendor model rule, it is never used.\n",
    "            lm.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"Bachelier\",\n",
    "                instrument_type=\"FXOption\",\n",
    "                parameters=\"{}\",\n",
    "            ),\n",
    "        ],\n",
    "        options = lm.PricingOptions(\n",
    "            allow_partially_successful_evaluation = True\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",
   "source": [
    "Note, an instrument may not support a given model, in which case a failure will be returned. To check which models are supported by a given instrument we can call `GetExistingInstrumentModels` endpoint, lets pick the \"special\" european option as an example:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['SimpleStatic', 'Discounting', 'BlackScholes', 'ConstantTimeValueOfMoney', 'Bachelier']\n"
     ]
    }
   ],
   "source": [
    "supported_models = instruments_api.get_existing_instrument_models(luid_opt1, instrument_scope=scope).supported_models\n",
    "print(supported_models)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "For more information about what pricing model can be used in your valuation please refer to https://support.lusid.com/knowledgebase/article/KA-01980/."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Valuation\n",
    "\n",
    "Value the portfolio using the setup above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_valuation(date, portfolio_code):\n",
    "\n",
    "    metrics = [\n",
    "        lm.AggregateSpec(\"Instrument/default/Name\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Valuation/PV/Amount\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Valuation/Model/Name\", \"Value\"),\n",
    "        lm.AggregateSpec(\"Instrument/Features/ExerciseType\", \"Value\"),\n",
    "        lm.AggregateSpec(f\"Instrument/{scope}/special\", \"Value\")\n",
    "    ]\n",
    "\n",
    "    group_by =[]\n",
    "\n",
    "    valuation_request = lm.ValuationRequest(\n",
    "        recipe_id=lm.ResourceId(scope=market_data_scope, code=recipe_code),\n",
    "        metrics=metrics,\n",
    "        group_by=group_by,\n",
    "        portfolio_entity_ids=[\n",
    "            lm.PortfolioEntityId(scope=scope, code=portfolio_code)\n",
    "        ],\n",
    "        valuation_schedule=lm.ValuationSchedule(effective_at=date),\n",
    "    )\n",
    "\n",
    "    val_data = aggregation_api.get_valuation(valuation_request=valuation_request).data\n",
    "    \n",
    "    vals_df = pd.DataFrame(val_data)\n",
    "\n",
    "    vals_df.rename(\n",
    "        columns={\n",
    "            f\"Instrument/{scope}/special\": \"Instrument/{scope}/special\"\n",
    "        },\n",
    "        inplace=True,\n",
    "    )\n",
    "    vals_df.fillna(\"\", inplace=True)\n",
    "\n",
    "    return vals_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "outputs": [
    {
     "data": {
      "text/plain": "   Valuation/PV/Amount                            Instrument/default/Name   \n0           5,421.1796  EUR/USD European Special FX Option 02/19/2021 ...  \\\n1          28,082.6301  EUR/USD European Not Special FX Option 05/20/2...   \n2          20,075.6347        EUR/USD American FX Option 03/21/2021 1.205   \n\n     Valuation/Model/Name Instrument/Features/ExerciseType   \n0             Discounting                         European  \\\n1            BlackScholes                         European   \n2  BjerksundStensland1993                         American   \n\n  Instrument/{scope}/special  \n0                        yes  \n1                         no  \n2                             ",
      "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>Valuation/PV/Amount</th>\n      <th>Instrument/default/Name</th>\n      <th>Valuation/Model/Name</th>\n      <th>Instrument/Features/ExerciseType</th>\n      <th>Instrument/{scope}/special</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>5,421.1796</td>\n      <td>EUR/USD European Special FX Option 02/19/2021 ...</td>\n      <td>Discounting</td>\n      <td>European</td>\n      <td>yes</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>28,082.6301</td>\n      <td>EUR/USD European Not Special FX Option 05/20/2...</td>\n      <td>BlackScholes</td>\n      <td>European</td>\n      <td>no</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>20,075.6347</td>\n      <td>EUR/USD American FX Option 03/21/2021 1.205</td>\n      <td>BjerksundStensland1993</td>\n      <td>American</td>\n      <td></td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "valuation = run_valuation(base_date.isoformat(), portfolio_code)\n",
    "display(valuation.head(3))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 7. Features\n",
    "Above we used the ExerciseType feature to help us select the desired model. Features are effectively labels attached to an instrument describing some part of it. In order to find out what features our instrument we call instrument capabilities endpoint, this endpoint contains variety of information for a given instrument. In particular we can get the features, for example picking the first instrument (Special European Fx Option) we get"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "outputs": [
    {
     "data": {
      "text/plain": "                         AddressKey     Value\n0    Instrument/Features/OptionType      Call\n1  Instrument/Features/DeliveryType  Physical\n2  Instrument/Features/ExerciseType  European\n3    Instrument/Features/PayoffType   Vanilla",
      "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>AddressKey</th>\n      <th>Value</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Instrument/Features/OptionType</td>\n      <td>Call</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Instrument/Features/DeliveryType</td>\n      <td>Physical</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Instrument/Features/ExerciseType</td>\n      <td>European</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Instrument/Features/PayoffType</td>\n      <td>Vanilla</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "capabilities = instruments_api.get_existing_instrument_capabilities(identifier=luid_opt1, instrument_scope=scope)\n",
    "df = pd.DataFrame(list(capabilities.features.items()), columns=['AddressKey', 'Value'])\n",
    "\n",
    "display(df)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "In addition to calling the endpoint above one can also request specific instrument feature in a valuation call. We can request a specific feature category e.g. `Instrument/Features/ExerciseType` (as done above) or request all instrument features by requesting `Instrument/Features`. Now we know what features our FxOption has we can setup configuration recipe as above, another question worth answering is \"What possible features can an instrument of type X have? For that we can call GetAllPossibleFeatures endpoint, lets take `instrument_type=FxOption` as an example,"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "outputs": [
    {
     "data": {
      "text/plain": "                                                        \nInstrument/Features/OptionType        Call       Put    \nInstrument/Features/DeliveryType  Physical      Cash    \nInstrument/Features/Barrier         Double    Single    \nInstrument/Features/Touch              Two       One  No\nInstrument/Features/ExerciseType  American  European    \nInstrument/Features/PayoffType     Digital   Vanilla    ",
      "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></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Instrument/Features/OptionType</th>\n      <td>Call</td>\n      <td>Put</td>\n      <td></td>\n    </tr>\n    <tr>\n      <th>Instrument/Features/DeliveryType</th>\n      <td>Physical</td>\n      <td>Cash</td>\n      <td></td>\n    </tr>\n    <tr>\n      <th>Instrument/Features/Barrier</th>\n      <td>Double</td>\n      <td>Single</td>\n      <td></td>\n    </tr>\n    <tr>\n      <th>Instrument/Features/Touch</th>\n      <td>Two</td>\n      <td>One</td>\n      <td>No</td>\n    </tr>\n    <tr>\n      <th>Instrument/Features/ExerciseType</th>\n      <td>American</td>\n      <td>European</td>\n      <td></td>\n    </tr>\n    <tr>\n      <th>Instrument/Features/PayoffType</th>\n      <td>Digital</td>\n      <td>Vanilla</td>\n      <td></td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_features = instruments_api.get_all_possible_features(instrument_type=\"FxOption\")\n",
    "df = pd.DataFrame.from_dict(all_features, orient='index')\n",
    "df.fillna(\"\", inplace=True)\n",
    "df.columns = [\"\"] * len(df.columns)\n",
    "\n",
    "display(df)"
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.10.6 (main, Aug  3 2022, 12:12:57) [Clang 13.1.6 (clang-1316.0.21.2.5)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "9b2ad45377be23472136155f9be1fd1f9127868d50a62bcbda4e8cdcd384c3ac"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}