{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5f6ccd5b",
   "metadata": {},
   "source": [
    "# CapiPort - PORTFOLIO OPTIMISATION"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1962897",
   "metadata": {},
   "source": [
    "    Two things to consider for Portfolio Optimisation:\n",
    "    \n",
    "        1) Minimising Risk\n",
    "        2) Maximising Return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d025126",
   "metadata": {},
   "source": [
    "    Basic process of Portfolio Optimisation:\n",
    "        \n",
    "        1) Select the Asset class to work on.\n",
    "            1.1) Asset Class choosen - Equity (Stocks)\n",
    "        2) Select the Companies which you want to use to build a Portfolio.\n",
    "            2.1) Companies choosen - \n",
    "                2.1.1) Tata Power - TATAPOWER.NS\n",
    "                2.1.2) Tata Motors - TATAMOTORS.NS\n",
    "                2.1.3) Tata Steel - TATASTEEL.NS\n",
    "                2.1.4) Zomato - ZOMATO.NS\n",
    "                2.1.5) NHPC - NHPC.NS\n",
    "                2.1.6) NCC - NCC.NS\n",
    "                2.1.7) IREDA - IREDA.NS\n",
    "                2.1.8) IRCON - IRCON.NS\n",
    "        3) To try various Statistical Methods relating to Portfolio Optimisation.\n",
    "            3.1) Method 1 - Result\n",
    "            3.2) Method 2 - Result\n",
    "        4) You will obtain Weigths or Percentages of Portfolio to invest.\n",
    "            4.1) Method 1 - Weights\n",
    "            4.2) Method 2 - Weights\n",
    "        5) Testing the Portfolio for the future.\n",
    "            5.1) Method 1 - Result\n",
    "            5.2) Method 2 - Result\n",
    "        6) Final Result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a80152f2",
   "metadata": {},
   "source": [
    "# <u>Steps of Implementation</u>\n",
    "\n",
    "    1) Importing Libraries\n",
    "    2) Select the Financial Instruments\n",
    "    3) Get the Adjacent Close prices of Last 5 Years\n",
    "    4) Calculating the Log-Return of Company Dataset\n",
    "    5) Calculating the Sharpe Ratio\n",
    "    6) Getting Started with Monte Carlo\n",
    "    7) Let's look closer at the Simulations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42c5d329",
   "metadata": {},
   "source": [
    "## Importing Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "945bbd48",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:35.347796Z",
     "start_time": "2024-03-07T20:09:30.939936Z"
    }
   },
   "outputs": [],
   "source": [
    "import pathlib\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.optimize as sci_opt\n",
    "\n",
    "from pprint import pprint\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "import yfinance as yf\n",
    "\n",
    "# Set some display options for Pandas.\n",
    "pd.set_option('expand_frame_repr', False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dbc2573",
   "metadata": {},
   "source": [
    "## Select the Financial Instruments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "08345846",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:37.966003Z",
     "start_time": "2024-03-07T20:09:37.963670Z"
    }
   },
   "outputs": [],
   "source": [
    "## Have Choosen Stocks\n",
    "\n",
    "## The Companies selected to build a Optimal Portfolio\n",
    "com_sel = [\"TATAPOWER.NS\", \"TATAMOTORS.NS\", \"TATASTEEL.NS\", \"RELIANCE.NS\", \"ADANIENT.NS\", \"ADANIPORTS.NS\"]\n",
    "\n",
    "## We will need Number of Tickers for future\n",
    "num_tick = len(com_sel)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2376a747",
   "metadata": {},
   "source": [
    "## Get the Adjacent Close prices of Last 5 Years"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cb64a4c0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:39.680530Z",
     "start_time": "2024-03-07T20:09:38.995900Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[*********************100%%**********************]  6 of 6 completed\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>Ticker</th>\n",
       "      <th>ADANIENT.NS</th>\n",
       "      <th>ADANIPORTS.NS</th>\n",
       "      <th>RELIANCE.NS</th>\n",
       "      <th>TATAMOTORS.NS</th>\n",
       "      <th>TATAPOWER.NS</th>\n",
       "      <th>TATASTEEL.NS</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-03-01</th>\n",
       "      <td>132.264633</td>\n",
       "      <td>322.673431</td>\n",
       "      <td>1098.479858</td>\n",
       "      <td>179.739807</td>\n",
       "      <td>61.861305</td>\n",
       "      <td>43.332832</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-05</th>\n",
       "      <td>140.120468</td>\n",
       "      <td>328.532288</td>\n",
       "      <td>1108.873047</td>\n",
       "      <td>193.447083</td>\n",
       "      <td>63.798790</td>\n",
       "      <td>44.540791</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-06</th>\n",
       "      <td>137.600662</td>\n",
       "      <td>326.401764</td>\n",
       "      <td>1133.197876</td>\n",
       "      <td>188.213394</td>\n",
       "      <td>65.782410</td>\n",
       "      <td>44.463959</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-07</th>\n",
       "      <td>135.278503</td>\n",
       "      <td>330.130127</td>\n",
       "      <td>1138.080811</td>\n",
       "      <td>188.711853</td>\n",
       "      <td>65.090462</td>\n",
       "      <td>44.489571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-08</th>\n",
       "      <td>136.563110</td>\n",
       "      <td>331.340698</td>\n",
       "      <td>1135.258667</td>\n",
       "      <td>180.637009</td>\n",
       "      <td>64.583015</td>\n",
       "      <td>43.354172</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Ticker      ADANIENT.NS  ADANIPORTS.NS  RELIANCE.NS  TATAMOTORS.NS  TATAPOWER.NS  TATASTEEL.NS\n",
       "Date                                                                                          \n",
       "2019-03-01   132.264633     322.673431  1098.479858     179.739807     61.861305     43.332832\n",
       "2019-03-05   140.120468     328.532288  1108.873047     193.447083     63.798790     44.540791\n",
       "2019-03-06   137.600662     326.401764  1133.197876     188.213394     65.782410     44.463959\n",
       "2019-03-07   135.278503     330.130127  1138.080811     188.711853     65.090462     44.489571\n",
       "2019-03-08   136.563110     331.340698  1135.258667     180.637009     64.583015     43.354172"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "com_data = yf.download(com_sel, start=\"2019-03-01\", end=\"2024-03-01\")['Adj Close']\n",
    "\n",
    "com_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbc4ccf9",
   "metadata": {},
   "source": [
    "## Calculating the Log-Return of Company Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "49aadb44",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:40.540798Z",
     "start_time": "2024-03-07T20:09:40.536374Z"
    }
   },
   "outputs": [],
   "source": [
    "## Log-Return of Company Dataset\n",
    "log_return = np.log(1 + com_data.pct_change())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a3b8f50",
   "metadata": {},
   "source": [
    "## Calculating the Sharpe Ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f91abb2c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:41.663993Z",
     "start_time": "2024-03-07T20:09:41.653810Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "==========================================================================================\n",
      "PORTFOLIO WEIGHTS:\n",
      "------------------------------------------------------------------------------------------\n",
      "   random_weights  rebalance_weights\n",
      "0        0.106868           0.036601\n",
      "1        0.491893           0.168466\n",
      "2        0.523100           0.179154\n",
      "3        0.552735           0.189304\n",
      "4        0.786875           0.269493\n",
      "5        0.458361           0.156982\n",
      "------------------------------------------------------------------------------------------\n",
      "\n",
      "==========================================================================================\n",
      "PORTFOLIO METRICS:\n",
      "------------------------------------------------------------------------------------------\n",
      "   Expected Portfolio Returns  Expected Portfolio Volatility  Portfolio Sharpe Ratio\n",
      "0                       0.303                       0.286268                1.058451\n",
      "------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "## Generate Random Weights\n",
    "rand_weig = np.array(np.random.random(num_tick))\n",
    "\n",
    "## Rebalancing Random Weights\n",
    "rebal_weig = rand_weig / np.sum(rand_weig)\n",
    "\n",
    "## Calculate the Expected Returns, Annualize it by * 247.0\n",
    "exp_ret = np.sum((log_return.mean() * rebal_weig) * 247)\n",
    "\n",
    "## Calculate the Expected Volatility, Annualize it by * 247.0\n",
    "exp_vol = np.sqrt(\n",
    "np.dot(\n",
    "    rebal_weig.T,\n",
    "    np.dot(\n",
    "        log_return.cov() * 247,\n",
    "        rebal_weig\n",
    "    )\n",
    ")\n",
    ")\n",
    "\n",
    "## Calculate the Sharpe Ratio.\n",
    "sharpe_ratio = exp_ret / exp_vol\n",
    "\n",
    "# Put the weights into a data frame to see them better.\n",
    "weights_df = pd.DataFrame(data={\n",
    "'random_weights': rand_weig,\n",
    "'rebalance_weights': rebal_weig\n",
    "})\n",
    "print('')\n",
    "print('='*90)\n",
    "print('PORTFOLIO WEIGHTS:')\n",
    "print('-'*90)\n",
    "print(weights_df)\n",
    "print('-'*90)\n",
    "\n",
    "# Do the same with the other metrics.\n",
    "metrics_df = pd.DataFrame(data={\n",
    "    'Expected Portfolio Returns': exp_ret,\n",
    "    'Expected Portfolio Volatility': exp_vol,\n",
    "    'Portfolio Sharpe Ratio': sharpe_ratio\n",
    "}, index=[0])\n",
    "\n",
    "print('')\n",
    "print('='*90)\n",
    "print('PORTFOLIO METRICS:')\n",
    "print('-'*90)\n",
    "print(metrics_df)\n",
    "print('-'*90)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22925bff",
   "metadata": {},
   "source": [
    "## Getting Started with Monte Carlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7abe8654",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:42.830884Z",
     "start_time": "2024-03-07T20:09:42.827059Z"
    }
   },
   "outputs": [],
   "source": [
    "## Let's get started with Monte Carlo Simulations\n",
    "\n",
    "## How many times should we run Monte Carlo\n",
    "num_of_port = 20000\n",
    "\n",
    "## Create an Array to store the weights as they are generated\n",
    "all_weights = np.zeros((num_of_port, num_tick))\n",
    "\n",
    "## Create an Array to store the returns as they are generated\n",
    "ret_arr = np.zeros(num_of_port)\n",
    "\n",
    "## Create an Array to store the volatilities as they are generated\n",
    "vol_arr = np.zeros(num_of_port)\n",
    "\n",
    "## Create an Array to store the Sharpe Ratios as they are generated\n",
    "sharpe_arr = np.zeros(num_of_port)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d81282dd",
   "metadata": {},
   "source": [
    "## Monte Carlo Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9150b622",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:52.035492Z",
     "start_time": "2024-03-07T20:09:43.833813Z"
    }
   },
   "outputs": [],
   "source": [
    "## Let's start the Monte Carlo Simulation\n",
    "\n",
    "for ind in range(num_of_port):\n",
    "    \n",
    "    ## Let's first Calculate the Weights\n",
    "    weig = np.array(np.random.random(num_tick))\n",
    "    weig = weig / np.sum(weig)\n",
    "    \n",
    "    ## Append the Weights to Weigths array\n",
    "    all_weights[ind, :] = weig\n",
    "    \n",
    "    ## Calculate and Append the Expected Log Returns to Returns Array\n",
    "    ret_arr[ind] = np.sum((log_return.mean() * weig) * 247)\n",
    "    \n",
    "    ## Calculate and Append the Volatility to the Volatitlity Array\n",
    "    vol_arr[ind] = np.sqrt(\n",
    "        np.dot(weig.T, np.dot(log_return.cov() * 247, weig))\n",
    "    )\n",
    "    \n",
    "    ## Calculate and Append the Sharpe Ratio to Sharpe Ratio Array\n",
    "    sharpe_arr[ind] = ret_arr[ind] / vol_arr[ind]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d496de6c",
   "metadata": {},
   "source": [
    "## Let's look closer at the Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c6b2b637",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:52.335274Z",
     "start_time": "2024-03-07T20:09:52.040485Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "==========================================================================================\n",
      "SIMULATIONS RESULT:\n",
      "------------------------------------------------------------------------------------------\n",
      "    Returns  Volatility  Sharpe Ratio                                  Portfolio Weights\n",
      "0  0.348837    0.304359      1.146135  [0.1690690056838101, 0.229961952530237, 0.1738...\n",
      "1  0.311647    0.288966      1.078490  [0.15583695704909642, 0.3148456337062344, 0.37...\n",
      "2  0.380132    0.333072      1.141290  [0.24692548531911288, 0.27348838795746494, 0.0...\n",
      "3  0.359978    0.311953      1.153948  [0.2204412846189971, 0.031119722138497567, 0.1...\n",
      "4  0.342977    0.317469      1.080351  [0.1618750270568406, 0.11395237163220999, 0.10...\n",
      "------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "## Let's create a Data Frame with Weights, Returns, Volatitlity, and the Sharpe Ratio\n",
    "sim_data = [ret_arr, vol_arr, sharpe_arr, all_weights]\n",
    "\n",
    "## Create a Data Frame using above, then Transpose it\n",
    "sim_df = pd.DataFrame(data = sim_data).T\n",
    "\n",
    "## Give the columns in Simulation Data Proper Names\n",
    "sim_df.columns = [\n",
    "    'Returns',\n",
    "    'Volatility',\n",
    "    'Sharpe Ratio',\n",
    "    'Portfolio Weights'\n",
    "]\n",
    "\n",
    "## Make sure the Data Types are correct in the Data Frame\n",
    "sim_df = sim_df.infer_objects()\n",
    "\n",
    "# Print out the results.\n",
    "print('')\n",
    "print('='*90)\n",
    "print('SIMULATIONS RESULT:')\n",
    "print('-'*90)\n",
    "print(sim_df.head())\n",
    "print('-'*90)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "836a92d8",
   "metadata": {},
   "source": [
    "## Look at Important Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "190b2de9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:52.346009Z",
     "start_time": "2024-03-07T20:09:52.337508Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "MAX SHARPE RATIO:\n",
      "--------------------------------------------------------------------------------\n",
      "Returns                                                       0.477027\n",
      "Volatility                                                    0.363963\n",
      "Sharpe Ratio                                                  1.310648\n",
      "Portfolio Weights    [0.4840066921566578, 0.04011284279744121, 0.05...\n",
      "Name: 3737, dtype: object\n",
      "--------------------------------------------------------------------------------\n",
      "\n",
      "================================================================================\n",
      "MIN VOLATILITY:\n",
      "--------------------------------------------------------------------------------\n",
      "Returns                                                       0.264526\n",
      "Volatility                                                    0.260549\n",
      "Sharpe Ratio                                                  1.015263\n",
      "Portfolio Weights    [0.041974048159546716, 0.1147461556730666, 0.4...\n",
      "Name: 12541, dtype: object\n",
      "--------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Return the Max Sharpe Ratio from the run.\n",
    "max_sharpe_ratio = sim_df.loc[sim_df['Sharpe Ratio'].idxmax()]\n",
    "\n",
    "# Return the Min Volatility from the run.\n",
    "min_volatility = sim_df.loc[sim_df['Volatility'].idxmin()]\n",
    "\n",
    "print('')\n",
    "print('='*80)\n",
    "print('MAX SHARPE RATIO:')\n",
    "print('-'*80)\n",
    "print(max_sharpe_ratio)\n",
    "print('-'*80)\n",
    "\n",
    "print('')\n",
    "print('='*80)\n",
    "print('MIN VOLATILITY:')\n",
    "print('-'*80)\n",
    "print(min_volatility)\n",
    "print('-'*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad243990",
   "metadata": {},
   "source": [
    "## Let's Visualize the Monte Carlo Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "751eab2f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:52.835850Z",
     "start_time": "2024-03-07T20:09:52.351612Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/jx/_r4pg95j3pzdd581p_wql9pc0000gn/T/ipykernel_3957/3549902619.py:20: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  max_sharpe_ratio[1],\n",
      "/var/folders/jx/_r4pg95j3pzdd581p_wql9pc0000gn/T/ipykernel_3957/3549902619.py:21: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  max_sharpe_ratio[0],\n",
      "/var/folders/jx/_r4pg95j3pzdd581p_wql9pc0000gn/T/ipykernel_3957/3549902619.py:29: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  min_volatility[1],\n",
      "/var/folders/jx/_r4pg95j3pzdd581p_wql9pc0000gn/T/ipykernel_3957/3549902619.py:30: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  min_volatility[0],\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This is so I can see the plot inside of my Jupyter Notebook.\n",
    "%matplotlib inline\n",
    "\n",
    "# Plot the data on a Scatter plot.\n",
    "plt.scatter(\n",
    "    y=sim_df['Returns'],\n",
    "    x=sim_df['Volatility'],\n",
    "    c=sim_df['Sharpe Ratio'],\n",
    "    cmap='RdYlBu'\n",
    ")\n",
    "\n",
    "# Give the Plot some labels, and titles.\n",
    "plt.title('Portfolio Returns Vs. Risk')\n",
    "plt.colorbar(label='Sharpe Ratio')\n",
    "plt.xlabel('Standard Deviation')\n",
    "plt.ylabel('Returns')\n",
    "\n",
    "# Plot the Max Sharpe Ratio, using a `Red Star`.\n",
    "plt.scatter(\n",
    "    max_sharpe_ratio[1],\n",
    "    max_sharpe_ratio[0],\n",
    "    marker=(5, 1, 0),\n",
    "    color='r',\n",
    "    s=600\n",
    ")\n",
    "\n",
    "# Plot the Min Volatility, using a `Blue Star`.\n",
    "plt.scatter(\n",
    "    min_volatility[1],\n",
    "    min_volatility[0],\n",
    "    marker=(5, 1, 0),\n",
    "    color='b',\n",
    "    s=600\n",
    ")\n",
    "\n",
    "# Finally, show the plot.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "759a52dd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:52.848946Z",
     "start_time": "2024-03-07T20:09:52.840460Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "728a0752",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-07T20:09:52.860738Z",
     "start_time": "2024-03-07T20:09:52.853368Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc534b3e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}