V1/product/ibor/How do I create holdings in LUSID.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Toggle Docstring\"></form>\n",
       "    \n",
       "         <script>\n",
       "         function code_toggle() {\n",
       "             if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){\n",
       "                 $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "             } else {\n",
       "                 $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "             }\n",
       "         }\n",
       "         </script>\n",
       "\n",
       "     "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from lusidtools.jupyter_tools import toggle_code\n",
    "\n",
    "\"\"\"Creating holdings in LUSID\n",
    "\n",
    "Demonstrates how to load transactions based on custom transaction types and then compute the subsequent holdings.\n",
    "\n",
    "Attributes\n",
    "----------\n",
    "properties\n",
    "transaction configuration\n",
    "transactions\n",
    "\"\"\"\n",
    "\n",
    "toggle_code(\"Toggle Docstring\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How do I create holdings in LUSID?\n",
    "\n",
    "This notebook provides a reference implementation to the [\"How do I create holdings in LUSID?\"](https://support.finbourne.com/how-do-i-create-holdings) document which demonstrates the process of loading transactions into LUSID to produce holdings.\n",
    "\n",
    "While we use Python to interact with the LUSID API here, the models and methods are also available through our other maintained SDKs in [C#](https://github.com/finbourne/lusid-sdk-csharp), [Java](https://github.com/finbourne/lusid-sdk-java) and [JavaScript](https://github.com/finbourne/lusid-sdk-js). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup LUSID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LUSID Environment Initialised\n",
      "LUSID SDK Version:  0.6.10718.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import lusid\n",
    "import json\n",
    "from lusid import models\n",
    "import pandas as pd\n",
    "from lusid.utilities import ApiClientFactory\n",
    "from pathlib import Path\n",
    "from lusidjam import RefreshingToken\n",
    "import pickle\n",
    "import pprint\n",
    "from lusidtools.cocoon.utilities import create_scope_id\n",
    "\n",
    "\n",
    "# Authenticate our user and create our API client\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(\n",
    "    \"LUSID SDK Version: \",\n",
    "    api_factory.build(lusid.api.ApplicationMetadataApi)\n",
    "    .get_lusid_versions()\n",
    "    .build_version,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the APIs we are going to use\n",
    "\n",
    "transaction_portfolios_api = api_factory.build(lusid.api.TransactionPortfoliosApi)\n",
    "portfolios_api = api_factory.build(lusid.api.PortfoliosApi)\n",
    "property_definitions_api = api_factory.build(lusid.api.PropertyDefinitionsApi)\n",
    "instruments_api = api_factory.build(lusid.api.InstrumentsApi)\n",
    "transaction_configuration_api = api_factory.build(lusid.api.TransactionConfigurationApi)\n",
    "search_api = api_factory.build(lusid.api.SearchApi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "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>txn_id</th>\n",
       "      <th>trade_date</th>\n",
       "      <th>transaction_type</th>\n",
       "      <th>instrument_desc</th>\n",
       "      <th>client_internal</th>\n",
       "      <th>instrument_currency</th>\n",
       "      <th>instrument_id</th>\n",
       "      <th>quantity</th>\n",
       "      <th>price</th>\n",
       "      <th>net_money</th>\n",
       "      <th>portfolio</th>\n",
       "      <th>base_currency</th>\n",
       "      <th>portfolio_manager_name</th>\n",
       "      <th>Broker</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tx_00001</td>\n",
       "      <td>2020-01-01T00:00:00.0000000+00:00</td>\n",
       "      <td>FundsIn</td>\n",
       "      <td>CASH_GBP</td>\n",
       "      <td>cash</td>\n",
       "      <td>GBP</td>\n",
       "      <td>Cash in GBP</td>\n",
       "      <td>1000000</td>\n",
       "      <td>1.00</td>\n",
       "      <td>1000000</td>\n",
       "      <td>UK_EQUITY</td>\n",
       "      <td>GBP</td>\n",
       "      <td>John Smith</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tx_00002</td>\n",
       "      <td>2020-01-01T00:00:00.0000000+00:00</td>\n",
       "      <td>Tutorial-Buy</td>\n",
       "      <td>Tesco</td>\n",
       "      <td>EQ_001</td>\n",
       "      <td>GBP</td>\n",
       "      <td>TSCO</td>\n",
       "      <td>100000</td>\n",
       "      <td>2.56</td>\n",
       "      <td>256000</td>\n",
       "      <td>UK_EQUITY</td>\n",
       "      <td>GBP</td>\n",
       "      <td>John Smith</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>tx_00003</td>\n",
       "      <td>2020-01-02T00:00:00.0000000+00:00</td>\n",
       "      <td>Tutorial-Buy</td>\n",
       "      <td>Morrisons</td>\n",
       "      <td>EQ_002</td>\n",
       "      <td>GBP</td>\n",
       "      <td>MRW</td>\n",
       "      <td>120000</td>\n",
       "      <td>1.92</td>\n",
       "      <td>230400</td>\n",
       "      <td>UK_EQUITY</td>\n",
       "      <td>GBP</td>\n",
       "      <td>John Smith</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>tx_00004</td>\n",
       "      <td>2020-01-02T00:00:00.0000000+00:00</td>\n",
       "      <td>Tutorial-Buy</td>\n",
       "      <td>Sainsbury's</td>\n",
       "      <td>EQ_003</td>\n",
       "      <td>GBP</td>\n",
       "      <td>SBRY</td>\n",
       "      <td>200000</td>\n",
       "      <td>2.26</td>\n",
       "      <td>452000</td>\n",
       "      <td>UK_EQUITY</td>\n",
       "      <td>GBP</td>\n",
       "      <td>John Smith</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>tx_00005</td>\n",
       "      <td>2020-01-03T00:00:00.0000000+00:00</td>\n",
       "      <td>Tutorial-Buy</td>\n",
       "      <td>Tesco</td>\n",
       "      <td>EQ_001</td>\n",
       "      <td>GBP</td>\n",
       "      <td>TSCO</td>\n",
       "      <td>20000</td>\n",
       "      <td>2.60</td>\n",
       "      <td>52000</td>\n",
       "      <td>UK_EQUITY</td>\n",
       "      <td>GBP</td>\n",
       "      <td>John Smith</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     txn_id                         trade_date transaction_type  \\\n",
       "0  tx_00001  2020-01-01T00:00:00.0000000+00:00          FundsIn   \n",
       "1  tx_00002  2020-01-01T00:00:00.0000000+00:00     Tutorial-Buy   \n",
       "2  tx_00003  2020-01-02T00:00:00.0000000+00:00     Tutorial-Buy   \n",
       "3  tx_00004  2020-01-02T00:00:00.0000000+00:00     Tutorial-Buy   \n",
       "4  tx_00005  2020-01-03T00:00:00.0000000+00:00     Tutorial-Buy   \n",
       "\n",
       "  instrument_desc client_internal instrument_currency instrument_id  quantity  \\\n",
       "0        CASH_GBP            cash                 GBP   Cash in GBP   1000000   \n",
       "1           Tesco          EQ_001                 GBP          TSCO    100000   \n",
       "2       Morrisons          EQ_002                 GBP           MRW    120000   \n",
       "3     Sainsbury's          EQ_003                 GBP          SBRY    200000   \n",
       "4           Tesco          EQ_001                 GBP          TSCO     20000   \n",
       "\n",
       "   price  net_money  portfolio base_currency portfolio_manager_name  Broker  \n",
       "0   1.00    1000000  UK_EQUITY           GBP             John Smith     NaN  \n",
       "1   2.56     256000  UK_EQUITY           GBP             John Smith     NaN  \n",
       "2   1.92     230400  UK_EQUITY           GBP             John Smith     NaN  \n",
       "3   2.26     452000  UK_EQUITY           GBP             John Smith     NaN  \n",
       "4   2.60      52000  UK_EQUITY           GBP             John Smith     NaN  "
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "txns = pd.read_csv(\"data/tutorial/tutorial-transactions.csv\")\n",
    "txns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_property_definition(domain, scope, code, data_type):\n",
    "    try:\n",
    "        response = property_definitions_api.create_property_definition(\n",
    "            create_property_definition_request=models.CreatePropertyDefinitionRequest(\n",
    "                domain=domain,\n",
    "                scope=scope,\n",
    "                code=code,\n",
    "                display_name=code,\n",
    "                life_time=\"Perpetual\",\n",
    "                value_required=False,\n",
    "                data_type_id=models.ResourceId(scope=\"system\", code=data_type)\n",
    "            )\n",
    "        )\n",
    "        return response.key\n",
    "    except lusid.ApiException as e:\n",
    "        detail = json.loads(e.body)\n",
    "        if detail[\"code\"] != 124:  # 'PropertyAlreadyExists'\n",
    "            raise e\n",
    "        else:\n",
    "            key = f\"{domain}/{scope}/{code}\"\n",
    "            print(f\"property {key} already exists\")\n",
    "            return key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare portfolio and properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We begin by specifying a scope for loading the data. We also define the portfolio code which will be used to store transactions and holdings. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "life_of_a_txn-3b80-5d06-b245-78\n",
      "UK_EQUITY\n"
     ]
    }
   ],
   "source": [
    "scope = \"life_of_a_txn-\" + create_scope_id()\n",
    "portfolio_code = \"UK_EQUITY\"\n",
    "\n",
    "print(scope)\n",
    "print(portfolio_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created property Portfolio/life_of_a_txn-3b80-5d06-b245-78/portfolio_manager_name\n"
     ]
    }
   ],
   "source": [
    "# Call LUSID to create a property\n",
    "property = create_property_definition(\"Portfolio\", scope, \"portfolio_manager_name\", \"string\")\n",
    "\n",
    "print(f\"Created property {property}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Portfolio in LUSID\n",
    "\n",
    "(See [Section 4](https://support.finbourne.com/how-do-i-create-holdings#load-portfolios) of linked tutorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "portfolio 'UK_EQUITY', in scope life_of_a_txn-3b80-5d06-b245-78 created effective from: 2010/1/1\n"
     ]
    }
   ],
   "source": [
    "# Create portfolio with properties\n",
    "subholding_key = {}\n",
    "created_date = \"2010-01-01T00:00:00.000000+00:00\"\n",
    "\n",
    "# create request body\n",
    "portfolio_request = models.CreateTransactionPortfolioRequest(\n",
    "    display_name=\"Life of a transaction\",\n",
    "    code=portfolio_code,\n",
    "    base_currency=\"GBP\",\n",
    "    created=created_date,\n",
    "    properties={\n",
    "        f\"Portfolio/{scope}/portfolio_manager_name\": models.ModelProperty(\n",
    "            key=f\"Portfolio/{scope}/portfolio_manager_name\",\n",
    "            value=models.PropertyValue(label_value=\"Active\"),\n",
    "        )\n",
    "    },\n",
    ")\n",
    "\n",
    "# Upload new portfolio to LUSID\n",
    "response = transaction_portfolios_api.create_portfolio(\n",
    "    scope=scope, create_transaction_portfolio_request=portfolio_request\n",
    ")\n",
    "\n",
    "created = response.version.effective_from\n",
    "print(\n",
    "    f\"portfolio '{response.id.code}', in scope {scope} created effective from: \"\n",
    "    f\"{created.year}/\"\n",
    "    f\"{created.month}/\"\n",
    "    f\"{created.day}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Instruments\n",
    "\n",
    "(See [Section 5](https://support.finbourne.com/how-do-i-create-holdings#load-instruments) of linked tutorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created property Instrument/life_of_a_txn-3b80-5d06-b245-78/portfolio_manager_name\n"
     ]
    }
   ],
   "source": [
    "# Call LUSID to create a property\n",
    "property = create_property_definition(\"Instrument\", scope, \"portfolio_manager_name\", \"string\")\n",
    "\n",
    "print(f\"Created property {property}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each instrument definition needs to be given an identifier. For equities this could be an Isin or Figi, alternatively for cash this must be \"Currency\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# remove duplicate values\n",
    "txns.drop_duplicates(subset=\"client_internal\")\n",
    "\n",
    "# remove cash rows\n",
    "instruments = txns[txns[\"client_internal\"] != \"cash\"]\n",
    "batch_upsert_request = {\n",
    "    instr[\"instrument_desc\"]: models.InstrumentDefinition(\n",
    "        name=instr[\"instrument_desc\"],\n",
    "        identifiers={ \"ClientInternal\": models.InstrumentIdValue(value=instr[\"client_internal\"]) },\n",
    "        properties=[\n",
    "            models.ModelProperty(\n",
    "                key=f\"Instrument/{scope}/portfolio_manager_name\",\n",
    "                value=models.PropertyValue(label_value=instr[\"portfolio_manager_name\"]),\n",
    "            )\n",
    "        ],\n",
    "    )\n",
    "    for row, instr in instruments.iterrows()\n",
    "}\n",
    "\n",
    "# Upsert new instruments to LUSID\n",
    "instrument_response = instruments_api.upsert_instruments(\n",
    "    request_body=batch_upsert_request\n",
    ")\n",
    "\n",
    "# check response was successful\n",
    "\n",
    "if len(instrument_response.failed) > 0:\n",
    "    raise AssertionError(\"Instruments upsert failed. Inspect response for more detail\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading a Transaction File\n",
    "\n",
    "(See [Section 6](https://support.finbourne.com/how-do-i-create-holdings#load-txn-file) of linked tutorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created property Transaction/life_of_a_txn-3b80-5d06-b245-78/portfolio_manager_name\n"
     ]
    }
   ],
   "source": [
    "# Call LUSID to create a property\n",
    "property = create_property_definition(\"Transaction\", scope, \"portfolio_manager_name\", \"string\")\n",
    "\n",
    "print(f\"Created property {property}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 transactions upserted\n"
     ]
    }
   ],
   "source": [
    "# Upsert transactions\n",
    "transactions_request = []\n",
    "txn_response = []\n",
    "for row, txn in txns.iterrows():\n",
    "\n",
    "    if txn[\"client_internal\"] == \"cash\":\n",
    "        instrument_identifier = {\"Instrument/default/Currency\": \"GBP\"}\n",
    "    else:\n",
    "        instrument_identifier = {\n",
    "            \"Instrument/default/ClientInternal\": txn[\"client_internal\"]\n",
    "        }\n",
    "\n",
    "    # build request body\n",
    "    transactions_request.append(\n",
    "        models.TransactionRequest(\n",
    "            transaction_id=txn[\"txn_id\"],\n",
    "            type=txn[\"transaction_type\"],\n",
    "            instrument_identifiers=instrument_identifier,\n",
    "            transaction_date=txn[\"trade_date\"],\n",
    "            settlement_date=txn[\"trade_date\"],\n",
    "            units=txn[\"quantity\"],\n",
    "            transaction_price=models.TransactionPrice(price=txn[\"price\"], type=\"Price\"),\n",
    "            total_consideration=models.CurrencyAndAmount(\n",
    "                amount=txn[\"net_money\"], currency=txn[\"instrument_currency\"]\n",
    "            ),\n",
    "            properties={\n",
    "                f\"Transaction/{scope}/portfolio_manager_name\": models.PerpetualProperty(\n",
    "                    key=f\"Transaction/{scope}/portfolio_manager_name\",\n",
    "                    value=models.PropertyValue(\n",
    "                        label_value=txn[\"portfolio_manager_name\"]\n",
    "                    ),\n",
    "                )\n",
    "            },\n",
    "        )\n",
    "    )\n",
    "\n",
    "    # Make Upsert Transactions call to LUSID\n",
    "    txn_response.append(\n",
    "        transaction_portfolios_api.upsert_transactions(\n",
    "            scope=scope, code=portfolio_code, transaction_request=transactions_request\n",
    "        )\n",
    "    )\n",
    "\n",
    "print(f\"{len(txn_response)} transactions upserted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuring Transaction Types\n",
    "\n",
    "(See [Section 7](https://support.finbourne.com/how-do-i-create-holdings#config-txn-types) of linked tutorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we configure some new transaction types. LUSID already comes pre-configured with some commonly used transaction types (Buy, Sell etc) however we configure the new transaction types of <b>Tutorial-Buy</b> and <b>Tutorial-B</b> below to demonstrate the configurability of the movements engine. \n",
    "\n",
    "####  <font color='darkred'>WARNING: Amending Transaction Types can have an unintended system wide impact</font> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the property used in mapping for the custom side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Transaction/life_of_a_txn-3b80-5d06-b245-78/Comms2'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "create_property_definition(\"Transaction\", scope, \"Comms2\", \"number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tutorial-Side1 already exists in LUSID\n",
      "Tutorial-Side2 already exists in LUSID\n",
      "Tutorial-TradeCommissions already exists in LUSID\n"
     ]
    }
   ],
   "source": [
    "# Construct the default side definitions that, unless removed, can be found in the default scope.\n",
    "default_side_definitions = [\n",
    "    models.SidesDefinitionRequest(\n",
    "        side=\"Side1\", \n",
    "        side_request=models.SideDefinitionRequest(\n",
    "            security=\"Txn:LusidInstrumentId\",\n",
    "            currency=\"Txn:TradeCurrency\",\n",
    "            rate=\"Txn:TradeToPortfolioRate\",\n",
    "            units=\"Txn:Units\",\n",
    "            amount=\"Txn:TradeAmount\")),\n",
    "    models.SidesDefinitionRequest(\n",
    "        side=\"Side2\", \n",
    "        side_request=models.SideDefinitionRequest(\n",
    "            security=\"Txn:SettleCcy\",\n",
    "            currency=\"Txn:SettlementCurrency\",\n",
    "            rate=\"SettledToPortfolioRate\",\n",
    "            units=\"Txn:TotalConsideration\",\n",
    "            amount=\"Txn:TotalConsideration\"))\n",
    "]\n",
    "\n",
    "# Create a list of custom sides which will be used on the new transaction type\n",
    "side_list = [\n",
    "        models.SidesDefinitionRequest(\n",
    "            side=\"Tutorial-Side1\",\n",
    "            side_request = models.SideDefinitionRequest(\n",
    "                security=\"Txn:LusidInstrumentId\",\n",
    "                currency=\"Txn:TradeCurrency\",\n",
    "                rate=\"Txn:TradeToPortfolioRate\",\n",
    "                units=\"Txn:Units\",\n",
    "                amount=\"Txn:TradeAmount\"\n",
    "            )\n",
    "        ),\n",
    "        models.SidesDefinitionRequest(\n",
    "            side=\"Tutorial-Side2\",\n",
    "            side_request = models.SideDefinitionRequest(\n",
    "                security=\"Txn:SettleCcy\",\n",
    "                currency=\"Txn:SettlementCurrency\",\n",
    "                rate=\"SettledToPortfolioRate\",\n",
    "                units=\"Txn:TotalConsideration\",\n",
    "                amount=\"Txn:TotalConsideration\"\n",
    "            )\n",
    "        ),\n",
    "        models.SidesDefinitionRequest(\n",
    "            side=\"Tutorial-TradeCommissions\",\n",
    "            side_request = models.SideDefinitionRequest(\n",
    "                security=\"Txn:SettleCcy\",\n",
    "                currency=\"Txn:SettlementCurrency\",\n",
    "                rate=\"SettledToPortfolioRate\",\n",
    "                units=f\"Transaction/{scope}/Comms2\",\n",
    "                amount=f\"Transaction/{scope}/Comms2\"\n",
    "            )\n",
    "        )\n",
    "    ]\n",
    "\n",
    "# Set both the default and non-default sides in the non-default scope\n",
    "transaction_configuration_api.set_side_definitions(sides_definition_request = default_side_definitions + side_list , scope = scope)\n",
    "\n",
    "# Add default transaction types\n",
    "default_transaction_mapping=open('data/default_transaction_mapping.json').read()\n",
    "default_transaction_mapping = json.loads(default_transaction_mapping)\n",
    "\n",
    "def map_properties(properties):\n",
    "    return {property[\"key\"]: models.PerpetualProperty(property[\"key\"], models.PropertyValue(property[\"value\"])) for property in properties}\n",
    "def map_alias(alias):\n",
    "    return models.TransactionTypeAlias(alias[\"type\"], alias[\"description\"], alias[\"transactionClass\"], alias[\"transactionRoles\"])\n",
    "def map_movement(movement):\n",
    "    return models.TransactionTypeMovement(movement[\"movementTypes\"], movement[\"side\"], movement[\"direction\"], map_properties(movement[\"properties\"]))\n",
    "def map_transaction_type_request(transaction_type_request):\n",
    "    return models.TransactionTypeRequest(\n",
    "        [map_alias(alias) for alias in transaction_type_request[\"aliases\"]],\n",
    "        [map_movement(movement) for movement in transaction_type_request[\"movements\"]],\n",
    "        map_properties(transaction_type_request[\"properties\"]))\n",
    "\n",
    "for configuration in default_transaction_mapping:\n",
    "    transaction_type_requests = [map_transaction_type_request(transaction_type_request) for transaction_type_request in configuration[\"transactionTypeRequests\"]]\n",
    "    \n",
    "    # Call LUSID to set your configuration for our transaction types\n",
    "    transaction_configuration_api.set_transaction_type_source(\n",
    "        source=configuration[\"source\"],\n",
    "        transaction_type_request=transaction_type_requests,\n",
    "        scope=scope\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The provided mappings contain duplicate transaction aliases\n"
     ]
    }
   ],
   "source": [
    "# Create the new transaction types using the new sides\n",
    "\n",
    "try:\n",
    "    transaction_configuration_api.set_transaction_type(\n",
    "        source=\"default\",\n",
    "        type=\"Tutorial-Buy\",\n",
    "        transaction_type_request=models.TransactionTypeRequest(\n",
    "            aliases=[\n",
    "                models.TransactionTypeAlias(\n",
    "                    type=\"Tutorial-Buy\",\n",
    "                    description=\"A purchase transaction from System X\",\n",
    "                    transaction_class=\"Basic\",\n",
    "                    transaction_roles=\"LongLonger\",\n",
    "                )\n",
    "            ],\n",
    "            movements=[\n",
    "                models.TransactionTypeMovement(\n",
    "                    movement_types=\"StockMovement\",\n",
    "                    side=\"Tutorial-Side1\",\n",
    "                    direction=1,\n",
    "                    properties={},\n",
    "                    mappings=[],\n",
    "                ),\n",
    "                models.TransactionTypeMovement(\n",
    "                    movement_types=\"CashCommitment\",\n",
    "                    side=\"Tutorial-Side2\",\n",
    "                    direction=-1,\n",
    "                    properties={},\n",
    "                    mappings=[],\n",
    "                ),\n",
    "                models.TransactionTypeMovement(\n",
    "                    movement_types=\"CashCommitment\",\n",
    "                    side=\"Tutorial-TradeCommissions\",\n",
    "                    direction=-1,\n",
    "                    properties={},\n",
    "                    mappings=[\n",
    "                        models.TransactionPropertyMappingRequest(\n",
    "                            property_key=f\"Transaction/{scope}/Broker_2\",\n",
    "                            set_to=\"Commission\",\n",
    "                        )\n",
    "                    ],\n",
    "                ),\n",
    "            ],\n",
    "        ),\n",
    "        scope = scope\n",
    "    )\n",
    "    transaction_configuration_api.set_transaction_type(\n",
    "        source=\"alt1\",\n",
    "        type=\"Tutorial-B\",\n",
    "        transaction_type_request=models.TransactionTypeRequest(\n",
    "            aliases=[\n",
    "                models.TransactionTypeAlias(\n",
    "                    type=\"Tutorial-B\",\n",
    "                    description=\"A purchase transaction from System X\",\n",
    "                    transaction_class=\"Basic\",\n",
    "                    transaction_roles=\"LongLonger\",\n",
    "                ),\n",
    "            ],\n",
    "            movements=[\n",
    "                models.TransactionTypeMovement(\n",
    "                    movement_types=\"StockMovement\",\n",
    "                    side=\"Tutorial-Side1\",\n",
    "                    direction=1,\n",
    "                    properties={},\n",
    "                    mappings=[],\n",
    "                ),\n",
    "                models.TransactionTypeMovement(\n",
    "                    movement_types=\"CashCommitment\",\n",
    "                    side=\"Tutorial-Side2\",\n",
    "                    direction=-1,\n",
    "                    properties={},\n",
    "                    mappings=[],\n",
    "                ),\n",
    "                models.TransactionTypeMovement(\n",
    "                    movement_types=\"CashCommitment\",\n",
    "                    side=\"Tutorial-TradeCommissions\",\n",
    "                    direction=-1,\n",
    "                    properties={},\n",
    "                    mappings=[\n",
    "                        models.TransactionTypePropertyMapping(\n",
    "                            property_key=f\"Transaction/{scope}/Broker_2\",\n",
    "                            set_to=\"Commission\",\n",
    "                        )\n",
    "                    ],\n",
    "                ),\n",
    "            ],\n",
    "        ),\n",
    "        scope = scope\n",
    "    )\n",
    "\n",
    "except lusid.ApiException as e:\n",
    "    print(json.loads(e.body)[\"title\"])\n",
    "\n",
    "\n",
    "# Call LUSID to update the transaction type scope of your portfolio \n",
    "patch_document = [\n",
    "    {\n",
    "        \"value\": scope,\n",
    "        \"path\": \"/transactiontypescope\",\n",
    "        \"op\": \"add\"\n",
    "    }\n",
    "]\n",
    "patch_response = api_factory.build(lusid.api.TransactionPortfoliosApi).patch_portfolio_details(\n",
    "    scope=scope,\n",
    "    code=portfolio_code,\n",
    "    operation=patch_document)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get Holdings\n",
    "\n",
    "(See [Section 8](https://support.finbourne.com/how-do-i-create-holdings#get-holdings) of linked tutorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prints the name and a quick summary from a get_holdings() response\n",
    "def display_holdings_summary(response):\n",
    "    # inspect holdings response for today\n",
    "    hld = [i for i in response.values]\n",
    "\n",
    "    names = []\n",
    "    amount = []\n",
    "    units = []\n",
    "    shks = []\n",
    "\n",
    "    for item in hld:\n",
    "\n",
    "        names.append(item.properties[\"Instrument/default/Name\"].value.label_value)\n",
    "        amount.append(item.cost.amount)\n",
    "        units.append(item.units)\n",
    "        shks.append(\n",
    "            [\n",
    "                item.sub_holding_keys[key].value.label_value\n",
    "                for key in item.sub_holding_keys.keys()\n",
    "            ]\n",
    "        )\n",
    "\n",
    "    data = {\"names\": names, \"amount\": amount, \"units\": units, \"shks\": shks}\n",
    "\n",
    "    summary = pd.DataFrame(data=data)\n",
    "    return summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get holdings with todays effective date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>names</th>\n",
       "      <th>amount</th>\n",
       "      <th>units</th>\n",
       "      <th>shks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GBP</td>\n",
       "      <td>9600.0</td>\n",
       "      <td>9600.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Tesco</td>\n",
       "      <td>308000.0</td>\n",
       "      <td>120000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Morrisons</td>\n",
       "      <td>230400.0</td>\n",
       "      <td>120000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sainsbury's</td>\n",
       "      <td>452000.0</td>\n",
       "      <td>200000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         names    amount     units shks\n",
       "0          GBP    9600.0    9600.0   []\n",
       "1        Tesco  308000.0  120000.0   []\n",
       "2    Morrisons  230400.0  120000.0   []\n",
       "3  Sainsbury's  452000.0  200000.0   []"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "holdings_response_today = transaction_portfolios_api.get_holdings(\n",
    "    scope=scope, code=portfolio_code, property_keys=[\"Instrument/default/Name\"]\n",
    ")\n",
    "\n",
    "summary = display_holdings_summary(holdings_response_today)\n",
    "summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get holdings effective 1st January 2020 (the trade date of the first transactions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>names</th>\n",
       "      <th>amount</th>\n",
       "      <th>units</th>\n",
       "      <th>shks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GBP</td>\n",
       "      <td>744000.0</td>\n",
       "      <td>744000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Tesco</td>\n",
       "      <td>256000.0</td>\n",
       "      <td>100000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   names    amount     units shks\n",
       "0    GBP  744000.0  744000.0   []\n",
       "1  Tesco  256000.0  100000.0   []"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "holdings_response_1st_jan = transaction_portfolios_api.get_holdings(\n",
    "    scope=scope,\n",
    "    code=portfolio_code,\n",
    "    effective_at=\"2020-01-01T00:00:01.0000000+00:00\",\n",
    "    property_keys=[\"Instrument/default/Name\"],\n",
    ")\n",
    "\n",
    "display_holdings_summary(holdings_response_1st_jan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get holdings effective 1st March (after the trade date of the last transaction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>names</th>\n",
       "      <th>amount</th>\n",
       "      <th>units</th>\n",
       "      <th>shks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GBP</td>\n",
       "      <td>9600.0</td>\n",
       "      <td>9600.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Tesco</td>\n",
       "      <td>308000.0</td>\n",
       "      <td>120000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Morrisons</td>\n",
       "      <td>230400.0</td>\n",
       "      <td>120000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sainsbury's</td>\n",
       "      <td>452000.0</td>\n",
       "      <td>200000.0</td>\n",
       "      <td>[]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         names    amount     units shks\n",
       "0          GBP    9600.0    9600.0   []\n",
       "1        Tesco  308000.0  120000.0   []\n",
       "2    Morrisons  230400.0  120000.0   []\n",
       "3  Sainsbury's  452000.0  200000.0   []"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "holdings_response_1st_Mar = transaction_portfolios_api.get_holdings(\n",
    "    scope=scope,\n",
    "    code=portfolio_code,\n",
    "    property_keys=[\"Instrument/default/Name\"],\n",
    "    effective_at=\"2020-03-01T00:00:01.0000000+00:00\",\n",
    ")\n",
    "\n",
    "display_holdings_summary(holdings_response_1st_Mar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sub-holding Keys\n",
    "\n",
    "(See [Section 9](https://support.finbourne.com/how-do-i-create-holdings#shk) of linked tutorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to segregate our new portfolio that includes Sub-holding Keys (SHKs), we will use a different scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "txns_strat = pd.read_csv(\"data/tutorial/txn_strategy.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "life_of_a_txn-3b80-5d06-b245-78-stratategy-tagging\n"
     ]
    }
   ],
   "source": [
    "scope_shk = scope + \"-stratategy-tagging\"\n",
    "print(scope_shk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### create the property for `StrategyTag`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created property Transaction/life_of_a_txn-3b80-5d06-b245-78-stratategy-tagging/StrategyTag\n"
     ]
    }
   ],
   "source": [
    "# Call LUSID to create our new property, this property willbe used as our SHK\n",
    "\n",
    "property = create_property_definition(\"Transaction\", scope_shk, \"StrategyTag\", \"string\")\n",
    "\n",
    "print(f\"Created property {property}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assign property to portfolio (or derived portfolio) as SHK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "portfolio 'UK_EQUITY', in scope life_of_a_txn-3b80-5d06-b245-78-stratategy-tagging created effective from: 2010/1/1\n"
     ]
    }
   ],
   "source": [
    "# Create portfolio with properties\n",
    "created_date = \"2010-01-01T00:00:00.000000+00:00\"\n",
    "\n",
    "# create request body\n",
    "portfolio_request = models.CreateTransactionPortfolioRequest(\n",
    "    display_name=\"Life of a transaction - stratategy tagging\",\n",
    "    code=portfolio_code,\n",
    "    base_currency=\"GBP\",\n",
    "    created=created_date,\n",
    "    sub_holding_keys=[f\"Transaction/{scope_shk}/StrategyTag\"],\n",
    "    transaction_type_scope=scope\n",
    ")\n",
    "\n",
    "# Upload new portfolio to LUSID\n",
    "response = transaction_portfolios_api.create_portfolio(\n",
    "    scope=scope_shk, create_transaction_portfolio_request=portfolio_request\n",
    ")\n",
    "\n",
    "created = response.version.effective_from\n",
    "print(\n",
    "    f\"portfolio '{response.id.code}', in scope {scope_shk} created effective from: \"\n",
    "    f\"{created.year}/\"\n",
    "    f\"{created.month}/\"\n",
    "    f\"{created.day}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Upload transactions with properties for SHK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 transactions upserted\n"
     ]
    }
   ],
   "source": [
    "# Upsert transactions\n",
    "transactions_request = []\n",
    "txn_response = []\n",
    "for row, txn in txns_strat.iterrows():\n",
    "\n",
    "    if txn[\"client_internal\"] == \"cash\":\n",
    "        instrument_identifier = {\"Instrument/default/Currency\": \"GBP\"}\n",
    "    else:\n",
    "        instrument_identifier = {\n",
    "            \"Instrument/default/ClientInternal\": txn[\"client_internal\"]\n",
    "        }\n",
    "\n",
    "    # build request body\n",
    "    transactions_request.append(\n",
    "        models.TransactionRequest(\n",
    "            transaction_id=txn[\"txn_id\"],\n",
    "            type=txn[\"transaction_type\"],\n",
    "            instrument_identifiers=instrument_identifier,\n",
    "            transaction_date=txn[\"trade_date\"],\n",
    "            settlement_date=txn[\"trade_date\"],\n",
    "            units=txn[\"quantity\"],\n",
    "            transaction_price=models.TransactionPrice(price=txn[\"price\"], type=\"Price\"),\n",
    "            total_consideration=models.CurrencyAndAmount(\n",
    "                amount=txn[\"net_money\"], currency=txn[\"instrument_currency\"]\n",
    "            ),\n",
    "            properties={\n",
    "                f\"Transaction/{scope_shk}/StrategyTag\": models.PerpetualProperty(\n",
    "                    key=f\"Transaction/{scope_shk}/StrategyTag\",\n",
    "                    value=models.PropertyValue(label_value=txn[\"StrategyTag\"]),\n",
    "                ),\n",
    "            },\n",
    "        )\n",
    "    )\n",
    "\n",
    "    # Make Upsert Transactions call to LUSID\n",
    "    txn_response.append(\n",
    "        transaction_portfolios_api.upsert_transactions(\n",
    "            scope=scope_shk,\n",
    "            code=portfolio_code,\n",
    "            transaction_request=transactions_request,\n",
    "        )\n",
    "    )\n",
    "\n",
    "print(f\"{len(txn_response)} transactions upserted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Holdings from new portfolio with SHK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we get holdings, the result will be segregated by any specified Sub-holding Keys that we specified on the portfolio. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>names</th>\n",
       "      <th>amount</th>\n",
       "      <th>units</th>\n",
       "      <th>shks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GBP</td>\n",
       "      <td>61600.0</td>\n",
       "      <td>61600.0</td>\n",
       "      <td>[benchmarkRebalance]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>GBP</td>\n",
       "      <td>-52000.0</td>\n",
       "      <td>-52000.0</td>\n",
       "      <td>[quantitativeSignal]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Tesco</td>\n",
       "      <td>256000.0</td>\n",
       "      <td>100000.0</td>\n",
       "      <td>[benchmarkRebalance]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Tesco</td>\n",
       "      <td>52000.0</td>\n",
       "      <td>20000.0</td>\n",
       "      <td>[quantitativeSignal]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Morrisons</td>\n",
       "      <td>230400.0</td>\n",
       "      <td>120000.0</td>\n",
       "      <td>[benchmarkRebalance]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Sainsbury's</td>\n",
       "      <td>452000.0</td>\n",
       "      <td>200000.0</td>\n",
       "      <td>[benchmarkRebalance]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         names    amount     units                  shks\n",
       "0          GBP   61600.0   61600.0  [benchmarkRebalance]\n",
       "1          GBP  -52000.0  -52000.0  [quantitativeSignal]\n",
       "2        Tesco  256000.0  100000.0  [benchmarkRebalance]\n",
       "3        Tesco   52000.0   20000.0  [quantitativeSignal]\n",
       "4    Morrisons  230400.0  120000.0  [benchmarkRebalance]\n",
       "5  Sainsbury's  452000.0  200000.0  [benchmarkRebalance]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "holdings_response_1st_Mar = transaction_portfolios_api.get_holdings(\n",
    "    scope=scope_shk,\n",
    "    code=portfolio_code,\n",
    "    property_keys=[\"Instrument/default/Name\",],\n",
    "    effective_at=\"2020-03-01T00:00:01.0000000+00:00\",\n",
    ")\n",
    "\n",
    "display_holdings_summary(holdings_response_1st_Mar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "scrolled": true
   },
   "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>names</th>\n",
       "      <th>amount</th>\n",
       "      <th>units</th>\n",
       "      <th>shks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GBP</td>\n",
       "      <td>744000.0</td>\n",
       "      <td>744000.0</td>\n",
       "      <td>[benchmarkRebalance]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Tesco</td>\n",
       "      <td>256000.0</td>\n",
       "      <td>100000.0</td>\n",
       "      <td>[benchmarkRebalance]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   names    amount     units                  shks\n",
       "0    GBP  744000.0  744000.0  [benchmarkRebalance]\n",
       "1  Tesco  256000.0  100000.0  [benchmarkRebalance]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "holdings_response_1st_jan = transaction_portfolios_api.get_holdings(\n",
    "    scope=scope_shk,\n",
    "    code=portfolio_code,\n",
    "    effective_at=\"2020-01-01T00:00:01.0000000+00:00\",\n",
    "    property_keys=[\"Instrument/default/Name\",],\n",
    ")\n",
    "\n",
    "display_holdings_summary(holdings_response_1st_jan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Footnote: Resetting the original transaction configuration\n",
    "\n",
    "Transaction types are system wide settings. Therefore you might want to delete or reset the ones created above. If so, you can create a new [CreateConfigurationTransactionType](https://www.lusid.com/docs/api/#operation/CreateConfigurationTransactionType) request without the new types created above. One way of doing this is with the [lusidtools CLI](https://github.com/finbourne/lusid-python-tools/wiki/lusidtools-CLI).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tear down"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove example data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    property_defns = search_api.search_properties(search=f\"\\\"{scope}\\\"\")\n",
    "\n",
    "    for defn in property_defns.values:\n",
    "        property_definitions_api.delete_property_definition(defn.domain, defn.scope, defn.code)\n",
    "        display(f\"deleted property {defn.key}\")\n",
    "except Exception as e:\n",
    "    display(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    portfolios_api.delete_portfolio(scope, portfolio_code)\n",
    "    display(f\"deleted portfolio {scope}/{portfolio_code}\")\n",
    "    \n",
    "    portfolios_api.delete_portfolio(scope_shk, portfolio_code)\n",
    "    display(f\"deleted portfolio {scope}/{scope_shk}\")\n",
    "    \n",
    "except lusid.ApiException as e:\n",
    "    detail = json.loads(e.body)\n",
    "    if detail[\"code\"] != 109:  # 'PortfolioNotFound'\n",
    "        raise e"
   ]
  }
 ],
 "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.9.7"
  },
  "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
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}