examples/use-cases/instruments/FX Forward.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n    <form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Toggle Docstring\"></form>\n    \n         <script>\n         function code_toggle() {\n             if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){\n                 $('div.cell.code_cell.rendered.selected div.input').hide();\n             } else {\n                 $('div.cell.code_cell.rendered.selected div.input').show();\n             }\n         }\n         </script>\n\n     "
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from lusidtools.jupyter_tools import toggle_code\n",
    "\n",
    "\"\"\"FX Forward - Valuation Workflow\n",
    "\n",
    "Attributes\n",
    "----------\n",
    "FX Forwards\n",
    "complex market data\n",
    "recipes\n",
    "valuations\n",
    "\"\"\"\n",
    "\n",
    "toggle_code(\"Toggle Docstring\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:04.757810Z",
     "start_time": "2024-03-18T18:02:04.754769Z"
    }
   },
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Booking and valuing an FX Forward\n",
    "\n",
    "In this notebook, we demonstrate how an FX Forward can be booked in LUSID, and extend it to use cases such as running a standard valuation and calculating PnL.\n",
    "\n",
    "**Table of Contents:**\n",
    "- [1. Create Portfolio](#1.-Create-Portfolio)\n",
    "- [2. Create Instrument](#2.-Create-Instrument)\n",
    "- [3. Upsert Transactions](#3.-Upsert-Transactions)\n",
    "- [4. Upsert FX Market Data](#4.-Upsert-FX-Market-Data)\n",
    "- [5. Create Configuration Recipe](#5.-Create-Configuration-Recipe)\n",
    "- [6. Valuation](#6.-Valuation)\n",
    "- [7. Instrument Life Cycle](#7.-Instrument-Life-Cycle)"
   ]
  },
  {
   "cell_type": "code",
   "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.12757.0\n"
     ]
    }
   ],
   "source": [
    "# Import generic non-LUSID packages\n",
    "import os\n",
    "import pandas as pd\n",
    "from datetime import datetime, timedelta\n",
    "import re\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import pytz\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",
    "from lusidtools.pandas_utils.lusid_pandas import lusid_response_to_data_frame\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(\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)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.236917Z",
     "start_time": "2024-03-18T18:02:04.951361Z"
    }
   },
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "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",
    "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)\n",
    "transaction_configuration_api = api_factory.build(lusid.api.TransactionConfigurationApi)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.240214Z",
     "start_time": "2024-03-18T18:02:06.237792Z"
    }
   },
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "# Define scopes\n",
    "scope = \"fx-forward-notebook-example\""
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.242655Z",
     "start_time": "2024-03-18T18:02:06.240960Z"
    }
   },
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "# Define a method to produce numeric axes\n",
    "def create_curve_axes(spot, rates, tenors, is_pips=False, return_pips=False):\n",
    "\n",
    "    # Process pips - note that pips are 1 hundredth of a %\n",
    "    if is_pips:\n",
    "        rates = [spot + i/10000 for i in rates]\n",
    "\n",
    "    # Convert tenors\n",
    "    tenors_in_days = []\n",
    "    conv_factors = {\n",
    "        \"D\": 1,\n",
    "        \"M\": 30,\n",
    "        \"W\": 7,\n",
    "        \"Y\": 365\n",
    "    }\n",
    "    for tenor in tenors:\n",
    "        temp = re.split('(\\d+)',tenor)\n",
    "        tenors_in_days.append(int(temp[1]) * conv_factors[temp[2]])\n",
    "\n",
    "    # Return either pips or outrights\n",
    "    if return_pips:\n",
    "        return tenors_in_days, rates\n",
    "\n",
    "    else:\n",
    "        # Initiate x, y arrays for spot\n",
    "        int_rates = [spot]\n",
    "        int_tenors = [0]\n",
    "\n",
    "        # Add numeric tenors and rates\n",
    "        int_rates.extend(rates)\n",
    "        int_tenors.extend(tenors_in_days)\n",
    "\n",
    "        return int_tenors, int_rates"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.247232Z",
     "start_time": "2024-03-18T18:02:06.243863Z"
    }
   },
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Add required transaction configuration"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "default_side_definitions = [\n",
    "    lm.SidesDefinitionRequest(\n",
    "        side=\"Side1\",\n",
    "        side_request=lm.SideDefinitionRequest(\n",
    "            security=\"Txn:LusidInstrumentId\",\n",
    "            currency=\"Txn:TradeCurrency\",\n",
    "            rate=\"Txn:TradeToPortfolioRate\",\n",
    "            units=\"Txn:Units\",\n",
    "            amount=\"Txn:TradeAmount\")),\n",
    "    lm.SidesDefinitionRequest(\n",
    "        side=\"Side2\",\n",
    "        side_request=lm.SideDefinitionRequest(\n",
    "            security=\"Txn:SettleCcy\",\n",
    "            currency=\"Txn:SettlementCurrency\",\n",
    "            rate=\"SettledToPortfolioRate\",\n",
    "            units=\"Txn:TotalConsideration\",\n",
    "            amount=\"Txn:TotalConsideration\"))\n",
    "]\n",
    "\n",
    "transaction_configuration_api.set_side_definitions(default_side_definitions, scope = scope)\n",
    "\n",
    "# construct the transaction type requests\n",
    "transaction_type_requests = [\n",
    "     lm.TransactionTypeRequest(\n",
    "        aliases=[\n",
    "            lm.TransactionTypeAlias(\n",
    "                type=\"StockIn\",\n",
    "                description=\"Transfer In\",\n",
    "                transaction_class=\"StockTransfers\",\n",
    "                transaction_roles=\"Longer\",\n",
    "            )\n",
    "        ],\n",
    "        movements=[\n",
    "            lm.TransactionTypeMovement(\n",
    "                movement_types=\"StockMovement\",\n",
    "                side=\"Side1\",\n",
    "                direction=1,\n",
    "                properties=None,\n",
    "                mappings=[],\n",
    "            )\n",
    "        ],\n",
    "        properties=None,\n",
    "    ),\n",
    "    lm.TransactionTypeRequest(\n",
    "        aliases=[\n",
    "            lm.TransactionTypeAlias(\n",
    "                type= \"StockOut\",\n",
    "                description=\"Transfer Out\",\n",
    "                transaction_class=\"StockTransfers\",\n",
    "                transaction_roles=\"Shorter\",\n",
    "            )\n",
    "        ],\n",
    "        movements=[\n",
    "            lm.TransactionTypeMovement(\n",
    "                movement_types=\"StockMovement\",\n",
    "                side=\"Side1\",\n",
    "                direction=-1,\n",
    "                properties=None,\n",
    "                mappings=[],\n",
    "            )\n",
    "        ],\n",
    "        properties=None,\n",
    "    ),\n",
    "    lm.TransactionTypeRequest(\n",
    "        aliases=[\n",
    "            lm.TransactionTypeAlias(\n",
    "                type= \"Sell\",\n",
    "                description=\"Sale\",\n",
    "                transaction_class=\"Basic\",\n",
    "                transaction_roles=\"LongShorter\",\n",
    "            )\n",
    "        ],\n",
    "        movements=[\n",
    "            lm.TransactionTypeMovement(\n",
    "                movement_types=\"StockMovement\",\n",
    "                side=\"Side1\",\n",
    "                direction=-1,\n",
    "                properties=None,\n",
    "                mappings=[],\n",
    "            ),lm.TransactionTypeMovement(\n",
    "                movement_types=\"CashCommitment\",\n",
    "                side=\"Side2\",\n",
    "                direction=1,\n",
    "                properties=None,\n",
    "                mappings=[],\n",
    "            )\n",
    "        ],\n",
    "        properties=None,\n",
    "    ),\n",
    "  lm.TransactionTypeRequest(\n",
    "    aliases=[\n",
    "        lm.TransactionTypeAlias(\n",
    "            type= \"Principal\",\n",
    "            description=\"all\",\n",
    "            transaction_class=\"default\",\n",
    "            transaction_roles=\"AllRoles\",\n",
    "            is_default = False\n",
    "        )\n",
    "    ],\n",
    "    movements=[\n",
    "        lm.TransactionTypeMovement(\n",
    "            movement_types=\"CashCommitment\",\n",
    "            side=\"Side2\",\n",
    "            direction=1,\n",
    "            properties=None,\n",
    "            mappings=[],\n",
    "        )\n",
    "    ],\n",
    "     properties = {\n",
    "        \"TransactionConfiguration/default/CashFlowType\":\n",
    "            lm.PerpetualProperty(\n",
    "                \"TransactionConfiguration/default/CashFlowType\",\n",
    "                value= lm.PropertyValue(label_value=\"Principal\"))\n",
    "    }),\n",
    "    lm.TransactionTypeRequest(\n",
    "    aliases=[\n",
    "        lm.TransactionTypeAlias(\n",
    "            type= \"CashFlow\",\n",
    "            description=\"cash paid/received from instrument\",\n",
    "            transaction_class=\"CashFlow\",\n",
    "            transaction_roles=\"AllRoles\",\n",
    "            is_default = False\n",
    "        )\n",
    "    ],\n",
    "    movements=[\n",
    "        lm.TransactionTypeMovement(\n",
    "            movement_types=\"Carry\",\n",
    "            side=\"Side1\",\n",
    "            direction=1,\n",
    "            properties=None,\n",
    "            mappings=[],\n",
    "            name=\"CarryCashFlow\"\n",
    "        ),\n",
    "          lm.TransactionTypeMovement(\n",
    "            movement_types=\"CashReceivable\",\n",
    "            side=\"Side2\",\n",
    "            direction=1,\n",
    "            properties=None,\n",
    "            mappings=[]\n",
    "          )\n",
    "    ])\n",
    "]\n",
    "\n",
    "# set the transaction types in the transaction type scope\n",
    "new_txn_config = transaction_configuration_api.set_transaction_type_source(\n",
    "    source=\"default\",\n",
    "    transaction_type_request=transaction_type_requests,\n",
    "    scope=scope\n",
    ")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.621323Z",
     "start_time": "2024-03-18T18:02:06.248231Z"
    }
   },
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1. Create Portfolio\n",
    "\n",
    "We begin by creating a portfolio that will contain the FX forward instrument that we will be looking to price."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "portfolio_code = \"FxForwardWithPipsCurve\"\n",
    "\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",
    "            sub_holding_keys=[],\n",
    "            transaction_type_scope=scope\n",
    "        ),\n",
    "    )\n",
    "\n",
    "except lusid.ApiException as e:\n",
    "    print(e.body)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.991285Z",
     "start_time": "2024-03-18T18:02:06.621937Z"
    }
   },
   "execution_count": 9
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Create Instrument\n",
    "\n",
    "Using the below method we can reference the SDK models to populate the required parameters for creating an FX forward. We then populate the instrument variables, and make a call to persist the instrument in LUSID."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.994212Z",
     "start_time": "2024-03-18T18:02:06.991804Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define function that creates an FX forward\n",
    "\n",
    "def create_fx_forward(\n",
    "        dom_amount,\n",
    "        fgn_amount,\n",
    "        dom_ccy,\n",
    "        fgn_ccy,\n",
    "        start_date,\n",
    "        maturity_date\n",
    "):\n",
    "    return lm.FxForward(\n",
    "        dom_amount=dom_amount,\n",
    "        fgn_amount=fgn_amount,\n",
    "        dom_ccy=dom_ccy,\n",
    "        fgn_ccy=fgn_ccy,\n",
    "        start_date=start_date,\n",
    "        maturity_date=maturity_date,\n",
    "        instrument_type=\"FxForward\",\n",
    "    )\n",
    "\n",
    "# Define a function to upsert instrument\n",
    "def upsert_instrument_to_lusid(instrument_definition, name, identifier, identifier_type):\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",
    "                )\n",
    "            }\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "For this example we will be creating a 6M EUR/USD forward, with the following characteristics:\n",
    "- Forward Exchange Rate (Strike): 1.21552025\n",
    "- Buy/Receive: EUR\n",
    "- Sell/Pay: USD\n",
    "- Start Date: 20 Jan 2021\n",
    "- Maturity Date: 22 July 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:06.997352Z",
     "start_time": "2024-03-18T18:02:06.994815Z"
    }
   },
   "outputs": [],
   "source": [
    "# Set the instrument variables\n",
    "forward_name = \"EUR/USD 6M FX Forward 20210720\"\n",
    "forward_identifier = \"FWD-EURUSD20210720\"\n",
    "identifier_type = \"ClientInternal\"\n",
    "description = \"EUR/USD FX Forward 20210720\"\n",
    "start_date = datetime(2021, 1, 20, tzinfo=pytz.utc)\n",
    "maturity_date = datetime(2021, 7, 22, tzinfo=pytz.utc)\n",
    "dom_ccy = \"EUR\"\n",
    "fgn_ccy = \"USD\"\n",
    "dom_amount = 1000000\n",
    "fgn_amount = -1215520.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:07.124257Z",
     "start_time": "2024-03-18T18:02:06.998013Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUID_0000EDME\n"
     ]
    }
   ],
   "source": [
    "# Create the Instrument\n",
    "forward_definition = create_fx_forward(\n",
    "    dom_amount=dom_amount,\n",
    "    fgn_amount=fgn_amount,\n",
    "    dom_ccy=dom_ccy,\n",
    "    fgn_ccy=fgn_ccy,\n",
    "    start_date=start_date,\n",
    "    maturity_date=maturity_date\n",
    ")\n",
    "\n",
    "# Upsert the instrument\n",
    "upsert_response = upsert_instrument_to_lusid(forward_definition, forward_name, forward_identifier, identifier_type)\n",
    "luid = upsert_response.values[forward_identifier].lusid_instrument_id\n",
    "print(luid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Upsert Transactions\n",
    "\n",
    "Having created the portfolio, we add a _StockIn_ transaction against the forward to create a position without incurring any costs. Notice that this transaction type will simply increase our position by the given units, as opposed to a typical _Buy_/_Sell_, that would also impact cash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:07.793243Z",
     "start_time": "2024-03-18T18:02:07.126305Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction successfully updated at time: 2024-03-18 18:02:07.724546+00:00\n"
     ]
    }
   ],
   "source": [
    "# Set trade variables\n",
    "trade_date = datetime(2021, 1, 20, tzinfo=pytz.utc)\n",
    "settle_days = 2\n",
    "units = 1\n",
    "\n",
    "# Book a StockIn transaction against the forward\n",
    "fwd_txn = lm.TransactionRequest(\n",
    "    transaction_id=\"TXN001\",\n",
    "    type=\"StockIn\",\n",
    "    instrument_identifiers={\"Instrument/default/ClientInternal\": forward_identifier},\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=1,type=\"Price\"),\n",
    "    total_consideration=lm.CurrencyAndAmount(amount=1,currency=\"USD\"),\n",
    "    exchange_rate=1,\n",
    "    transaction_currency=\"USD\"\n",
    ")\n",
    "\n",
    "response = transaction_portfolios_api.upsert_transactions(scope=scope,\n",
    "                                                    code=portfolio_code,\n",
    "                                                    transaction_request=[fwd_txn])\n",
    "\n",
    "print(f\"Transaction successfully updated at time: {response.version.as_at_date}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Upsert FX Market Data\n",
    "\n",
    "Next we will be loading the required marked data into the quotes store. In this particular example, we will be using both spot rates as well as an FX forward curve, where the latter will need to be loaded using LUSID's complex market data APIs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 4.1 FX Spot Rates\n",
    "\n",
    "We begin by adding the FX spot rates, which are the first piece of market data required to value an FX forward on a given day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:07.805846Z",
     "start_time": "2024-03-18T18:02:07.793975Z"
    }
   },
   "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": 14,
     "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": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:08.131177Z",
     "start_time": "2024-03-18T18:02:07.806386Z"
    }
   },
   "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=\"Lusid\",\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=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": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 4.2 FX Forward Curve\n",
    "\n",
    "Next we will read in our FX forward curve data, and create a `ComplexMarketData` object that can be loaded into LUSID's market data store to be used for valuation. Notice, in this example our curve is composed of points rather than outrights, which are commonly referred to as pips as well. These will be added to the spot rate of the day a valuation is run, and need to be scaled so that they are in the correct order of magnitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:08.137102Z",
     "start_time": "2024-03-18T18:02:08.131998Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "  Tenor  Points Mid\n0    1D      0.6375\n1    1W      1.4975\n2    2W      3.0275\n3    3W      4.5625\n4    1M      6.7525\n5    2M     19.5125\n6    3M     27.3225\n7    4M     34.0625\n8    5M     41.5175\n9    6M     49.2025",
      "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>Tenor</th>\n      <th>Points Mid</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1D</td>\n      <td>0.6375</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1W</td>\n      <td>1.4975</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2W</td>\n      <td>3.0275</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>3W</td>\n      <td>4.5625</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1M</td>\n      <td>6.7525</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2M</td>\n      <td>19.5125</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>3M</td>\n      <td>27.3225</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>4M</td>\n      <td>34.0625</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>5M</td>\n      <td>41.5175</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>6M</td>\n      <td>49.2025</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read FX forward curve data - showing first 10 terms\n",
    "fwd_df = pd.read_csv(\"data/fwd_curve.csv\")\n",
    "fwd_df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:08.399548Z",
     "start_time": "2024-03-18T18:02:08.137612Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Curves successfully loaded into LUSID. 1 curves loaded.\n"
     ]
    }
   ],
   "source": [
    "# Set the curve variables\n",
    "market_data_type = \"FxForwardTenorPipsCurveData\"\n",
    "\n",
    "forward_curve_data = lm.FxForwardTenorPipsCurveData(\n",
    "    base_date=trade_date,\n",
    "    dom_ccy=\"EUR\",\n",
    "    fgn_ccy=\"USD\",\n",
    "    tenors=[row[\"Tenor\"] for i, row in fwd_df.iterrows()],\n",
    "    pip_rates=[row[\"Points Mid\"] for i, row in fwd_df.iterrows()],\n",
    "    market_data_type=market_data_type\n",
    ")\n",
    "\n",
    "forward_curve_id = lm.ComplexMarketDataId(\n",
    "    provider=\"Lusid\",\n",
    "    lineage=\"FxForwardCurveTenorPipsDemo\",\n",
    "    price_source=None,\n",
    "    effective_at=trade_date,\n",
    "    market_asset=\"EUR/USD/FxFwdCurve\"\n",
    ")\n",
    "\n",
    "complex_market_data_request = lm.UpsertComplexMarketDataRequest(\n",
    "    market_data_id=forward_curve_id,\n",
    "    market_data=forward_curve_data\n",
    ")\n",
    "\n",
    "# Upsert forward curve into LUSID\n",
    "response = complex_market_data_api.upsert_complex_market_data(\n",
    "    scope=scope,\n",
    "    request_body={\"1\": complex_market_data_request}\n",
    ")\n",
    "\n",
    "if response.failed == {}:\n",
    "    print(f\"Curves successfully loaded into LUSID. {len(response.values)} curves 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": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "We can also use the _ComplexMarketDataApi_ to retrieve the data as it's been stored in LUSID. See below for the returned object, and a plot showing a dissection of the pips curve. Within LUSID, these pips will be overlaid on the effective spot rate in order to compute the forward rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:08.584490Z",
     "start_time": "2024-03-18T18:02:08.400236Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Retrieve curve\n",
    "forward_curve = complex_market_data_api.get_complex_market_data(\n",
    "    scope=scope,\n",
    "    effective_at = forward_curve_id.effective_at.isoformat(),\n",
    "    request_body= {\"1\": forward_curve_id}\n",
    ")\n",
    "\n",
    "# Get axis data and create plot\n",
    "x, y = create_curve_axes(0, forward_curve.values[\"1\"].pip_rates, forward_curve.values[\"1\"].tenors, False, True)\n",
    "plt.plot(x,y, color='#ff5200' , marker='o', markersize=5, linestyle='--', linewidth=1, label=\"Pips\")\n",
    "x_tenors = forward_curve.values[\"1\"].tenors\n",
    "plt.xticks(x, x_tenors, rotation='vertical')\n",
    "plt.title('EUR/USD Forward Pips')\n",
    "plt.ylabel('EUR/USD')\n",
    "plt.xlim([30, 1000]), plt.ylim([0, 400])\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.show()"
   ]
  },
  {
   "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.\n",
    "\n",
    "Within the market context we provide 2 rules, where the first defines a ruleset for spot rates and the other references our FX forward curve. Notice also that we have applied a long quote interval (1Y) for the forward curve, which defines the look-back period for reusing the data set on multiple valuation dates.\n",
    "\n",
    "For the valuation model we have selected `ForwardFromCurveUndiscounted`, which allows for the valuation of an FX forward using an FX forward curve. In our case it will also create the forward curve from the previously seen pips along with the daily spot. This model will calculate the forward's value on the fly by interpolating the matching point on the curve for the instrument's maturity, using the following formula.\n",
    "\n",
    "```\n",
    "PV = (S - K) / S * notionalBase\n",
    "\n",
    "Where;\n",
    "\n",
    "S = Interpolated Forward Rate\n",
    "\n",
    "K = Strike\n",
    "\n",
    "```\n",
    "\n",
    "As the name implies, this model doesn't apply any discounting in computing the instrument's market value. In LUSID this is supported using the model `ForwardFromCurve`, which would require the addition of a discount curve into the complex market data store."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:08.588296Z",
     "start_time": "2024-03-18T18:02:08.585380Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define a method for creating the recipe\n",
    "def create_recipe(recipe_code, separate_otc_legs=False):\n",
    "\n",
    "    # Populate recipe parameters\n",
    "    return lm.ConfigurationRecipe(\n",
    "        scope=scope,\n",
    "        code=recipe_code,\n",
    "        market=lm.MarketContext(\n",
    "            market_rules=[\n",
    "                lm.MarketDataKeyRule(\n",
    "                    key=\"FX.CurrencyPair.*\",\n",
    "                    supplier=\"Lusid\",\n",
    "                    data_scope=scope,\n",
    "                    quote_type=\"Rate\",\n",
    "                    field=\"mid\",\n",
    "                    quote_interval=\"5D.0D\"\n",
    "                ),\n",
    "                lm.MarketDataKeyRule(\n",
    "                    key=\"FxForwards.*.*.*\",\n",
    "                    supplier=\"Lusid\",\n",
    "                    data_scope=scope,\n",
    "                    quote_type=\"Rate\",\n",
    "                    field=\"mid\",\n",
    "                    quote_interval=\"1Y.0D\"\n",
    "                )\n",
    "            ],\n",
    "            options=lm.MarketOptions(\n",
    "                attempt_to_infer_missing_fx=True,\n",
    "                default_scope=scope\n",
    "            )\n",
    "        ),\n",
    "        # Set the valuation model - curve with no discounting\n",
    "        pricing=lm.PricingContext(\n",
    "            model_rules=[\n",
    "                lm.VendorModelRule(\n",
    "                    supplier=\"Lusid\",\n",
    "                    model_name=\"ForwardFromCurveUndiscounted\",\n",
    "                    instrument_type=\"FxForward\",\n",
    "                    parameters=\"{}\",\n",
    "                    # Optional - will make FX conversion done using forward rate not spot\n",
    "                    model_options=lm.FxForwardModelOptions(\n",
    "                            forward_rate_observable_type=\"Invalid\",\n",
    "                            discounting_method=\"Invalid\",\n",
    "                            convert_to_report_ccy=False,\n",
    "                            model_options_type=\"FxForwardModelOptions\"\n",
    "                        )\n",
    "                ),\n",
    "            ],\n",
    "            options=lm.PricingOptions(\n",
    "                produce_separate_result_for_linear_otc_legs=separate_otc_legs\n",
    "            )\n",
    "        ),\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "By default, LUSID will price an _FxForward_ instrument as a single line-item, which yields the net market value. However, in some use cases it may be needed to produce the leg level market value, which can be managed in the recipe's pricing options.\n",
    "\n",
    "In this example we create 2 recipes, one that produces the net market value and another that splits the instrument to its leg components. This is driven by the `produce_separate_result_for_linear_otc_legs` parameter in the configuration recipe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:08.952637Z",
     "start_time": "2024-03-18T18:02:08.589273Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Configuration recipe loaded into LUSID at time 2024-03-18 18:02:08.692593+00:00.\n",
      "Configuration recipe loaded into LUSID at time 2024-03-18 18:02:08.858906+00:00.\n"
     ]
    }
   ],
   "source": [
    "# Create recipes for net and leg level valuation\n",
    "net_recipe_code = \"FxForwardValuation\"\n",
    "sep_recipe_code = \"FxForwardValuationSeparated\"\n",
    "\n",
    "standard_recipe = create_recipe(net_recipe_code, False)\n",
    "separate_legs_recipe = create_recipe(sep_recipe_code, True)\n",
    "\n",
    "for recipe in [standard_recipe, separate_legs_recipe]:\n",
    "    response = configuration_recipe_api.upsert_configuration_recipe(\n",
    "            upsert_recipe_request=lm.UpsertRecipeRequest(\n",
    "                configuration_recipe=recipe\n",
    "            )\n",
    "        )\n",
    "\n",
    "    print(f\"Configuration recipe loaded into LUSID at time {response.value}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Valuation\n",
    "\n",
    "In order to value the portfolio, we will need to create a valuation request that specifies the metrics that are to be returned, and reference our previously setup portfolio and recipe on a given date. The following method will return the results in form of a data frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:08.959358Z",
     "start_time": "2024-03-18T18:02:08.956246Z"
    }
   },
   "outputs": [],
   "source": [
    "# Set the queryable metrics and operation to be applied on the group_by level\n",
    "metrics = [\n",
    "    lm.AggregateSpec(\"Instrument/default/Name\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Instrument/default/ClientInternal\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Valuation/PvInPortfolioCcy\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Valuation/Diagnostics/FxForwardRate\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Quotes/FxRate/DomFgn\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Holding/default/Units\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Valuation/PnL/Tm1/Pfolio\", \"Value\"),\n",
    "        ]\n",
    "\n",
    "# Method to query daily valuations\n",
    "def get_daily_valuation(date, portfolio_code, recipe_code, metrics, group_by=[\"Instrument/default/Name\"]):\n",
    "\n",
    "    valuation_request = lm.ValuationRequest(\n",
    "        recipe_id=lm.ResourceId(scope=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.isoformat()),\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",
    "            \"Instrument/default/Name\": \"InstrumentName\",\n",
    "            \"Instrument/default/ClientInternal\": \"ClientInternal\",\n",
    "            \"Valuation/PvInPortfolioCcy\": \"Market Value (Portfolio Currency)\",\n",
    "            \"Valuation/Diagnostics/FxForwardRate\": \"Forward Rate (Interpolated)\",\n",
    "            \"Quotes/FxRate/DomFgn\": \"FX Spot Rate\",\n",
    "            \"Valuation/PnL/Tm1/Pfolio\": \"PnL (1-day)\",\n",
    "            \"Valuation/PV/Ccy\": \"Leg Currency\"\n",
    "        },\n",
    "        inplace=True,\n",
    "    )\n",
    "\n",
    "    return vals_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6.1 Daily Valuation and PnL\n",
    "\n",
    "# Day 1\n",
    "\n",
    "We begin by valuing the position as of the trade date, where based on the available forward curve and spot rates, we can observe the following market values for the positions within the portfolio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:10.900025Z",
     "start_time": "2024-03-18T18:02:08.960117Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "                   InstrumentName      ClientInternal  \\\n0  EUR/USD 6M FX Forward 20210720  FWD-EURUSD20210720   \n\n   Market Value (Portfolio Currency)  Forward Rate (Interpolated)  \\\n0                             0.0000                       1.2155   \n\n   FX Spot Rate  Holding/default/Units PnL (1-day)  \n0        1.2106                 1.0000        None  ",
      "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>InstrumentName</th>\n      <th>ClientInternal</th>\n      <th>Market Value (Portfolio Currency)</th>\n      <th>Forward Rate (Interpolated)</th>\n      <th>FX Spot Rate</th>\n      <th>Holding/default/Units</th>\n      <th>PnL (1-day)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>EUR/USD 6M FX Forward 20210720</td>\n      <td>FWD-EURUSD20210720</td>\n      <td>0.0000</td>\n      <td>1.2155</td>\n      <td>1.2106</td>\n      <td>1.0000</td>\n      <td>None</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = get_daily_valuation(trade_date, portfolio_code, net_recipe_code, metrics)\n",
    "df.drop('Aggregation/Errors', axis=1, inplace=True)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "As we can see, the current market value for the forward is zero. This is because our current implied forward rate is equal to the strike on our forward instrument. We can illustrate this on the curve, as seen below, with our instrument's forward rate highlighted in blue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:10.981770Z",
     "start_time": "2024-03-18T18:02:10.900662Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get axis data and create plot\n",
    "x, y = create_curve_axes(1.2106, forward_curve.values[\"1\"].pip_rates, forward_curve.values[\"1\"].tenors, True)\n",
    "plt.plot(x,y, color='#ff5200' , marker='o', markersize=5, linestyle='--', linewidth=1, label=\"Forwards\")\n",
    "plt.plot(180, 1.21552025,'s', label=\"Implied Forward\")\n",
    "plt.axhline(y=1.21552025, color='r', label=\"Strike\")\n",
    "x_tenors = [\"0D\"] + forward_curve.values[\"1\"].tenors\n",
    "plt.xticks(x, x_tenors, rotation='vertical')\n",
    "plt.title('EUR/USD Forward Curve')\n",
    "plt.ylabel('EUR/USD')\n",
    "plt.xlim([30, 365]), plt.ylim([1.21, 1.220])\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 2\n",
    "\n",
    "On the following date, we observe a new market value and also observe a daily PnL as a result of a price change against the previous day's market value.\n",
    "\n",
    "Notice that in this case we are re-using the curve upserted on the trade date, however, the market values are moving along with a change in the spot rate. Given we have a curve composed of points, rather than outrights, the fx forward curve will shift along with the spot rate. (In a real world implementation, it would be more accurate to update the curve daily.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:12.774991Z",
     "start_time": "2024-03-18T18:02:10.982756Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "                   InstrumentName      ClientInternal  \\\n0  EUR/USD 6M FX Forward 20210720  FWD-EURUSD20210720   \n\n   Market Value (Portfolio Currency)  Forward Rate (Interpolated)  \\\n0                         4,748.9592                       1.2213   \n\n   FX Spot Rate  Holding/default/Units  PnL (1-day)  \n0        1.2164                 1.0000   4,748.9592  ",
      "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>InstrumentName</th>\n      <th>ClientInternal</th>\n      <th>Market Value (Portfolio Currency)</th>\n      <th>Forward Rate (Interpolated)</th>\n      <th>FX Spot Rate</th>\n      <th>Holding/default/Units</th>\n      <th>PnL (1-day)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>EUR/USD 6M FX Forward 20210720</td>\n      <td>FWD-EURUSD20210720</td>\n      <td>4,748.9592</td>\n      <td>1.2213</td>\n      <td>1.2164</td>\n      <td>1.0000</td>\n      <td>4,748.9592</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = get_daily_valuation(trade_date + timedelta(days=1), portfolio_code, net_recipe_code, metrics)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "As we can see, we have a positive market value which stems from the fact that the interpolated forward has moved above our strike, which means entering a similar contract today would be more expensive.\n",
    "\n",
    "Moreover, the PV in USD base terms is arrived to as follows:\n",
    "\n",
    "```\n",
    "PVlocal = (1.22132025 - 1.21552025) /1.22132025 * 1,000,000.00\n",
    "PVlocal = EUR 4748.9592\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:12.854334Z",
     "start_time": "2024-03-18T18:02:12.775741Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get axis data and create plot\n",
    "x, y = create_curve_axes(1.2164, forward_curve.values[\"1\"].pip_rates, forward_curve.values[\"1\"].tenors, True)\n",
    "plt.plot(x,y, color='#ff5200' , marker='o', markersize=5, linestyle='--', linewidth=1, label=\"Forwards\")\n",
    "plt.plot(179, 1.2213,'s',label=\"Implied Forward\")\n",
    "x_tenors = [\"0D\"] + forward_curve.values[\"1\"].tenors\n",
    "plt.xticks(x, x_tenors, rotation='vertical')\n",
    "plt.axhline(y=1.21552025, color='r', label=\"Strike\")\n",
    "plt.title('EUR/USD Forward Curve')\n",
    "plt.ylabel('EUR/USD')\n",
    "plt.xlim([30, 365]), plt.ylim([1.215, 1.225])\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 3\n",
    "\n",
    "On day 3, we again run the same query and observe a daily gain, as well as the latest market value and price."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:15.065446Z",
     "start_time": "2024-03-18T18:02:12.855098Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "                   InstrumentName      ClientInternal  \\\n0  EUR/USD 6M FX Forward 20210720  FWD-EURUSD20210720   \n\n   Market Value (Portfolio Currency)  Forward Rate (Interpolated)  \\\n0                         5,319.0608                       1.2220   \n\n   FX Spot Rate  Holding/default/Units  PnL (1-day)  \n0        1.2171                 1.0000     570.1016  ",
      "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>InstrumentName</th>\n      <th>ClientInternal</th>\n      <th>Market Value (Portfolio Currency)</th>\n      <th>Forward Rate (Interpolated)</th>\n      <th>FX Spot Rate</th>\n      <th>Holding/default/Units</th>\n      <th>PnL (1-day)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>EUR/USD 6M FX Forward 20210720</td>\n      <td>FWD-EURUSD20210720</td>\n      <td>5,319.0608</td>\n      <td>1.2220</td>\n      <td>1.2171</td>\n      <td>1.0000</td>\n      <td>570.1016</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = get_daily_valuation(trade_date + timedelta(days=2), portfolio_code, net_recipe_code, metrics)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "We notice a daily PnL in the portfolio base currency, which is a result of:\n",
    "\n",
    "```\n",
    "PnL = (PV1local - PV0local)\n",
    "\n",
    "PnL = (5319.0608 - 4748.9592) = 570.1016\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 6.2 Leg level valuation\n",
    "\n",
    "LUSID can also value OTC instruments that are composed of multiple legs at the individual leg level. We can see this here for Day 3, where we replace the recipe with the one that splits the instrument as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:16.728291Z",
     "start_time": "2024-03-18T18:02:15.066318Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "  Leg Currency                  InstrumentName  \\\n0          EUR  EUR/USD 6M FX Forward 20210720   \n1          USD  EUR/USD 6M FX Forward 20210720   \n\n   Market Value (Portfolio Currency)  Forward Rate (Interpolated) FX Spot Rate  \n0                     1,000,000.0000                       1.2220         None  \n1                      -994,680.9392                       1.2220         None  ",
      "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>Leg Currency</th>\n      <th>InstrumentName</th>\n      <th>Market Value (Portfolio Currency)</th>\n      <th>Forward Rate (Interpolated)</th>\n      <th>FX Spot Rate</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>EUR</td>\n      <td>EUR/USD 6M FX Forward 20210720</td>\n      <td>1,000,000.0000</td>\n      <td>1.2220</td>\n      <td>None</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>USD</td>\n      <td>EUR/USD 6M FX Forward 20210720</td>\n      <td>-994,680.9392</td>\n      <td>1.2220</td>\n      <td>None</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run with separate legs\n",
    "\n",
    "new_metrics = [\n",
    "    lm.AggregateSpec(\"Instrument/default/Name\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Valuation/PV/Ccy\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Valuation/PvInPortfolioCcy\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Valuation/Diagnostics/FxForwardRate\", \"Value\"),\n",
    "    lm.AggregateSpec(\"Quotes/FxRate/DomFgn\", \"Value\"),\n",
    "        ]\n",
    "\n",
    "df = get_daily_valuation(trade_date + timedelta(days=3), portfolio_code, sep_recipe_code, new_metrics, [\"Instrument/default/Name\",  \"Valuation/PvInPortfolioCcy\"])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 7. Instrument Life Cycle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7.1 Rolling over the contract\n",
    "\n",
    "As seen previously, the instrument we've held has a positive market value, which means we could unwind the position and realize a gain on any of day 2 or 3. If a hedge is still needed in place, this could be done by rolling over to a new forward.\n",
    "\n",
    "Rolling the forward contract can also be used dynamically to ensure periodic cash flows in foreign currencies remain hedged. Below we show an example of unwinding an existing forward, realising the gain/loss and entering a new contract. This is done using our previous example with 1M into the contracts life cycle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:18.855923Z",
     "start_time": "2024-03-18T18:02:16.728946Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "                   InstrumentName      ClientInternal  \\\n0  EUR/USD 6M FX Forward 20210720  FWD-EURUSD20210720   \n\n   Market Value (Portfolio Currency)  Forward Rate (Interpolated)  \\\n0                         1,068.3583                       1.2168   \n\n   FX Spot Rate  Holding/default/Units  PnL (1-day)  \n0        1.2119                 1.0000   2,221.4566  ",
      "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>InstrumentName</th>\n      <th>ClientInternal</th>\n      <th>Market Value (Portfolio Currency)</th>\n      <th>Forward Rate (Interpolated)</th>\n      <th>FX Spot Rate</th>\n      <th>Holding/default/Units</th>\n      <th>PnL (1-day)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>EUR/USD 6M FX Forward 20210720</td>\n      <td>FWD-EURUSD20210720</td>\n      <td>1,068.3583</td>\n      <td>1.2168</td>\n      <td>1.2119</td>\n      <td>1.0000</td>\n      <td>2,221.4566</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Query valuations as of day 30\n",
    "df = get_daily_valuation(trade_date + timedelta(days=30), portfolio_code, net_recipe_code, metrics)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to realize the gain/loss, we use the market value of the forward as the cost of the transaction unwinding our position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:19.156042Z",
     "start_time": "2024-03-18T18:02:18.856760Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction successfully updated at time: 2024-03-18 18:02:19.116261+00:00\n"
     ]
    }
   ],
   "source": [
    "# Store market value - to be realized as cash settlement\n",
    "market_val = df[\"Market Value (Portfolio Currency)\"][0]\n",
    "\n",
    "# Set trade parameters\n",
    "unwind_date = trade_date + timedelta(days=30, hours=12)\n",
    "\n",
    "# Book a sell transaction against the forward\n",
    "fwd_txn = lm.TransactionRequest(\n",
    "    transaction_id=\"TXN002\",\n",
    "    type=\"Sell\",\n",
    "    instrument_identifiers={\"Instrument/default/ClientInternal\": forward_identifier},\n",
    "    transaction_date=unwind_date.isoformat(),\n",
    "    settlement_date=(unwind_date + timedelta(days=settle_days)).isoformat(),\n",
    "    units=units,\n",
    "    transaction_price=lm.TransactionPrice(price=1,type=\"Price\"),\n",
    "    total_consideration=lm.CurrencyAndAmount(amount=market_val,currency=\"USD\"),\n",
    "    exchange_rate=1,\n",
    "    transaction_currency=\"USD\"\n",
    ")\n",
    "\n",
    "response = transaction_portfolios_api.upsert_transactions(scope=scope,\n",
    "                                                    code=portfolio_code,\n",
    "                                                    transaction_request=[fwd_txn])\n",
    "\n",
    "print(f\"Transaction successfully updated at time: {response.version.as_at_date}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Having unwound our position with our realized gain as cash, we can now enter a new forward with our counterparty, rolling the hedge forward. To this end we will create and book the following instrument:\n",
    "\n",
    "- Forward Exchange Rate (Strike): 1.2168\n",
    "- Buy/Receive: EUR\n",
    "- Sell/Pay: USD\n",
    "- Start Date: 19 Feb 2021\n",
    "- Maturity Date: 19 Aug 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:19.286780Z",
     "start_time": "2024-03-18T18:02:19.156667Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUID_0000FMOX\n"
     ]
    }
   ],
   "source": [
    "# Set the instrument variables\n",
    "forward_name2 = \"EUR/USD 6M FX Forward 20210819\"\n",
    "forward_identifier2 = \"FWD-EURUSD20210819\"\n",
    "identifier_type = \"ClientInternal\"\n",
    "description = \"EUR/USD FX Forward 20210819\"\n",
    "start_date = datetime(2021, 2, 19, tzinfo=pytz.utc)\n",
    "maturity_date = datetime(2021, 8, 19, tzinfo=pytz.utc)\n",
    "dom_ccy = \"EUR\"\n",
    "fgn_ccy = \"USD\"\n",
    "dom_amount = 1000000\n",
    "fgn_amount = -1216800\n",
    "\n",
    "# Create the forward\n",
    "forward_definition = create_fx_forward(\n",
    "    dom_amount=dom_amount,\n",
    "    fgn_amount=fgn_amount,\n",
    "    dom_ccy=dom_ccy,\n",
    "    fgn_ccy=fgn_ccy,\n",
    "    start_date=start_date,\n",
    "    maturity_date=maturity_date\n",
    ")\n",
    "\n",
    "# Upsert the instrument\n",
    "upsert_response = upsert_instrument_to_lusid(forward_definition, forward_name2, forward_identifier2, identifier_type)\n",
    "luid = upsert_response.values[forward_identifier2].lusid_instrument_id\n",
    "print(luid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "We then enter the forward position with a _StockIn_, similar to what was done with our previous instrument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:19.768114Z",
     "start_time": "2024-03-18T18:02:19.290736Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction successfully updated at time: 2024-03-18 18:02:19.697192+00:00\n"
     ]
    }
   ],
   "source": [
    "# Book a StockIn transaction against the new forward\n",
    "fwd_txn = lm.TransactionRequest(\n",
    "    transaction_id=\"TXN003\",\n",
    "    type=\"StockIn\",\n",
    "    instrument_identifiers={\"Instrument/default/ClientInternal\": forward_identifier2},\n",
    "    transaction_date=unwind_date.isoformat(),\n",
    "    settlement_date=(unwind_date + timedelta(days=settle_days)).isoformat(),\n",
    "    units=units,\n",
    "    transaction_price=lm.TransactionPrice(price=1,type=\"Price\"),\n",
    "    total_consideration=lm.CurrencyAndAmount(amount=1,currency=\"USD\"),\n",
    "    exchange_rate=1,\n",
    "    transaction_currency=\"USD\"\n",
    ")\n",
    "\n",
    "response = transaction_portfolios_api.upsert_transactions(scope=scope,\n",
    "                                                    code=portfolio_code,\n",
    "                                                    transaction_request=[fwd_txn])\n",
    "\n",
    "print(f\"Transaction successfully updated at time: {response.version.as_at_date}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 7.2 Upsertable Cash Flows\n",
    "\n",
    "For the instrument's life cycle events, LUSID has a native cash flows API end point that allows a user to query upcoming portfolio flows. The example below shows an example that retrieves the cash flows occurring at maturity for the FX forward, as shown below for both the EUR and USD legs.\n",
    "\n",
    "Notice that the results of the _UpsertableCashFlows_ call will be composed of headers that match an _UpsertTransactions_ payload, which means it can be used to execute life cycle events as part of a scripted process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:21.968074Z",
     "start_time": "2024-03-18T18:02:19.768811Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "                                      transaction_id       type  \\\n0  TXN003-LUID_0000FMOX-20210819-Principal-EUR-Re...  Principal   \n1    TXN003-LUID_0000FMOX-20210819-Principal-USD-Pay  Principal   \n\n  instrument_identifiers.Instrument/default/LusidInstrumentId  \\\n0                                      LUID_0000FMOX            \n1                                      LUID_0000FMOX            \n\n  instrument_scope instrument_uid          transaction_date  \\\n0          default  LUID_0000FMOX 2021-08-19 00:00:00+00:00   \n1          default  LUID_0000FMOX 2021-08-19 00:00:00+00:00   \n\n            settlement_date           units  transaction_price.price  \\\n0 2021-08-19 00:00:00+00:00  1,000,000.0000                   1.0000   \n1 2021-08-19 00:00:00+00:00 -1,216,800.0000                   1.0000   \n\n  transaction_price.type  total_consideration.amount  \\\n0                  Price              1,000,000.0000   \n1                  Price             -1,216,800.0000   \n\n  total_consideration.currency  exchange_rate transaction_currency  \\\n0                          EUR         1.0000                  EUR   \n1                          USD         1.0000                  USD   \n\n  properties.Transaction/default/ParentLuid.key  \\\n0                Transaction/default/ParentLuid   \n1                Transaction/default/ParentLuid   \n\n  properties.Transaction/default/ParentLuid.value.label_value  \\\n0                                      LUID_0000FMOX            \n1                                      LUID_0000FMOX            \n\n  properties.Transaction/default/InstrumentEventId.key  \\\n0              Transaction/default/InstrumentEventId     \n1              Transaction/default/InstrumentEventId     \n\n  properties.Transaction/default/InstrumentEventId.value.label_value   source  \\\n0    LUID_0000FMOX-20210819-Principal-EUR-Receive-v1                  default   \n1        LUID_0000FMOX-20210819-Principal-USD-Pay-v1                  default   \n\n             entry_date_time transaction_status  \n0  0001-01-01 00:00:00+00:00             Active  \n1  0001-01-01 00:00:00+00:00             Active  ",
      "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>transaction_id</th>\n      <th>type</th>\n      <th>instrument_identifiers.Instrument/default/LusidInstrumentId</th>\n      <th>instrument_scope</th>\n      <th>instrument_uid</th>\n      <th>transaction_date</th>\n      <th>settlement_date</th>\n      <th>units</th>\n      <th>transaction_price.price</th>\n      <th>transaction_price.type</th>\n      <th>total_consideration.amount</th>\n      <th>total_consideration.currency</th>\n      <th>exchange_rate</th>\n      <th>transaction_currency</th>\n      <th>properties.Transaction/default/ParentLuid.key</th>\n      <th>properties.Transaction/default/ParentLuid.value.label_value</th>\n      <th>properties.Transaction/default/InstrumentEventId.key</th>\n      <th>properties.Transaction/default/InstrumentEventId.value.label_value</th>\n      <th>source</th>\n      <th>entry_date_time</th>\n      <th>transaction_status</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>TXN003-LUID_0000FMOX-20210819-Principal-EUR-Re...</td>\n      <td>Principal</td>\n      <td>LUID_0000FMOX</td>\n      <td>default</td>\n      <td>LUID_0000FMOX</td>\n      <td>2021-08-19 00:00:00+00:00</td>\n      <td>2021-08-19 00:00:00+00:00</td>\n      <td>1,000,000.0000</td>\n      <td>1.0000</td>\n      <td>Price</td>\n      <td>1,000,000.0000</td>\n      <td>EUR</td>\n      <td>1.0000</td>\n      <td>EUR</td>\n      <td>Transaction/default/ParentLuid</td>\n      <td>LUID_0000FMOX</td>\n      <td>Transaction/default/InstrumentEventId</td>\n      <td>LUID_0000FMOX-20210819-Principal-EUR-Receive-v1</td>\n      <td>default</td>\n      <td>0001-01-01 00:00:00+00:00</td>\n      <td>Active</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>TXN003-LUID_0000FMOX-20210819-Principal-USD-Pay</td>\n      <td>Principal</td>\n      <td>LUID_0000FMOX</td>\n      <td>default</td>\n      <td>LUID_0000FMOX</td>\n      <td>2021-08-19 00:00:00+00:00</td>\n      <td>2021-08-19 00:00:00+00:00</td>\n      <td>-1,216,800.0000</td>\n      <td>1.0000</td>\n      <td>Price</td>\n      <td>-1,216,800.0000</td>\n      <td>USD</td>\n      <td>1.0000</td>\n      <td>USD</td>\n      <td>Transaction/default/ParentLuid</td>\n      <td>LUID_0000FMOX</td>\n      <td>Transaction/default/InstrumentEventId</td>\n      <td>LUID_0000FMOX-20210819-Principal-USD-Pay-v1</td>\n      <td>default</td>\n      <td>0001-01-01 00:00:00+00:00</td>\n      <td>Active</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "upsertable_cash_flows = transaction_portfolios_api.get_upsertable_portfolio_cash_flows(\n",
    "    scope=scope,\n",
    "    code=portfolio_code,\n",
    "    effective_at=\"2021-02-21T12:00:00Z\",\n",
    "    window_start=trade_date,\n",
    "    window_end=maturity_date,\n",
    "    recipe_id_scope=scope,\n",
    "    recipe_id_code=net_recipe_code\n",
    ")\n",
    "\n",
    "# we create a dataframe out of the cash flows table and drop some columns to improve readability\n",
    "cash_flow_table = lusid_response_to_data_frame(upsertable_cash_flows)\n",
    "if(not cash_flow_table.empty):\n",
    "    cash_flow_table[\n",
    "        [\n",
    "            \"transaction_id\", \n",
    "            \"type\", \n",
    "            \"instrument_identifiers.Instrument/default/LusidInstrumentId\", \n",
    "            \"instrument_scope\", \n",
    "            \"transaction_date\", \n",
    "            \"settlement_date\", \n",
    "            \"total_consideration.amount\", \n",
    "            \"total_consideration.currency\", \n",
    "            \"source\", \n",
    "            \"transaction_status\"\n",
    "        ]\n",
    "    ]\n",
    "cash_flow_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 7.3 At Maturity\n",
    "\n",
    "The previous cash flows output can also be ingested as transaction in order for the portfolio holdings to reflect the settlement of 2 instrument cash flows. These are not booked automatically, but the process can be scripted for where needed, and run as a scheduled job in LUSID. This process that can be run periodically would consist of the following steps:\n",
    "1. Retrieve upsertable cash flows.\n",
    "2. Remove the zero cash flows\n",
    "3. Book cash flows as transactions in order to adjust holdings.\n",
    "\n",
    "Below we upsert the previously seen cash flows below to show this taking place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:22.453085Z",
     "start_time": "2024-03-18T18:02:21.968726Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction successfully updated at time: 2024-03-18 18:02:22.362077+00:00\n"
     ]
    }
   ],
   "source": [
    "# Set the instrument identifiers\n",
    "non_zero_upsertable_cash_flows = []\n",
    "\n",
    "for x in upsertable_cash_flows.values:\n",
    "    if(x.units != 0):\n",
    "        x.instrument_identifiers = {\"Instrument/default/Currency\": x.transaction_currency}\n",
    "        non_zero_upsertable_cash_flows.append(x)\n",
    "\n",
    "        # Upsert the transactions\n",
    "response = transaction_portfolios_api.upsert_transactions(\n",
    "    scope=scope,\n",
    "    code=portfolio_code,\n",
    "    transaction_request=non_zero_upsertable_cash_flows\n",
    ")\n",
    "\n",
    "print(f\"Transaction successfully updated at time: {response.version.as_at_date}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "With the cash transactions loaded into LUSID, we can now view our holdings as of the maturity date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:23.669385Z",
     "start_time": "2024-03-18T18:02:22.461594Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "                   InstrumentName      ClientInternal  \\\n0  EUR/USD 6M FX Forward 20210819  FWD-EURUSD20210819   \n1                             USD                None   \n2                             EUR                None   \n\n   Market Value (Portfolio Currency)  Forward Rate (Interpolated)  \\\n0                       -37,163.5927                       1.1732   \n1                    -1,041,311.8987                          NaN   \n2                     1,000,000.0000                          NaN   \n\n   FX Spot Rate  Holding/default/Units  PnL (1-day)  \n0        1.1675                 1.0000  -3,172.8331  \n1           NaN        -1,215,731.6417       0.0000  \n2           NaN         1,000,000.0000       0.0000  ",
      "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>InstrumentName</th>\n      <th>ClientInternal</th>\n      <th>Market Value (Portfolio Currency)</th>\n      <th>Forward Rate (Interpolated)</th>\n      <th>FX Spot Rate</th>\n      <th>Holding/default/Units</th>\n      <th>PnL (1-day)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>EUR/USD 6M FX Forward 20210819</td>\n      <td>FWD-EURUSD20210819</td>\n      <td>-37,163.5927</td>\n      <td>1.1732</td>\n      <td>1.1675</td>\n      <td>1.0000</td>\n      <td>-3,172.8331</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>USD</td>\n      <td>None</td>\n      <td>-1,041,311.8987</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>-1,215,731.6417</td>\n      <td>0.0000</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>EUR</td>\n      <td>None</td>\n      <td>1,000,000.0000</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>1,000,000.0000</td>\n      <td>0.0000</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = get_daily_valuation(maturity_date, portfolio_code, net_recipe_code, metrics)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "As we can see, we now have our cash balances within our portfolio holdings. However, we still hold a position in the FX forward position with a negative market value.\n",
    "\n",
    "In order to remove the instrument from our holdings, we will need to add a transaction to reflect this. The default `StockOut` transaction can be used here as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:23.996188Z",
     "start_time": "2024-03-18T18:02:23.670042Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction successfully updated at time: 2024-03-18 18:02:23.942714+00:00\n"
     ]
    }
   ],
   "source": [
    "#Set trade variables\n",
    "settle_days = 2\n",
    "units = 1\n",
    "\n",
    "# Book a StockOut transaction against the forward\n",
    "fwd_txn = lm.TransactionRequest(\n",
    "    transaction_id=\"TXN004\",\n",
    "    type=\"StockOut\",\n",
    "    instrument_identifiers={\"Instrument/default/ClientInternal\": forward_identifier2},\n",
    "    transaction_date=(maturity_date + timedelta(days=1)).isoformat(),\n",
    "    settlement_date=(maturity_date + timedelta(days=settle_days)).isoformat(),\n",
    "    units=units,\n",
    "    transaction_price=lm.TransactionPrice(price=1,type=\"Price\"),\n",
    "    total_consideration=lm.CurrencyAndAmount(amount=1,currency=\"USD\"),\n",
    "    exchange_rate=1,\n",
    "    transaction_currency=\"USD\"\n",
    ")\n",
    "\n",
    "response = transaction_portfolios_api.upsert_transactions(scope=scope,\n",
    "                                                    code=portfolio_code,\n",
    "                                                    transaction_request=[fwd_txn])\n",
    "\n",
    "print(f\"Transaction successfully updated at time: {response.version.as_at_date}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "We can now observe our holdings within the portfolio that include only the cash balances and the market value of each position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-03-18T18:02:24.925837Z",
     "start_time": "2024-03-18T18:02:23.996938Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "  InstrumentName ClientInternal  Market Value (Portfolio Currency)  \\\n0            USD           None                    -1,039,264.5253   \n1            EUR           None                     1,000,000.0000   \n\n  Forward Rate (Interpolated) FX Spot Rate  Holding/default/Units  PnL (1-day)  \n0                        None         None        -1,215,731.6417       0.0000  \n1                        None         None         1,000,000.0000       0.0000  ",
      "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>InstrumentName</th>\n      <th>ClientInternal</th>\n      <th>Market Value (Portfolio Currency)</th>\n      <th>Forward Rate (Interpolated)</th>\n      <th>FX Spot Rate</th>\n      <th>Holding/default/Units</th>\n      <th>PnL (1-day)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>USD</td>\n      <td>None</td>\n      <td>-1,039,264.5253</td>\n      <td>None</td>\n      <td>None</td>\n      <td>-1,215,731.6417</td>\n      <td>0.0000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>EUR</td>\n      <td>None</td>\n      <td>1,000,000.0000</td>\n      <td>None</td>\n      <td>None</td>\n      <td>1,000,000.0000</td>\n      <td>0.0000</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = get_daily_valuation(maturity_date + timedelta(days=settle_days), portfolio_code, net_recipe_code, metrics)\n",
    "df"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}