examples/use-cases/risk-and-performance/Returns on composite portfolios.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Toggle Docstring\"></form>\n",
       "    \n",
       "         <script>\n",
       "         function code_toggle() {\n",
       "             if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){\n",
       "                 $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "             } else {\n",
       "                 $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "             }\n",
       "         }\n",
       "         </script>\n",
       "\n",
       "     "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from lusidtools.jupyter_tools import toggle_code\n",
    "\n",
    "\"\"\"Loading and caculating returns\n",
    "\n",
    "Demonstration of how to load and calculate returns on composite portfolios in LUSID\n",
    "\n",
    "Attributes\n",
    "----------\n",
    "Returns\n",
    "Composite portfolios\n",
    "\"\"\"\n",
    "\n",
    "toggle_code(\"Toggle Docstring\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load_ext lab_black\n",
    "# %load_ext nb_black"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Loading and calculating composite returns in LUSID\n",
    "\n",
    "In this notebook we show composite returns for two portfolios - a UK Active Equity and a UK Active Fixed Income portfolio. We show returns from 1 Jan 2014 to 31 Dec 2016."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>api_version</th>\n",
       "      <th>build_version</th>\n",
       "      <th>excel_version</th>\n",
       "      <th>links</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>v0</td>\n",
       "      <td>0.0.1.0</td>\n",
       "      <td>0.5.3499</td>\n",
       "      <td>{'relation': 'Re...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  api_version build_version excel_version                links\n",
       "0          v0       0.0.1.0      0.5.3499  {'relation': 'Re..."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import general purpose packages\n",
    "import os\n",
    "import json\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import datetime\n",
    "import pytz\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\", module=\"matplotlib*\")\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from datetime import datetime, timedelta\n",
    "from pandas import json_normalize\n",
    "\n",
    "# Import lusid specific packages\n",
    "import lusid\n",
    "import lusid.models as models\n",
    "\n",
    "from lusid.utilities import ApiClientFactory\n",
    "from lusidjam.refreshing_token import RefreshingToken\n",
    "\n",
    "# Set display configuration\n",
    "pd.set_option(\"display.max_columns\", None)\n",
    "pd.set_option(\"display.float_format\", lambda x: \"%.5f\" % x)\n",
    "pd.set_option(\"display.max_rows\", 3500)\n",
    "pd.set_option(\"max_colwidth\", 20)\n",
    "\n",
    "# Use line magic function to enable matplotlib to work interactively with iPython\n",
    "%matplotlib inline\n",
    "\n",
    "# Set style to fivethirtyeight to create clean and clear looking graphs\n",
    "plt.style.use(\"fivethirtyeight\")\n",
    "\n",
    "# Define a dictionary containing default plotting configurations\n",
    "params = {\n",
    "    \"legend.fontsize\": \"small\",\n",
    "    \"figure.figsize\": (12, 4.5),\n",
    "    \"axes.labelsize\": \"small\",\n",
    "    \"axes.titlesize\": \"medium\",\n",
    "    \"xtick.labelsize\": \"small\",\n",
    "    \"ytick.labelsize\": \"small\",\n",
    "}\n",
    "\n",
    "plt.rcParams.update(params)\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",
    "api_status = pd.DataFrame(\n",
    "    api_factory.build(lusid.api.ApplicationMetadataApi).get_lusid_versions().to_dict()\n",
    ")\n",
    "\n",
    "display(api_status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a scope to hold data\n",
    "\n",
    "scope = \"compositeDemo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the three portfolios\n",
    "\n",
    "portfolio_codes = [\"ukActiveEquity\", \"ukActiveFI\", \"composite\", \"ukMa\"]\n",
    "\n",
    "equity_portfolio, fi_portfolio, composite_portfolio, ma_portfolio = (\n",
    "    portfolio_codes[0],\n",
    "    portfolio_codes[1],\n",
    "    portfolio_codes[2],\n",
    "    portfolio_codes[3],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the APIs we use\n",
    "\n",
    "transaction_portfolios_api = api_factory.build(lusid.api.TransactionPortfoliosApi)\n",
    "portfolios_api = api_factory.build(lusid.api.PortfoliosApi)\n",
    "relationship_definition_api = api_factory.build(lusid.api.RelationshipDefinitionsApi)\n",
    "relationships_api = api_factory.build(lusid.api.RelationshipsApi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define dates\n",
    "start_date = datetime(year=2020, month=1, day=2, tzinfo=pytz.UTC).isoformat\n",
    "number_of_days = 366"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Portfolio and relationships setup\n",
    "\n",
    "## 3.1 Create four portfolios\n",
    "\n",
    "1. A UK Equity Portfolio\n",
    "2. A UK Fixed Income Portfolio\n",
    "3. A UK Multi-Asset Portfolio\n",
    "4. A Composite Portfolio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "for port in portfolio_codes:\n",
    "\n",
    "    try:\n",
    "\n",
    "        response = transaction_portfolios_api.create_portfolio(\n",
    "            scope=scope,\n",
    "            create_transaction_portfolio_request=models.CreateTransactionPortfolioRequest(\n",
    "                display_name=port, code=port, created=\"2013-12-30\", base_currency=\"GBP\"\n",
    "            ),\n",
    "        )\n",
    "    except lusid.ApiException as e:\n",
    "        print(json.loads(e.body)[\"title\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Create relationship between composite and two investment portfolios effective from 31 Dec 2013"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scope and Code for the Relationship used for Composite Returns\n",
    "relationship_scope = \"default\"\n",
    "relationship_code = \"CompositeMembership\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "for portfolio in [equity_portfolio, fi_portfolio]:\n",
    "\n",
    "    relationships_api.create_relationship(\n",
    "        scope=relationship_scope,\n",
    "        code=relationship_code,\n",
    "        create_relationship_request=models.CreateRelationshipRequest(\n",
    "            source_entity_id={\"scope\": scope, \"code\": composite_portfolio},\n",
    "            target_entity_id={\"scope\": scope, \"code\": portfolio},\n",
    "            effective_from=\"2013-12-30\",\n",
    "        ),\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 Delete relationship between composite and FI portfolios effective from 1 Jan 2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    delete_request = relationships_api.delete_relationship(\n",
    "        scope=relationship_scope,\n",
    "        code=relationship_code,\n",
    "        delete_relationship_request=models.DeleteRelationshipRequest(\n",
    "            source_entity_id={\"scope\": scope, \"code\": composite_portfolio},\n",
    "            target_entity_id={\"scope\": scope, \"code\": fi_portfolio},\n",
    "            effective_from=\"2016-01-01\",\n",
    "        ),\n",
    "    )\n",
    "except lusid.ApiException as e:\n",
    "    print(json.loads(e.body)[\"title\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 Add another child portfolio to composite effective from 1 Jan 2017"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "for portfolio in [ma_portfolio]:\n",
    "\n",
    "    relationships_api.create_relationship(\n",
    "        scope=relationship_scope,\n",
    "        code=relationship_code,\n",
    "        create_relationship_request=models.CreateRelationshipRequest(\n",
    "            source_entity_id={\"scope\": scope, \"code\": composite_portfolio},\n",
    "            target_entity_id={\"scope\": scope, \"code\": portfolio},\n",
    "            effective_from=\"2017-01-01\",\n",
    "        ),\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 Delete relationship between composite and MA portfolios effective from 29 Feb 2020"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    delete_request = relationships_api.delete_relationship(\n",
    "        scope=relationship_scope,\n",
    "        code=relationship_code,\n",
    "        delete_relationship_request=models.DeleteRelationshipRequest(\n",
    "            source_entity_id={\"scope\": scope, \"code\": composite_portfolio},\n",
    "            target_entity_id={\"scope\": scope, \"code\": ma_portfolio},\n",
    "            effective_from=\"2020-02-29\",\n",
    "        ),\n",
    "    )\n",
    "except lusid.ApiException as e:\n",
    "    print(json.loads(e.body)[\"title\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Load returns\n",
    "\n",
    "## 4.1 Load returns from CSV file into DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "returns_df = pd.read_csv(\n",
    "    \"data/composite_performance_data.csv\", dtype={\"daily_returns\": np.int64}\n",
    ")\n",
    "returns_df[\"date\"] = pd.to_datetime(returns_df[\"date\"], format=\"%d/%m/%Y\")\n",
    "returns_df = returns_df.rename(\n",
    "    columns={\"mv\": \"market_value\", \"returns\": \"daily_returns\"}\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "uk_equity_returns = returns_df[returns_df[\"portfolio\"] == \"uKEquity\"].copy()\n",
    "fi_equity_returns = returns_df[returns_df[\"portfolio\"] == \"uKFixedIncome\"].copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.2 Load returns from DataFrame into LUSID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from_effective_at = \"2014-01-01\"\n",
    "to_effective_at = \"2015-12-31\"\n",
    "return_code = \"daily_return\"\n",
    "list_of_porfolios = [equity_portfolio, fi_portfolio, ma_portfolio, composite_portfolio]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> <b> NOTE: We have truncated the upsert to 10 rows. Remove the cell below if you want to load all 4500+ rows of daily returns.</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "uk_equity_returns = uk_equity_returns[:10]\n",
    "fi_equity_returns = fi_equity_returns[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "for portfolio, df in [\n",
    "    (equity_portfolio, uk_equity_returns),\n",
    "    (fi_portfolio, fi_equity_returns),\n",
    "]:\n",
    "\n",
    "    time_series_of_returns = [\n",
    "        models.PerformanceReturn(\n",
    "            effective_at=row[\"date\"].isoformat()[:10],\n",
    "            rate_of_return=row[\"daily_returns\"],\n",
    "            opening_market_value=row[\"market_value\"],\n",
    "            period=\"Daily\",\n",
    "        )\n",
    "        for _, row in df.iterrows()\n",
    "    ]\n",
    "\n",
    "    upsert_returns = portfolios_api.upsert_portfolio_returns(\n",
    "        scope=scope,\n",
    "        code=portfolio,\n",
    "        return_code=return_code,\n",
    "        return_scope=scope,\n",
    "        performance_return=time_series_of_returns,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Get returns out of LUSID\n",
    "\n",
    "# 5.1 Call a table of returns data for our three portfolios "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_returns_since_inc(portfolio_code):\n",
    "\n",
    "    returns = portfolios_api.get_portfolio_aggregated_returns(\n",
    "        scope=scope,\n",
    "        code=portfolio_code,\n",
    "        aggregated_returns_request={\n",
    "            \"metrics\": [{\"window\": \"SINCE(2014-01-01)\"}],\n",
    "            \"returnIds\": [{\"code\": return_code, \"scope\": scope}],\n",
    "            \"recipeId\": {\"code\": \"FxRates\", \"scope\": scope},\n",
    "            \"period\": \"Daily\",\n",
    "            \"outputFrequency\": \"Daily\",\n",
    "        },\n",
    "        from_effective_at=from_effective_at,\n",
    "        to_effective_at=to_effective_at,\n",
    "    )\n",
    "\n",
    "    return returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_summary_df = pd.DataFrame(\n",
    "    columns=[\"effective_at\", \"metrics_value.SINCE(2014-01-01)\"]\n",
    ")\n",
    "\n",
    "\n",
    "for portfolio in list_of_porfolios:\n",
    "\n",
    "    portfolio_summary_df = pd.DataFrame(\n",
    "        columns=[\"effective_at\", \"metrics_value.SINCE(2014-01-01)\"]\n",
    "    )\n",
    "\n",
    "    returns = get_returns_since_inc(portfolio)\n",
    "\n",
    "    for item in returns.results[f\"{scope}/{return_code}\"]:\n",
    "\n",
    "        normalize_json = json_normalize(item.to_dict())\n",
    "        normalize_json = normalize_json.set_index(\"effective_at\").copy()\n",
    "        portfolio_summary_df = pd.concat(\n",
    "            [portfolio_summary_df, normalize_json]\n",
    "        ).reset_index(drop=True)\n",
    "\n",
    "    all_summary_df = all_summary_df.join(\n",
    "        portfolio_summary_df, rsuffix=f\"{portfolio}\", on=\"effective_at\", how=\"outer\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "summary_columns = {\n",
    "    \"metrics_value.SINCE(2014-01-01)ukActiveEquity\": \"ukActiveEquity\",\n",
    "    \"metrics_value.SINCE(2014-01-01)ukActiveFI\": \"ukActiveFI\",\n",
    "    \"metrics_value.SINCE(2014-01-01)ukMa\": \"ukMa\",\n",
    "    \"metrics_value.SINCE(2014-01-01)composite\": \"composite\",\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_summary_df = (\n",
    "    all_summary_df[list(summary_columns.keys())].rename(columns=summary_columns).copy()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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>ukActiveEquity</th>\n",
       "      <th>ukActiveFI</th>\n",
       "      <th>ukMa</th>\n",
       "      <th>composite</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.00000</td>\n",
       "      <td>0.00000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.00058</td>\n",
       "      <td>0.00922</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00434</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.00321</td>\n",
       "      <td>0.00065</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.00936</td>\n",
       "      <td>0.00410</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00682</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.02007</td>\n",
       "      <td>0.00401</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.01215</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.03400</td>\n",
       "      <td>0.01163</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.02291</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.04182</td>\n",
       "      <td>0.00333</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.02264</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.04823</td>\n",
       "      <td>-0.00669</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.02075</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.04923</td>\n",
       "      <td>-0.00596</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.02161</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ukActiveEquity  ukActiveFI ukMa  composite\n",
       "0         0.00000     0.00000  NaN    0.00000\n",
       "1        -0.00058     0.00922  NaN    0.00434\n",
       "2         0.00321     0.00065  NaN    0.00202\n",
       "3         0.00936     0.00410  NaN    0.00682\n",
       "4         0.02007     0.00401  NaN    0.01215\n",
       "5         0.03400     0.01163  NaN    0.02291\n",
       "6         0.04182     0.00333  NaN    0.02264\n",
       "7         0.04823    -0.00669  NaN    0.02075\n",
       "8         0.04923    -0.00596  NaN    0.02161"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_summary_df.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 Plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_series_performance():\n",
    "    ts_performance = all_summary_df.plot(\n",
    "        y=[\"ukActiveEquity\", \"ukActiveFI\", \"ukMa\", \"composite\"], figsize=(12, 9)\n",
    "    )\n",
    "    ts_performance.set_title(\n",
    "        f\"Performance since 2014-01-01\",\n",
    "        fontsize=\"large\",\n",
    "    )\n",
    "    ts_performance.set_ylabel(\"Performance in %\", fontsize=\"large\")\n",
    "    ts_performance.set_xlabel(\"Days\", fontsize=\"large\")\n",
    "    ts_performance.legend(prop={\"size\": 12})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_series_performance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CLEAN UP - Delete Portfolios\n",
    "for port in portfolio_codes:\n",
    "\n",
    "    try:\n",
    "\n",
    "        response = portfolios_api.delete_portfolio(scope=scope, code=port)\n",
    "    except lusid.ApiException as e:\n",
    "        print(json.loads(e.body)[\"title\"])"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}