examples/use-cases/valuation/Bond Pricing And Accrued Interest Calculation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Bond Pricing And Accrued Interest Calculation\n",
    "\n",
    "Demonstrates pricing a bond and calculating it's accrued interest based on a user defined Bond Instrument.\n",
    "\n",
    "Attributes\n",
    "----------\n",
    "instruments\n",
    "aggregation\n",
    "market data store\n",
    "results store\n",
    "quotes\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Bond Pricing And Accrued Interest Calculation\n",
    "\n",
    "This notebook will run through the following business use cases :\n",
    "* [Pricing a bond using the built-in discounting LUSID model fed with a user supplied OIS yield curve.](#pricing_bond)\n",
    "* [Calculating the accrued interest between coupon dates based on user defined bond instrument parameters such as the day count convention.](#accrued_interest)\n",
    "* [Adding a transaction in a user defined bond instrument to a portfolio and subsequently valuing our portfolio.](#pricing_bond_portfolio)\n",
    "* [Overriding the calculated accrued interest with user provided value and feeding it in to our bond valuation.](#accrual_override)\n",
    "* [Valuing bond PV using an externally provided market quote for the bond.](#external_bond_price)\n",
    "\n",
    "<br>\n",
    "\n",
    "In doing so we'll cover the following LUSID concepts :\n",
    "* [Defining a LUSID internal representation of a bond instrument based on user provided parameters.](#bond_definition)\n",
    "* [Using the StructureMarketData store to hold your OIS yield curve data in way that enables it to be discovered during the bond valuation process.](#structured_market_data)\n",
    "* [Configuring recipes to run built in LUSID bond valuation models that make use of the structured data (OIS Yield Curve) you provided.](#recipe_configuration)\n",
    "* [Using aggregation requests to return the accrued interest as well as the PV of the bond based on our instrument definition.](#accrued_interest)\n",
    "* [Using the StructuredResultData store to override the accrued interest calculation and instead use static values.](#structured_result_data)\n",
    "* [Updating our recipes to make use of the StructuredResultData entries in your valuations.](#structured_result_data)\n",
    "* [Upserting bond market price as quotes and configuring recipes that value bonds by using the market quotes.](#external_bond_price)\n",
    "\n",
    "<br>\n",
    "\n",
    "For this notebook example we'll work with an example Gilt 1.5% 47s:\n",
    "* Coupon Rate : 1.5%\n",
    "* Maturity Date: 22 Jul 2047\n",
    "* Issue Date: 21 Sep 2016\n",
    "* Coupon Dates : 22 Jan, 22 Jun\n",
    "* Face Value : £1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Setup LUSID and LUSID API objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/requests/__init__.py:91: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (3.0.4) doesn't match a supported version!\n",
      "  RequestsDependencyWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUSID Environment Initialised\n",
      "LUSID SDK Version:  0.0.1.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "import lusid\n",
    "from stop_execution import StopExecution\n",
    "import pandas as pd\n",
    "import pytz\n",
    "from lusid import models\n",
    "from lusid.utilities import ApiClientFactory\n",
    "from lusidjam import RefreshingToken\n",
    "from lusidtools.cocoon.cocoon_printer import (\n",
    "    format_portfolios_response,\n",
    ")\n",
    "\n",
    "\n",
    "# Authenticate our user and create our API client\n",
    "from lusidtools.cocoon import load_from_data_frame\n",
    "secrets_path = os.getenv(\"FBN_SECRETS_PATH\")\n",
    "\n",
    "# Initiate an API Factory which is the client side object for interacting with LUSID APIs\n",
    "api_factory = lusid.utilities.ApiClientFactory(\n",
    "    token=RefreshingToken(),\n",
    "    api_secrets_filename=secrets_path,\n",
    "    app_name=\"LusidJupyterNotebook\",\n",
    ")\n",
    "\n",
    "print ('LUSID Environment Initialised')\n",
    "print ('LUSID SDK Version: ', api_factory.build(lusid.api.ApplicationMetadataApi).get_lusid_versions().build_version)\n",
    "\n",
    "# Setup the apis we'll use in this notebook:\n",
    "instruments_api = api_factory.build(lusid.api.InstrumentsApi)\n",
    "complex_market_data_api = api_factory.build(lusid.api.ComplexMarketDataApi)\n",
    "structured_result_data_api = api_factory.build(lusid.api.StructuredResultDataApi)\n",
    "\n",
    "# Setup the scope we'll use in this notebook:\n",
    "scope = \"bond-pricing-nb\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Settings and utility functions to display objects and responses more clearly.\n",
    "pd.set_option('float_format', '{:,.3f}'.format)\n",
    "def aggregation_result_to_dataframe(aggregation_results):\n",
    "    return pd.DataFrame(aggregation_results, columns = ['Name', 'Effective At', 'Value'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Define our Gilt as a Bond Instrument in LUSID <a id=\"bond_definition\"></a>\n",
    "\n",
    "Let's start by defining our bond instrument in LUSID via the bond class in the models of the SDKs. Take a look\n",
    "in the models package for other instruments currently supported (or see the [Bond Specification](https://www.lusid.com/api/swagger/index.html)).\n",
    "\n",
    "We'll start by initialising the basic bond parameters for our Gilt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "coupon_rate = 0.015\n",
    "start_date = datetime(2016, 9, 21, tzinfo=pytz.utc)\n",
    "maturity_date = datetime(2047, 7, 22, tzinfo=pytz.utc)\n",
    "dom_ccy = \"GBP\"\n",
    "face_value = 1\n",
    "\n",
    "trade_date = datetime(2020, 6, 22, tzinfo=pytz.utc)\n",
    "effective_at = datetime(2020, 6, 23, tzinfo=pytz.utc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Let's now move onto describing the conventions our bond instrument follows. Specifically we'll set up the behaviour of\n",
    "our cash flows date schedule which includes setting the day count convention for calculating accrued interest and\n",
    "handling cash flows landing on non business days. This behaviour is encapsulated in a FlowConventions object. For\n",
    "details on supported tenors, day count and roll conventions see the [Bond Specification](https://www.lusid.com/api/swagger/index.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_bond_instrument_definition(start_date, maturity_date, dom_ccy, coupon_rate, face_value):\n",
    "    instrument = models.Bond(\n",
    "        start_date=start_date.isoformat(),\n",
    "        maturity_date=maturity_date.isoformat(),\n",
    "        dom_ccy=dom_ccy,\n",
    "        coupon_rate=coupon_rate,\n",
    "        principal=face_value,\n",
    "        flow_conventions=models.FlowConventions(\n",
    "            # coupon payment currency\n",
    "            currency=\"GBP\",\n",
    "            # semi-annual coupon payments\n",
    "            payment_frequency= \"6M\",\n",
    "            # using an Actual/365 day count convention (other options : Act360, ActAct, ...\n",
    "            day_count_convention=\"Act365\",\n",
    "            # modified following rolling convention (other options : ModifiedPrevious, NoAdjustment, EndOfMonth,...)\n",
    "            roll_convention=\"ModifiedFollowing\",\n",
    "            # no holiday calendar supplied\n",
    "            payment_calendars=[],\n",
    "            reset_calendars=[],\n",
    "            settle_days=2,\n",
    "            reset_days=2,\n",
    "        ),\n",
    "        identifiers={},\n",
    "        instrument_type=\"Bond\"\n",
    "    )\n",
    "    return instrument\n",
    "\n",
    "bond_instrument_definition = create_bond_instrument_definition(start_date, maturity_date, dom_ccy, coupon_rate, face_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use our bond instrument definition to create an instance of our Gilt 1.5% 47 and upsert it as an instrument into LUSID:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_bond_instrument(instrument_id, instrument_name, bond_definition):\n",
    "    bond_instrument_request = {instrument_id: models.InstrumentDefinition(\n",
    "        # instrument display name\n",
    "        name=instrument_name,\n",
    "        # unique instrument identifier\n",
    "        identifiers={\"ClientInternal\": models.InstrumentIdValue(instrument_id)},\n",
    "        # our gilt instrument definition\n",
    "        definition=bond_definition\n",
    "    )}\n",
    "    return instruments_api.upsert_instruments(bond_instrument_request)\n",
    "\n",
    "instrument_creation_response = create_bond_instrument(\"gilt2047s\", \"gilt 1.5% 47s\", bond_instrument_definition)\n",
    "# retrieve the instrument id of our gilt to be used later when loading market quotes for the bond into LUSID.\n",
    "gilt_2047_luid = instrument_creation_response.values['gilt2047s'].lusid_instrument_id\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Defining the Bond Valuation\n",
    "\n",
    "Now that we have our bond instrument defined and upserted into LUSID we can move onto preparing to execute aggregations\n",
    "in LUSID to value our bond.\n",
    "\n",
    "Aggregations are configured in LUSID through the use of [Recipes](\"https://support.finbourne.com/what-is-a-lusid-recipe-and-how-is-it-used\").\n",
    "Configuration describes functions such as how to source market data for specific asset classes, which pricing models to use, and where to locate static values that may\n",
    "be used in the intermediate steps of the aggregation.\n",
    "\n",
    "We'll begin with a recipe that simply informs the aggregation engine of which model to use to price our bond. The model\n",
    "we'll use is LUSID's built-in \"Discounting\" model that prices our bond using an OIS yield curve. But before we can run our valuation\n",
    "we need to cover how we supply LUSID with our OIS yield curve in a format it can understand.\n",
    "\n",
    "### Complex Market Data <a id=\"complex_market_data\"></a>\n",
    "\n",
    "Complex Market Data expands on the simple uploading of market\n",
    "quotes by allowing you to supply more complex market data into LUSID in a structured format.\n",
    "\n",
    "In the case of our gilt we would like to price it using an OIS yield curve. The curve\n",
    "consists of a set of discount factors across the maturities of the OIS term structure. While we've\n",
    "specified the discount factors in this curve, lusid also supports building a curve from\n",
    "a set of instruments and corresponding quotes.\n",
    "\n",
    "Let's now load in the yield curves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GBP/GBPOIS yield curve uploaded into scope=FinbourneMarketData\n",
      "GBP/6M yield curve uploaded into scope=FinbourneMarketData\n"
     ]
    }
   ],
   "source": [
    "# scope used to store our market data\n",
    "market_data_scope = \"FinbourneMarketData\"\n",
    "# the market data supplier\n",
    "market_supplier = 'Lusid'\n",
    "\n",
    "def upsert_ois_yield_curve(scope, effective_at, market_asset):\n",
    "    # provide the structured data file source and it's document format\n",
    "    complex_market_data = models.DiscountFactorCurveData(\n",
    "        base_date=datetime(2020, 6, 2, tzinfo=pytz.utc),\n",
    "        dates = [datetime(2020, 6, 2, tzinfo=pytz.utc),datetime(2070, 6, 2, tzinfo=pytz.utc)],\n",
    "        discount_factors= [1.0, 0.969944204112752],\n",
    "        market_data_type=\"DiscountFactorCurveData\"\n",
    "    )\n",
    "\n",
    "    # create a unique identifier for our OIS yield curves\n",
    "    complex_id = models.ComplexMarketDataId(provider=\"Lusid\",price_source=None,\n",
    "                                            lineage=\"CurveVendorABC\",\n",
    "                                            effective_at=effective_at,\n",
    "                                            market_asset=market_asset)\n",
    "\n",
    "    upsert_request = models.UpsertComplexMarketDataRequest(market_data_id=complex_id,\n",
    "                                                              market_data=complex_market_data)\n",
    "\n",
    "    # https://www.lusid.com/docs/api#operation/UpsertComplexMarketData\n",
    "    response = complex_market_data_api.upsert_complex_market_data(\n",
    "        scope=scope,\n",
    "        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",
    "upsert_ois_yield_curve(market_data_scope, effective_at, \"GBP/GBPOIS\")\n",
    "upsert_ois_yield_curve(market_data_scope, effective_at, \"GBP/6M\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### What Bond Pricing Model To Use?\n",
    "To value our Gilt we need to tell LUSID how to answer the following questions - What bond pricing model to use? And where\n",
    "should LUSID source the market data to required to properly execute the model? To do so we define a Recipe that has two\n",
    "main constituents, the PricingContext and the MarketContext.\n",
    "\n",
    "We start with the PricingContext which is used to select the pricing model and add any additional parameters that configure the\n",
    "model behaviour. See the [Swagger spec](\"https://www.lusid.com/api/swagger/index.html\") under \"PricingContext\" for a detailed\n",
    "description of the parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_discounting_bond_pricing_context():\n",
    "    return models.PricingContext(\n",
    "        # select the \"Discounting\" model for bond pricing\n",
    "        model_rules=[\n",
    "            models.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"Discounting\",\n",
    "                instrument_type=\"Bond\",\n",
    "                parameters=\"{}\"\n",
    "            )\n",
    "        ]\n",
    "    )\n",
    "\n",
    "pricing_context = create_discounting_bond_pricing_context()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Where should Market Data be sourced?\n",
    "\n",
    "The MarketContext is how we inform LUSID where to retrieve market data for a given aggregation. In our case we need to\n",
    "tell LUSID where our OIS yield curve was stored. See the [Swagger spec](\"https://www.lusid.com/api/swagger/index.html#model-MarketContext\")\n",
    "under \"MarketContext\" for a detailed description of the parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_market_context():\n",
    "    return models.MarketContext(\n",
    "        # set rules for where we should resolve our rates data. In our case the OIS yield curves.\n",
    "        market_rules=[\n",
    "            models.MarketDataKeyRule(\n",
    "                key=\"Rates.*.*\",\n",
    "                data_scope=market_data_scope,\n",
    "                supplier=market_supplier,\n",
    "                quote_type='Rate',\n",
    "                field='Mid',\n",
    "                quote_interval='2D')\n",
    "        ],\n",
    "        # control default options for resolving market data. In our case simply default to the LUSID market_supplier\n",
    "        # and market data scope we defined earlier.\n",
    "        options=models.MarketOptions(\n",
    "            default_supplier=market_supplier,\n",
    "            default_scope=market_data_scope)\n",
    "    )\n",
    "\n",
    "    return market_context\n",
    "\n",
    "market_context = create_market_context()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Configure our Bond Pricing Recipe <a id=\"recipe_configuration\"></a>\n",
    "\n",
    "With our PricingContext and MarketContext defined we're now ready to configure our bond valuation recipe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_discount_bond_pricing_recipe(scope, market_context, pricing_context):\n",
    "\n",
    "    return models.ConfigurationRecipe(\n",
    "        scope=scope,\n",
    "        code=\"discounting-bond\",\n",
    "        description=\"Price bond using discounting model\",\n",
    "        market=market_context,\n",
    "        pricing=pricing_context\n",
    "    )\n",
    "\n",
    "discount_bond_pricing_config_recipe = create_discount_bond_pricing_recipe(scope, market_context, pricing_context)\n",
    "\n",
    "# Upsert recipe to LUSID\n",
    "upsert_recipe_request = models.UpsertRecipeRequest(configuration_recipe=discount_bond_pricing_config_recipe)\n",
    "response = api_factory.build(lusid.api.ConfigurationRecipeApi).upsert_configuration_recipe(upsert_recipe_request)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Pricing our Bond <a id=\"pricing_bond\"></a>\n",
    "\n",
    "Let's quickly summarise our current state:\n",
    " * We've defined a Gilt 1.5% 47s bond (including defining it's date conventions).\n",
    " * We've loaded the OIS yield curve into the Structure Market Data store.\n",
    " * We've setup our Recipe configuring of how we would like to price our bond and where to source our required market data.\n",
    "\n",
    "At this point we hold no position in the bond in our portfolio but would simply like to value it using our internal bond\n",
    "pricing model as defined in the recipe. LUSID offers the capability to run aggregations on non-existing positions through the\n",
    "use of inline portfolios. Inline portfolios are defined as a set of weighted instruments which can be used for example to define\n",
    "an Index. However in our simplified example we only have the one constituent which is our Gilt.\n",
    "\n",
    "### Run an Aggregation to Price our Bond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bond PV</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>1.399</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Name              Effective At  Value\n",
       "0  Bond PV 2020-06-23 00:00:00+00:00  1.399"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def run_bond_pricing_aggregation(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at):\n",
    "    # setup weighted instrument (only our gilt definition)\n",
    "    weighted_instrument_gilt = models.WeightedInstrument(quantity=1, instrument=bond_instrument_definition, holding_identifier=\"myholding_gilt\")\n",
    "    \n",
    "    # As we're running an inline valuation we must pass in our weighted instruments\n",
    "    inline_valuation_request = models.InlineValuationRequest(\n",
    "        recipe_id=models.ResourceId(\n",
    "            scope=discount_bond_pricing_config_recipe.scope,\n",
    "            code=discount_bond_pricing_config_recipe.code\n",
    "        ),\n",
    "        metrics=[\n",
    "            models.AggregateSpec(key='Valuation/PV', op='Value'),\n",
    "        ],\n",
    "        valuation_schedule=models.ValuationSchedule(\n",
    "            effective_at=effective_at.isoformat()\n",
    "        ),\n",
    "        instruments=[weighted_instrument_gilt]\n",
    "    )\n",
    "\n",
    "    # https://www.lusid.com/docs/api#operation/GetValuationOfWeightedInstruments\n",
    "    return api_factory.build(lusid.api.AggregationApi).get_valuation_of_weighted_instruments(\n",
    "        inline_valuation_request=inline_valuation_request)\n",
    "\n",
    "\n",
    "\n",
    "result = run_bond_pricing_aggregation(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at)\n",
    "bond_pv = result.data[0]['Valuation/PV']\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Bond PV', effective_at, bond_pv]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Pricing our Bond the Following Day\n",
    "\n",
    "We've now priced our Gilt using the LUSID internal bond \"Discounting\" model. As our recipe is already setup\n",
    "we can seamlessly revalue our bond for the following day:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bond PV</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>1.399</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bond PV</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>1.399</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Name              Effective At  Value\n",
       "0  Bond PV 2020-06-23 00:00:00+00:00  1.399\n",
       "1  Bond PV 2020-06-24 00:00:00+00:00  1.399"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "effective_at_t_plus_one = effective_at + timedelta(days=1)\n",
    "aggregation_result = run_bond_pricing_aggregation(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at_t_plus_one)\n",
    "bond_pv_at_t_plus_one = aggregation_result.data[0]['Valuation/PV']\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Bond PV', effective_at, bond_pv],\n",
    "    ['Bond PV', effective_at_t_plus_one, bond_pv_at_t_plus_one]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Accrued Interest <a id=\"accrued_interest\"></a>\n",
    "\n",
    "The above example shows our bond price changing from one day to the next using the Discounting model. This can be explained by the accrued\n",
    "interest on the Gilt. Recall that when we defined our gilt we set FlowConventions that contain all the information needed to calculate\n",
    "accrued interest between coupon dates.\n",
    "\n",
    "\n",
    "### Returning the Calculated Accrued Interest\n",
    "Note that the The 'Valuation/PV' aggregation firstly generates a price using the \"Discounting\" model before\n",
    "adding the calculated accrued interest and returning the PV. To get back the accrued interest that was calculated we simply need to update\n",
    "our aggregation request to include 'Holding/default/Accrual':\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bond PV</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>1.399</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bond PV</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>1.399</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Bond PV Dtd</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>0.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Accrued Interest</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>0.006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Accrued Interest</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>0.006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Accrued Interest Dtd</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>0.000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Name              Effective At  Value\n",
       "0               Bond PV 2020-06-23 00:00:00+00:00  1.399\n",
       "1               Bond PV 2020-06-24 00:00:00+00:00  1.399\n",
       "2           Bond PV Dtd 2020-06-24 00:00:00+00:00  0.000\n",
       "3      Accrued Interest 2020-06-23 00:00:00+00:00  0.006\n",
       "4      Accrued Interest 2020-06-24 00:00:00+00:00  0.006\n",
       "5  Accrued Interest Dtd 2020-06-24 00:00:00+00:00  0.000"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def run_bond_pricing_aggregation_and_accrued(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at):\n",
    "    weighted_instrument_gilt = models.WeightedInstrument(quantity=1, instrument=bond_instrument_definition, holding_identifier=\"myholding_gilt\")\n",
    "\n",
    "        # As we're running an inline valuation we must pass in our weighted instruments\n",
    "    inline_valuation_request = models.InlineValuationRequest(\n",
    "        recipe_id=models.ResourceId(\n",
    "            scope=discount_bond_pricing_config_recipe.scope,\n",
    "            code=discount_bond_pricing_config_recipe.code\n",
    "        ),\n",
    "        metrics=[\n",
    "            models.AggregateSpec(key='Valuation/PV', op='Value'),\n",
    "            # Ensure the calculated accrual is returned\n",
    "            models.AggregateSpec(key='Valuation/Accrued', op='Value')\n",
    "        ],\n",
    "        valuation_schedule=models.ValuationSchedule(\n",
    "            effective_at=effective_at.isoformat()\n",
    "        ),\n",
    "        instruments=[weighted_instrument_gilt]\n",
    "    )\n",
    "\n",
    "    # https://www.lusid.com/docs/api#operation/GetValuationOfWeightedInstruments\n",
    "    return api_factory.build(lusid.api.AggregationApi).get_valuation_of_weighted_instruments(\n",
    "        inline_valuation_request=inline_valuation_request)\n",
    "\n",
    "\n",
    "# bond pv and accrued interest at effective date\n",
    "aggregation_result = run_bond_pricing_aggregation_and_accrued(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at)\n",
    "bond_pv = aggregation_result.data[0]['Valuation/PV']\n",
    "accrued_interest = aggregation_result.data[0]['Valuation/Accrued']\n",
    "\n",
    "# bond pv and accrued interest day after\n",
    "aggregation_result = run_bond_pricing_aggregation_and_accrued(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at_t_plus_one)\n",
    "bond_pv_t_plus_one = aggregation_result.data[0]['Valuation/PV']\n",
    "accrued_interest_t_plus_one = aggregation_result.data[0]['Valuation/Accrued']\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Bond PV', effective_at, bond_pv],\n",
    "    ['Bond PV', effective_at_t_plus_one, bond_pv_t_plus_one],\n",
    "    ['Bond PV Dtd', effective_at_t_plus_one, bond_pv_t_plus_one-bond_pv],\n",
    "    ['Accrued Interest', effective_at, accrued_interest],\n",
    "    ['Accrued Interest', effective_at_t_plus_one, accrued_interest_t_plus_one],\n",
    "    ['Accrued Interest Dtd', effective_at_t_plus_one, accrued_interest_t_plus_one-accrued_interest]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a Bond Position to our Portfolio\n",
    "\n",
    "Now that we've covered how to define and price a bond instrument let's move onto adding a bond position to our portfolio.\n",
    "We'll then use the same recipe we defined to price the bond but this time use it to value our entire bond position within\n",
    "our portfolio. So we're using the same Recipe (i.e same Bond pricing model and data sources) but different aggregation parameters\n",
    "\n",
    "Brief summary of what we'll aim to do:\n",
    "* Create a portfolio to hold our Bond position.\n",
    "* Create a buy transaction on our holding. We'll also make use of the accrual calculation we just covered to help us\n",
    "setup a realistic transaction price and consideration for our test case.\n",
    "* Run an aggregation to calculate the value of our portfolio with the accrued interest. We'll also review how this aggregation\n",
    "on our portfolio differs to the the previous inline aggregation.\n",
    "\n",
    "### Setting up our Portfolio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>successful items</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>simple-bond-portfolio-01</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           successful items\n",
       "0  simple-bond-portfolio-01"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "portfolio = \"simple-bond-portfolio-01\"\n",
    "\n",
    "def create_portfolio(scope, portfolio_code, portfolio_name, portfolio_ccy):\n",
    "    pfs = [[portfolio_code, portfolio_name, portfolio_ccy]]\n",
    "    pf_df = pd.DataFrame(pfs, columns=['portfolio_code', 'portfolio_name', 'base_currency'])\n",
    "\n",
    "    portfolio_mapping = {\n",
    "        \"required\": {\n",
    "            \"code\": \"portfolio_code\",\n",
    "            \"display_name\": \"portfolio_name\",\n",
    "            \"base_currency\": \"base_currency\",\n",
    "        },\n",
    "        \"optional\": {\"created\": \"$2020-01-01T00:00:00+00:00\"},\n",
    "    }\n",
    "    result = load_from_data_frame(\n",
    "        api_factory=api_factory,\n",
    "        scope=scope,\n",
    "        data_frame=pf_df,\n",
    "        mapping_required=portfolio_mapping[\"required\"],\n",
    "        mapping_optional=portfolio_mapping[\"optional\"],\n",
    "        file_type=\"portfolios\",\n",
    "        sub_holding_keys=[],\n",
    "    )\n",
    "    succ, failed = format_portfolios_response(result)\n",
    "\n",
    "    if not failed.empty:\n",
    "        raise StopExecution(failed)\n",
    "\n",
    "    return succ\n",
    "\n",
    "create_portfolio(scope, portfolio, portfolio, \"GBP\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating our Transaction\n",
    "\n",
    "We now need to create and upsert our buy transaction. Earlier we priced the Present Value of our bond (approx 138.66) which\n",
    "included accrued interest of around 0.00062. For our example transaction let's set a market price of 137.00 and we're looking\n",
    "for a position size with a notional of 75,000,000. We'll use the accrued interest calculated by LUSID to come up with a dirty price\n",
    "and consideration for this particular example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# retrieve accrued interest\n",
    "aggregation_result = run_bond_pricing_aggregation_and_accrued(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at)\n",
    "bond_unit_pv = aggregation_result.data[0]['Valuation/PV']\n",
    "accrued_unit_interest = aggregation_result.data[0]['Valuation/Accrued']\n",
    "\n",
    "# setup our transaction\n",
    "notional = 75000000\n",
    "clean_price = 1.37\n",
    "dirty_price = clean_price + accrued_unit_interest\n",
    "consideration = notional * dirty_price\n",
    "\n",
    "def upsert_buy_transaction(scope, txn_id, instrument_id, trade_date, effective_at, portfolio, clean_price):\n",
    "    gilt_transaction_request = models.TransactionRequest(\n",
    "        transaction_id=txn_id,\n",
    "        type=\"Buy\",\n",
    "        instrument_identifiers={\"Instrument/default/ClientInternal\": instrument_id},\n",
    "        transaction_date=trade_date.isoformat(),\n",
    "        settlement_date=effective_at.isoformat(),\n",
    "        units=notional,\n",
    "        transaction_price=models.TransactionPrice(price=clean_price, type=\"Price\"),\n",
    "        total_consideration=models.CurrencyAndAmount(amount=consideration, currency=\"GBP\"),\n",
    "        exchange_rate=1,\n",
    "        transaction_currency=\"GBP\"\n",
    "    )\n",
    "\n",
    "    response = api_factory.build(lusid.api.TransactionPortfoliosApi).upsert_transactions(scope=scope,\n",
    "                                                                                         code=portfolio,\n",
    "                                                                                         transaction_request=[gilt_transaction_request])\n",
    "\n",
    "upsert_buy_transaction(scope, \"GiltTXN001\", \"gilt2047s\", trade_date, effective_at, portfolio, clean_price)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Valuing our Portfolio <a id=\"pricing_bond_portfolio\"></a>\n",
    "\n",
    "We're now ready to run our aggregation and value our bond portfolio. It's important to note that this is no longer an\n",
    "inline aggregation. This means the aggregation we're now running isn't only against the bond instrument definition, but instead\n",
    "is being run against a portfolio within a specific scope. For this reason we no longer require the use of a weighted instrument\n",
    "or the need to generate a specific inline aggregation request. Our request is simpler and only requires our recipe, portfolio and scope.\n",
    "\n",
    "### Run an Aggregation to Price our Portfolio With Bond Holdings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Portfolio PV inc Accrd Int</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,926,020.472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Portfolio Accrued Interest</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         Name              Effective At           Value\n",
       "0  Portfolio PV inc Accrd Int 2020-06-23 00:00:00+00:00 104,926,020.472\n",
       "1  Portfolio Accrued Interest 2020-06-23 00:00:00+00:00     472,870.879"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def run_bond_pricing_aggregation_on_portfolio(scope, portfolio, recipe, effective_at):\n",
    "    valuation_request = models.ValuationRequest(\n",
    "        recipe_id=models.ResourceId(\n",
    "            scope=recipe.scope,\n",
    "            code=recipe.code\n",
    "        ),\n",
    "          metrics=[\n",
    "            models.AggregateSpec(key='Valuation/PV', op='Value'),\n",
    "            models.AggregateSpec(key='Valuation/Accrued', op='Value'),\n",
    "            models.AggregateSpec(key='Valuation/InstrumentAccrued', op='Value')\n",
    "\n",
    "        ],\n",
    "        valuation_schedule=models.ValuationSchedule(effective_at=effective_at.isoformat()),\n",
    "        portfolio_entity_ids=[\n",
    "            models.PortfolioEntityId(\n",
    "                scope=scope,\n",
    "                code=portfolio\n",
    "            )\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    return api_factory.build(lusid.api.AggregationApi).get_valuation(valuation_request=valuation_request)\n",
    "\n",
    "\n",
    "\n",
    "results = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, discount_bond_pricing_config_recipe, effective_at)\n",
    "bond_pv = results.data[0]['Valuation/PV']\n",
    "accrued_interest = results.data[0]['Valuation/Accrued']\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Portfolio PV inc Accrd Int', effective_at, bond_pv],\n",
    "    ['Portfolio Accrued Interest', effective_at, accrued_interest]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pricing our Bond the Following Day\n",
    "\n",
    "As in our previous example let's move forward a day to view the change in our Portfolio PV and Accrued Interest:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Portfolio PV inc Accrd Int</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,926,020.472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Portfolio PV inc Accrd Int</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>104,929,285.678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Portfolio PV inc Accrd Int Dtd</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>3,265.206</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Portfolio Accrued Interest</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Portfolio Accrued Interest</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>475,961.538</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Portfolio Accrued Interest Dtd</td>\n",
       "      <td>2020-06-24 00:00:00+00:00</td>\n",
       "      <td>3,090.659</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             Name              Effective At           Value\n",
       "0      Portfolio PV inc Accrd Int 2020-06-23 00:00:00+00:00 104,926,020.472\n",
       "1      Portfolio PV inc Accrd Int 2020-06-24 00:00:00+00:00 104,929,285.678\n",
       "2  Portfolio PV inc Accrd Int Dtd 2020-06-24 00:00:00+00:00       3,265.206\n",
       "3      Portfolio Accrued Interest 2020-06-23 00:00:00+00:00     472,870.879\n",
       "4      Portfolio Accrued Interest 2020-06-24 00:00:00+00:00     475,961.538\n",
       "5  Portfolio Accrued Interest Dtd 2020-06-24 00:00:00+00:00       3,090.659"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "effective_at_plus_one = effective_at + timedelta(days=1)\n",
    "results = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, discount_bond_pricing_config_recipe, effective_at_plus_one)\n",
    "bond_pv_t_plus_one = results.data[0]['Valuation/PV']\n",
    "accrued_interest_t_plus_one = results.data[0]['Valuation/Accrued']\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Portfolio PV inc Accrd Int', effective_at, bond_pv],\n",
    "    ['Portfolio PV inc Accrd Int', effective_at_t_plus_one, bond_pv_t_plus_one],\n",
    "    ['Portfolio PV inc Accrd Int Dtd', effective_at_t_plus_one, bond_pv_t_plus_one - bond_pv],\n",
    "    ['Portfolio Accrued Interest', effective_at, accrued_interest],\n",
    "    ['Portfolio Accrued Interest', effective_at_t_plus_one, accrued_interest_t_plus_one],\n",
    "    ['Portfolio Accrued Interest Dtd', effective_at_t_plus_one, accrued_interest_t_plus_one - accrued_interest]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Accrual Overrides <a id=\"accrual_override\"></a>\n",
    "\n",
    "So far we've relied on LUSID to run it's internal bond pricing model as well as calculate accruals based on the\n",
    "conventions we defined in the Gilt instrument definition. However you may need to use a different value for accrued interest - one\n",
    "that has been calculated externally for example. To do so we need to address two concerns. How do we load a one off accrual\n",
    "into LUSID? And how do we ensure LUSID uses that accrual during aggregation as oppose to reverting to calculating it\n",
    "on the fly as in the previous examples.\n",
    "\n",
    "### Structured Result Data <a id=\"structured_result_data\"></a>\n",
    "\n",
    "The [Structured Result Store](\"https://support.finbourne.com/how-do-i-store-and-retrieve-structured-market-data-documents\") is\n",
    "a location to store non quote data that may nevertheless be used in an aggregation. Examples include YTD performance on\n",
    "an Index, sensitivities of a Swap, or in our case the accrued interest on a bond between coupon dates.\n",
    "\n",
    "Just as with we did with our OIS yield curves in the Structured Market Data store we need to ensure that the Results we\n",
    "upsert can be resolved by LUSID during an aggregation. To do so all entries into the Result store must be defined with a\n",
    "corresponding key that uniquely identifies what the value relates to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upserted accrual result GiltAccrual.\n"
     ]
    }
   ],
   "source": [
    "result_data_scope = \"Finbourne-Examples\"\n",
    "accrual_result_id = \"GiltAccrual\"\n",
    "\n",
    "def upsert_structured_result_data_overrides(effective_at, accrual_result_id, instrument_id):\n",
    "    # mock an entry from  a csv file\n",
    "    accrual_document = \"LusidInstrumentId,Accrual,AccrualCcy\" + \"\\r\\n\" + f\"{instrument_id},0.069109979,GBP\"\n",
    "\n",
    "    data_map_key = models.DataMapKey(\n",
    "        code = \"sample-data-map\",\n",
    "        version = \"1.0.1\"\n",
    "    )\n",
    "    \n",
    "    try:\n",
    "        structured_result_data_api.create_data_map(\n",
    "            scope = result_data_scope,\n",
    "            request_body = {\n",
    "                \"data-map\": models.CreateDataMapRequest(\n",
    "                    id=data_map_key,\n",
    "                    data=models.DataMapping(\n",
    "                        data_definitions=[\n",
    "                            models.DataDefinition(address=\"UnitResult/LusidInstrumentId\", name=\"LusidInstrumentId\", data_type=\"String\", key_type=\"Unique\"),\n",
    "                            models.DataDefinition(address=\"UnitResult/Valuation/InstrumentAccrued\", data_type=\"Result0D\", key_type=\"CompositeLeaf\"),\n",
    "                            models.DataDefinition(address=\"UnitResult/Valuation/InstrumentAccrued/Amount\", name=\"Accrual\", data_type=\"Decimal\", key_type=\"Leaf\"),\n",
    "                            models.DataDefinition(address=\"UnitResult/Valuation/InstrumentAccrued/Ccy\", name=\"AccrualCcy\", data_type=\"String\", key_type=\"Leaf\"),\n",
    "                        ]\n",
    "                    )\n",
    "                )\n",
    "            }\n",
    "        )\n",
    "    except:\n",
    "        print(\"DataMaps are immutable - a datamap under this key already exists\")\n",
    "    \n",
    "    # create the result data object from our loaded csv file and definition of the format\n",
    "    accrual_result = models.StructuredResultData(\n",
    "        document_format=\"CSV\",\n",
    "        version=\"1.0.0\",\n",
    "        name=\"IRS accrual\",\n",
    "        document=accrual_document,\n",
    "        data_map_key=data_map_key\n",
    "    )\n",
    "    \n",
    "    # create a unique identifier for our accrual to ensure it can be properly resolved during aggregation\n",
    "    accrual_result_id = models.StructuredResultDataId(\n",
    "        source=\"Client\",\n",
    "        code=accrual_result_id,\n",
    "        effective_at=effective_at.isoformat(),\n",
    "        result_type=\"UnitResult/Analytic\"\n",
    "    )\n",
    "\n",
    "    # create structured request\n",
    "    structured_request = models.UpsertStructuredResultDataRequest(\n",
    "        id=accrual_result_id,\n",
    "        data=accrual_result\n",
    "    )\n",
    "\n",
    "    # https://www.lusid.com/docs/api#operation/UpsertStructuredResultData\n",
    "    response = structured_result_data_api.upsert_structured_result_data(\n",
    "        scope=result_data_scope,\n",
    "        request_body={\"AccrualOR1\": structured_request}\n",
    "    )\n",
    "    if response.failed:\n",
    "        raise StopExecution(f\"Failed to upsert result data: {response.failed}\")\n",
    "\n",
    "    print(f\"Upserted accrual result {accrual_result_id.code}.\")\n",
    "\n",
    "upsert_structured_result_data_overrides(effective_at, accrual_result_id, gilt_2047_luid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Setting Up Our Result Data Rule\n",
    "\n",
    "Now that the accrual override is in LUSID we need to address our second concern of notifying the aggregation to override the\n",
    "accrual calculation with our value when required. We can achieve this via the use of a \"Result Data Rule\". These rules\n",
    "rely on a pattern that when matched signals to the aggregation process that the stored result data should be used over any\n",
    "calculated value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_accrual_result_data_rule(result_data_scope, accrual_result_id):\n",
    "    accrual_key_rule = models.ResultDataKeyRule(\n",
    "        # identifies which patterns of results this rule should be applied for.\n",
    "        resource_key=\"UnitResult/Valuation/InstrumentAccrued\",\n",
    "        supplier=\"Client\",\n",
    "        data_scope=result_data_scope,\n",
    "        document_code=accrual_result_id,\n",
    "        document_result_type=\"UnitResult/Analytic\",\n",
    "        result_key_rule_type=\"ResultDataKeyRule\"\n",
    "    )\n",
    "\n",
    "    return accrual_key_rule\n",
    "\n",
    "\n",
    "accrual_key_rule = create_accrual_result_data_rule(result_data_scope, accrual_result_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Applying our Result Data Rule to a Recipe via PricingContext\n",
    "\n",
    "With the rule created we now need to instruct LUSID to apply this rule. To do so we simply add our rule to a an updated PricingContext definition\n",
    "(which you recall tells LUSID what models to use for the aggregation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_discounting_bond_pricing_context_with_accrual_override(accrual_key_rule):\n",
    "    return models.PricingContext(\n",
    "        model_rules=[\n",
    "            models.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"Discounting\",\n",
    "                instrument_type=\"Bond\",\n",
    "                parameters=\"{}\"\n",
    "            )\n",
    "        ],\n",
    "        result_data_rules=[accrual_key_rule]\n",
    "    )\n",
    "\n",
    "accrual_override_pricing_context = create_discounting_bond_pricing_context_with_accrual_override(accrual_key_rule)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Creating a new Recipe with our Accrual Override Rule\n",
    "\n",
    "As we've updated the pricing context we need to generate a new recipe for our portfolio valuation :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "def create_bond_pricing_recipe_with_accrual_override(scope, market_context, pricing_context):\n",
    "\n",
    "    return models.ConfigurationRecipe(\n",
    "        scope=scope,\n",
    "        code=\"discounting-bond-acc-override\",\n",
    "        description=\"Price bond using discounting model but override accruals\",\n",
    "        market=market_context,\n",
    "        pricing=pricing_context\n",
    "    )\n",
    "\n",
    "accrual_override_config_recipe = create_bond_pricing_recipe_with_accrual_override(scope, market_context, accrual_override_pricing_context)\n",
    "\n",
    "# Upsert recipe to LUSID\n",
    "upsert_recipe_request = models.UpsertRecipeRequest(configuration_recipe=accrual_override_config_recipe)\n",
    "response = api_factory.build(lusid.api.ConfigurationRecipeApi).upsert_configuration_recipe(upsert_recipe_request)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Price our Portfolio using the Accrual Override\n",
    "\n",
    "Let's rerun the portfolio aggregation but this time with our accrual override and compare the results to running without an override"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Portfolio PV inc Accrd Int (With Override)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>109,636,398.018</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Portfolio PV inc Accrd Int (No Override)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,926,020.472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Portfolio Accrued Interest  (With Override)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>5,183,248.425</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Portfolio Accrued Interest (No Override)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                          Name              Effective At  \\\n",
       "0   Portfolio PV inc Accrd Int (With Override) 2020-06-23 00:00:00+00:00   \n",
       "1     Portfolio PV inc Accrd Int (No Override) 2020-06-23 00:00:00+00:00   \n",
       "2  Portfolio Accrued Interest  (With Override) 2020-06-23 00:00:00+00:00   \n",
       "3     Portfolio Accrued Interest (No Override) 2020-06-23 00:00:00+00:00   \n",
       "\n",
       "            Value  \n",
       "0 109,636,398.018  \n",
       "1 104,926,020.472  \n",
       "2   5,183,248.425  \n",
       "3     472,870.879  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# run the aggregation with an accrual override (using accrual override recipe)\n",
    "results_with_override = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, accrual_override_config_recipe, effective_at)\n",
    "portfolio_pv_with_override = results_with_override.data[0]['Valuation/PV']\n",
    "accrued_interest_with_override = results_with_override.data[0]['Valuation/Accrued']\n",
    "\n",
    "# and now run without an override (using previously configured recipe).\n",
    "results_no_override = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, discount_bond_pricing_config_recipe, effective_at)\n",
    "portfolio_pv_no_override = results_no_override.data[0]['Valuation/PV']\n",
    "accrued_interest_no_override = results_no_override.data[0]['Valuation/Accrued']\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Portfolio PV inc Accrd Int (With Override)', effective_at, portfolio_pv_with_override],\n",
    "    ['Portfolio PV inc Accrd Int (No Override)', effective_at, portfolio_pv_no_override],\n",
    "    ['Portfolio Accrued Interest  (With Override)', effective_at, accrued_interest_with_override],\n",
    "    ['Portfolio Accrued Interest (No Override)', effective_at, accrued_interest_no_override],\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Bond Price Override <a id=\"external_bond_price\"></a>\n",
    "\n",
    "Up until now we have priced our bond portfolio using LUSID's internal \"Discounting\" model. We'll now take a different approach and\n",
    "upsert the market price of the Gilt into LUSID as a quote. Continuing with our previous example where we processed a transaction at a clean price of 137.00,\n",
    "now assume the market price of the bond has dropped to 135.00\n",
    "\n",
    "\n",
    "### Load our Gilt Market Price into LUSID\n",
    "Let's firstly upsert the latest market price as a quote into LUSID ensuring we map it to our specific Gilt via the instrument identifier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gilt 20147 @1.35 uploaded into Quote store.\n"
     ]
    }
   ],
   "source": [
    "def upsert_external_bond_price_as_quote(bond_price):\n",
    "    spot_quote = models.UpsertQuoteRequest(\n",
    "        quote_id=models.QuoteId(\n",
    "            quote_series_id=models.QuoteSeriesId(\n",
    "                provider=market_supplier,\n",
    "                instrument_id=gilt_2047_luid,\n",
    "                instrument_id_type='LusidInstrumentId',\n",
    "                quote_type='Price',\n",
    "                field='Mid'),\n",
    "            effective_at=effective_at,\n",
    "        ),\n",
    "        metric_value=models.MetricValue(\n",
    "            value=bond_price,\n",
    "            unit='GBP'),\n",
    "        lineage='InternalSystem')\n",
    "\n",
    "    response = api_factory.build(lusid.api.QuotesApi).upsert_quotes(\n",
    "        scope=market_data_scope,\n",
    "        request_body={\"1\": spot_quote})\n",
    "\n",
    "    if response.failed:\n",
    "        raise StopExecution(f\"Failed to upload yield curve:{response.failed}\")\n",
    "\n",
    "    print(f\"Gilt 20147 @{bond_price} uploaded into Quote store.\")\n",
    "\n",
    "upsert_external_bond_price_as_quote(1.35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Add a Market Rule to help LUSID resolve our Gilt Price\n",
    "\n",
    "As we now want to run a portfolio valuation using a different pricing model for bonds we need a new recipe. Recall the two key components of the recipe\n",
    "are the MaketContext and PricingContext. As we now have a new source of Market data, the quote we've inserted, we need to inform LUSID of where to locate it\n",
    "during an aggregation. So in addition to the Rate rule we had in our precious MarketContext definition we add a new market rule for \"Price\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_static_bond_pricing_market_context():\n",
    "    return models.MarketContext(\n",
    "        market_rules=[\n",
    "            # additional rule to resolve our quote\n",
    "            models.MarketDataKeyRule(\n",
    "                key='Quote.LusidInstrumentId.*',\n",
    "                supplier=market_supplier,\n",
    "                data_scope=market_data_scope,\n",
    "                quote_type='Price',\n",
    "                field='Mid'),\n",
    "            models.MarketDataKeyRule(\n",
    "                key=\"Rates.*.*\",\n",
    "                data_scope=market_data_scope,\n",
    "                supplier=market_supplier,\n",
    "                quote_type='Rate',\n",
    "                field='Mid')\n",
    "        ],\n",
    "        options=models.MarketOptions(\n",
    "            default_supplier=market_supplier,\n",
    "            default_scope=market_data_scope)\n",
    "    )\n",
    "\n",
    "    return market_context\n",
    "\n",
    "static_bond_pricing_market_context = create_static_bond_pricing_market_context()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Update the Bond Pricing Model used in the Aggregation\n",
    "\n",
    "We need to instruct LUSID that we would like to used the quoted price of the bond and not use\n",
    "the \"Discounting\" model. So we create a new PricingContext that uses a \"SimpleStatic\" model. To calculate PV of our bond\n",
    "this model simply retrieves the market price and then adds the accrued interest (which itself could either be calculated or loaded\n",
    "from the Structured Result Store as we covered earlier)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_static_bond_pricing_context():\n",
    "    return models.PricingContext(\n",
    "        # the default behaviour does not allow looking up data for pricing instruments so we must allow it.\n",
    "        options=models.PricingOptions(\n",
    "            allow_any_instruments_with_sec_uid_to_price_off_lookup=True\n",
    "        ),\n",
    "        model_rules=[\n",
    "            models.VendorModelRule(\n",
    "                supplier=\"Lusid\",\n",
    "                model_name=\"SimpleStatic\",\n",
    "                instrument_type=\"Bond\",\n",
    "                parameters=\"{}\"\n",
    "            )\n",
    "        ]\n",
    "    )\n",
    "\n",
    "static_bond_pricing_context = create_static_bond_pricing_context()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a new Recipe with our new Market Rules and Bond Pricing Model\n",
    "\n",
    "With our updated Market and Pricing Contexts we can now generate a new recipe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_static_bond_pricing_recipe(scope, market_context, pricing_context):\n",
    "\n",
    "    return models.ConfigurationRecipe(\n",
    "        scope=scope,\n",
    "        code=\"static-bond\",\n",
    "        description=\"Price bond using prices from the quote store.\",\n",
    "        market=market_context,\n",
    "        pricing=pricing_context\n",
    "    )\n",
    "\n",
    "static_bond_price_config_recipe = create_static_bond_pricing_recipe(scope, static_bond_pricing_market_context, static_bond_pricing_context)\n",
    "\n",
    "# Upsert recipe to LUSID\n",
    "upsert_recipe_request = models.UpsertRecipeRequest(configuration_recipe=static_bond_price_config_recipe)\n",
    "response = api_factory.build(lusid.api.ConfigurationRecipeApi).upsert_configuration_recipe(upsert_recipe_request)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run Aggregations to Price our Portfolio using Static and Discounting Bond Pricing Models\n",
    "\n",
    "Let's rerun our portfolio valuation using our static bond price model and compare the results to the valuations using our discounting model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Portfolio PV inc Accrd Int (Static Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>101,722,870.879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Portfolio PV inc Accrd Int (Discounting Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,926,020.472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Portfolio Accrued Interest  (Static Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Portfolio Accrued Interest (Discounting Mode)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             Name              Effective At  \\\n",
       "0       Portfolio PV inc Accrd Int (Static Model) 2020-06-23 00:00:00+00:00   \n",
       "1  Portfolio PV inc Accrd Int (Discounting Model) 2020-06-23 00:00:00+00:00   \n",
       "2      Portfolio Accrued Interest  (Static Model) 2020-06-23 00:00:00+00:00   \n",
       "3   Portfolio Accrued Interest (Discounting Mode) 2020-06-23 00:00:00+00:00   \n",
       "\n",
       "            Value  \n",
       "0 101,722,870.879  \n",
       "1 104,926,020.472  \n",
       "2     472,870.879  \n",
       "3     472,870.879  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_using_static_price = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, static_bond_price_config_recipe, effective_at)\n",
    "portfolio_pv_with_static_price = results_using_static_price.data[0]['Valuation/PV']\n",
    "accrued_interest_with_static_price = results_using_static_price.data[0]['Valuation/Accrued']\n",
    "\n",
    "results_using_discounting = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, discount_bond_pricing_config_recipe, effective_at)\n",
    "portfolio_pv_with_discounting = results_using_discounting.data[0]['Valuation/PV']\n",
    "accrued_interest_with_discounting = results_using_discounting.data[0]['Valuation/Accrued']\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Portfolio PV inc Accrd Int (Static Model)', effective_at, portfolio_pv_with_static_price],\n",
    "    ['Portfolio PV inc Accrd Int (Discounting Model)', effective_at, portfolio_pv_with_discounting],\n",
    "    ['Portfolio Accrued Interest  (Static Model)', effective_at, accrued_interest_with_static_price],\n",
    "    ['Portfolio Accrued Interest (Discounting Mode)', effective_at, accrued_interest_with_discounting],\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Revalue Portfolio with an Increased Gilt Price\n",
    "\n",
    "Update the market price of the bond to 139.00"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gilt 20147 @1.39 uploaded into Quote store.\n"
     ]
    },
    {
     "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Portfolio PV inc Accrd Int (Static Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,722,870.879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Portfolio PV inc Accrd Int (Discounting Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,926,020.472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Portfolio Accrued Interest  (Static Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Portfolio Accrued Interest (Discounting Mode)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             Name              Effective At  \\\n",
       "0       Portfolio PV inc Accrd Int (Static Model) 2020-06-23 00:00:00+00:00   \n",
       "1  Portfolio PV inc Accrd Int (Discounting Model) 2020-06-23 00:00:00+00:00   \n",
       "2      Portfolio Accrued Interest  (Static Model) 2020-06-23 00:00:00+00:00   \n",
       "3   Portfolio Accrued Interest (Discounting Mode) 2020-06-23 00:00:00+00:00   \n",
       "\n",
       "            Value  \n",
       "0 104,722,870.879  \n",
       "1 104,926,020.472  \n",
       "2     472,870.879  \n",
       "3     472,870.879  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "upsert_external_bond_price_as_quote(1.39)\n",
    "\n",
    "results_using_static_price = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, static_bond_price_config_recipe, effective_at)\n",
    "portfolio_pv_with_static_price = results_using_static_price.data[0]['Valuation/PV']\n",
    "accrued_interest_with_static_price = results_using_static_price.data[0]['Valuation/Accrued']\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Portfolio PV inc Accrd Int (Static Model)', effective_at, portfolio_pv_with_static_price],\n",
    "    ['Portfolio PV inc Accrd Int (Discounting Model)', effective_at, portfolio_pv_with_discounting],\n",
    "    ['Portfolio Accrued Interest  (Static Model)', effective_at, accrued_interest_with_static_price],\n",
    "    ['Portfolio Accrued Interest (Discounting Mode)', effective_at, accrued_interest_with_discounting],\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Revalue Portfolio with the same Clean Gilt Price\n",
    "\n",
    "Finally let's update the market price to equal the clean price as per the \"Discounting\" model. In this case we arrive at\n",
    "the same portfolio PV using two different bond pricing models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gilt 20147 @1.3927086612381778 uploaded into Quote store.\n"
     ]
    },
    {
     "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>Name</th>\n",
       "      <th>Effective At</th>\n",
       "      <th>Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Portfolio PV inc Accrd Int (Static Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,926,020.472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Portfolio PV inc Accrd Int (Discounting Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>104,926,020.472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Portfolio Accrued Interest  (Static Model)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Portfolio Accrued Interest (Discounting Mode)</td>\n",
       "      <td>2020-06-23 00:00:00+00:00</td>\n",
       "      <td>472,870.879</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             Name              Effective At  \\\n",
       "0       Portfolio PV inc Accrd Int (Static Model) 2020-06-23 00:00:00+00:00   \n",
       "1  Portfolio PV inc Accrd Int (Discounting Model) 2020-06-23 00:00:00+00:00   \n",
       "2      Portfolio Accrued Interest  (Static Model) 2020-06-23 00:00:00+00:00   \n",
       "3   Portfolio Accrued Interest (Discounting Mode) 2020-06-23 00:00:00+00:00   \n",
       "\n",
       "            Value  \n",
       "0 104,926,020.472  \n",
       "1 104,926,020.472  \n",
       "2     472,870.879  \n",
       "3     472,870.879  "
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# retrieve unit pv and accrued interest\n",
    "aggregation_result = run_bond_pricing_aggregation_and_accrued(bond_instrument_definition, discount_bond_pricing_config_recipe, effective_at)\n",
    "clean_as_per_disc_model = aggregation_result.data[0]['Valuation/PV'] - aggregation_result.data[0]['Valuation/Accrued']\n",
    "upsert_external_bond_price_as_quote(clean_as_per_disc_model)\n",
    "\n",
    "results_using_static_price = run_bond_pricing_aggregation_on_portfolio(scope, portfolio, static_bond_price_config_recipe, effective_at)\n",
    "portfolio_pv_with_static_price = results_using_static_price.data[0]['Valuation/PV']\n",
    "accrued_interest_with_static_price = results_using_static_price.data[0]['Valuation/Accrued']\n",
    "\n",
    "\n",
    "aggregation_result_to_dataframe([\n",
    "    ['Portfolio PV inc Accrd Int (Static Model)', effective_at, portfolio_pv_with_static_price],\n",
    "    ['Portfolio PV inc Accrd Int (Discounting Model)', effective_at, portfolio_pv_with_discounting],\n",
    "    ['Portfolio Accrued Interest  (Static Model)', effective_at, accrued_interest_with_static_price],\n",
    "    ['Portfolio Accrued Interest (Discounting Mode)', effective_at, accrued_interest_with_discounting],\n",
    "])"
   ]
  }
 ],
 "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": "e7952dbddf951868ba3c79448c1a6e602b7156b1e41e03fa768a9c7d55ad683d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}