examples/Example - Using Loman to Value a Portfolio.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example: Using Loman to Value a Portfolio\n",
    "\n",
    "In this example, we'll look at valuing a simple portfolio composed of equities and futures. In additional, we'll calculate an intraday P&L, and some simple exposure measures.\n",
    "\n",
    "The main challenge of valuing and risk-managing a multi-asset portfolio is that each asset type must be treated differently. Position, market and static data for each asset type must typically be sourced from separate systems and then integrated into a single holistic view. Loman excels at this sort of task, making it easy to add new nodes as new sources of data become available, or as new calculations are required.\n",
    "\n",
    "To simplify exposition, we have deliberately limited the number of asset types we treat, and the number of measures we calculate. However, it should be easy to see that the techniques applied here can be extended naturally to more complex portfolios.\n",
    "\n",
    "To make sure that this example is as widely accessible as possible, we have used publicly available data sources. For actual investing use, we strongly recommend investigating paid services to access higher quality data (and which typically requires less processing to use).\n",
    "\n",
    "This example makes heavy use of Pandas dataframes. If you haven't come across Pandas before, definitely take a look: http://pandas.pydata.org/. Dataframes are an in-memory table object, and have gained popularity for many data-processing tasks.\n",
    "\n",
    "## Raw Holdings Data\n",
    "\n",
    "Ok, let's get going! We start, as usual, by creating a Loman Computation object, which we shall populate with data and calculations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import loman\n",
    "\n",
    "comp = loman.Computation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing we shall need is holdings data. For this example, we assume that holdings data is provided in a CSV format, and insert that CSV data into a node in the computation called **holdings** using the `add_node` method.\n",
    "\n",
    "The portfolio itself consist of 5 equities from an arbitrary [CNN Money article](http://money.cnn.com/2016/12/28/investing/stocks-to-buy-2017/), together with a short S&P E-mini future to approximately hedge overall market exposure. (Our choice of article should not be construed as a recommendation for or against the content of that article, or the site as a whole)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "holdings = \"\"\"Type,Symbol,Qty,CostBasis\n",
    "Equity,AVGO,126,22680\n",
    "Equity,EVHC,349,22685\n",
    "Equity,STT,287,22673\n",
    "Equity,DAL,454,22700\n",
    "Equity,DY,283,22640\n",
    "Future,ESM7,-1,0\n",
    "Cash,USD,2000,\n",
    "\"\"\"\n",
    "comp.add_node('holdings', value=holdings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial Processing of Holdings Data\n",
    "\n",
    "We need to convert this CSV text data into a usable form.\n",
    "\n",
    "The `@loman.node` decorator allows us to insert a new node into the computation, using the name of the function as the name of the node. Any parameters of the function that are named the same as nodes in the computation will take the values of those nodes when the function is called.\n",
    "\n",
    "Here we use the `@loman.node` decorator to create a new node, called **df_holdings**, which will be calculated from the node **holdings** that we defined above. The function simply reads the CSV data into a Pandas dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from io import StringIO\n",
    "import pandas as pd\n",
    "\n",
    "@loman.node(comp)\n",
    "def df_holdings(holdings):\n",
    "    f = StringIO(holdings)\n",
    "    df = pd.read_csv(f)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily see the structure of a computation, although at this stage it is pretty simple. There is a node **holdings**, in dark green because we set its value, and so it is up-to-date. And there is a second node **df_holdings**, which depends on **holdings**, as shown by the arrow. The lighter green color tells us the **df_holdings** is computable, but not currently up-to-date, which we expect, as we have not told Loman to calculate it yet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n",
       "<!-- Generated by graphviz version 2.38.0 (20140413.2041)\r\n",
       " -->\r\n",
       "<!-- Title: G Pages: 1 -->\r\n",
       "<svg width=\"116pt\" height=\"116pt\"\r\n",
       " viewBox=\"0.00 0.00 115.89 116.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 112)\">\r\n",
       "<title>G</title>\r\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-112 111.89,-112 111.89,4 -4,4\"/>\r\n",
       "<!-- n0 -->\r\n",
       "<g id=\"node1\" class=\"node\"><title>n0</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"53.9452\" cy=\"-90\" rx=\"41.6928\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"53.9452\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">holdings</text>\r\n",
       "</g>\r\n",
       "<!-- n1 -->\r\n",
       "<g id=\"node2\" class=\"node\"><title>n1</title>\r\n",
       "<ellipse fill=\"#9dff00\" stroke=\"black\" cx=\"53.9452\" cy=\"-18\" rx=\"53.8905\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"53.9452\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_holdings</text>\r\n",
       "</g>\r\n",
       "<!-- n0&#45;&gt;n1 -->\r\n",
       "<g id=\"edge1\" class=\"edge\"><title>n0&#45;&gt;n1</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M53.9452,-71.6966C53.9452,-63.9827 53.9452,-54.7125 53.9452,-46.1124\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"57.4453,-46.1043 53.9452,-36.1043 50.4453,-46.1044 57.4453,-46.1043\"/>\r\n",
       "</g>\r\n",
       "</g>\r\n",
       "</svg>\r\n"
      ],
      "text/plain": [
       "<loman.computeengine.Computation at 0x16710a16f98>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we can go ahead and calculate **df_holdings** and check that it looks correct. Computation objects have an attribute-based accessor, `v`, which allows us to see the value of any node. It also works great with the auto-complete in interactive environments, such as IPython Notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>CostBasis</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Equity</td>\n",
       "      <td>AVGO</td>\n",
       "      <td>126</td>\n",
       "      <td>22680.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Equity</td>\n",
       "      <td>EVHC</td>\n",
       "      <td>349</td>\n",
       "      <td>22685.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Equity</td>\n",
       "      <td>STT</td>\n",
       "      <td>287</td>\n",
       "      <td>22673.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DAL</td>\n",
       "      <td>454</td>\n",
       "      <td>22700.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DY</td>\n",
       "      <td>283</td>\n",
       "      <td>22640.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Future</td>\n",
       "      <td>ESM7</td>\n",
       "      <td>-1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Cash</td>\n",
       "      <td>USD</td>\n",
       "      <td>2000</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Type Symbol   Qty  CostBasis\n",
       "0  Equity   AVGO   126    22680.0\n",
       "1  Equity   EVHC   349    22685.0\n",
       "2  Equity    STT   287    22673.0\n",
       "3  Equity    DAL   454    22700.0\n",
       "4  Equity     DY   283    22640.0\n",
       "5  Future   ESM7    -1        0.0\n",
       "6    Cash    USD  2000        NaN"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.compute('df_holdings')\n",
    "comp.v.df_holdings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quick sidenote: It is the nature of these examples that I present the computations in their complete state, with no mention of the struggle that it took to get them there. That's a shame, because one of the really great things about working with Loman is that you can iterate on a single node - even one in the middle of a calculation - without having to recalculate any of the upstream or downstream nodes if you don't want to. In this case, it doesn't make a huge amount of difference, but when dealing with large data sets and time-consuming calculations, it can be a boon not to have to wait a couple of minutes to see the results of your latest update to an intermediate calculation.\n",
    "\n",
    "## Splitting the Holdings by Asset Type\n",
    "\n",
    "Back to the main plot. We will need to source different market data for each type of asset that we hold, and perform different calculations to boot. To this end, we split **df_holdings** into three separate DataFrames, one for each asset type, in nodes **df_holdings_equity**, **df_holdings_future** and **df_holdings_cash**.\n",
    "\n",
    "We use a single function for calculating each of the nodes, and provide different values to the `type` parameter. As before, the Loman knows that the df_holdings argument will be populated from the **df_holdings** node. We use the `kwds` parameter to `add_node` to tell Loman that the parameter `type` should be a constant, rather than taken from a node. Thus the **df_holdings_equity** node will be calculated using the **df_holdings** node, and the constant `'Equity'`, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def filter_df(df_holdings, type):\n",
    "    return df_holdings[df_holdings.Type == type]\n",
    "comp.add_node('df_holdings_equity', filter_df, kwds={'type': loman.C('Equity')})\n",
    "comp.add_node('df_holdings_future', filter_df, kwds={'type': loman.C('Future')})\n",
    "comp.add_node('df_holdings_cash', filter_df, kwds={'type': loman.C('Cash')})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, we can compute nodes and inspect the results to make sure they are as we expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>CostBasis</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Equity</td>\n",
       "      <td>AVGO</td>\n",
       "      <td>126</td>\n",
       "      <td>22680.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Equity</td>\n",
       "      <td>EVHC</td>\n",
       "      <td>349</td>\n",
       "      <td>22685.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Equity</td>\n",
       "      <td>STT</td>\n",
       "      <td>287</td>\n",
       "      <td>22673.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DAL</td>\n",
       "      <td>454</td>\n",
       "      <td>22700.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DY</td>\n",
       "      <td>283</td>\n",
       "      <td>22640.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Type Symbol  Qty  CostBasis\n",
       "0  Equity   AVGO  126    22680.0\n",
       "1  Equity   EVHC  349    22685.0\n",
       "2  Equity    STT  287    22673.0\n",
       "3  Equity    DAL  454    22700.0\n",
       "4  Equity     DY  283    22640.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.compute_all()\n",
    "comp.v.df_holdings_equity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>CostBasis</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Future</td>\n",
       "      <td>ESM7</td>\n",
       "      <td>-1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Type Symbol  Qty  CostBasis\n",
       "5  Future   ESM7   -1        0.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.v.df_holdings_future"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>CostBasis</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Cash</td>\n",
       "      <td>USD</td>\n",
       "      <td>2000</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Type Symbol   Qty  CostBasis\n",
       "6  Cash    USD  2000        NaN"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.v.df_holdings_cash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gathering Market Data\n",
    "\n",
    "To do a portfolio valuation, and calculate exposure metrics, we will need market data. The market data we need will be different for each type of asset. We start first with the equity portfolio.\n",
    "\n",
    "### Equity Prices from Yahoo\n",
    "\n",
    "We add node **df_equity_yql_data_yahoo**, and we populate it by applying the function `get_yahoo_equity_data` to each Symbol in **df_holdings_equity**, the DataFrame with our equity holdings, in turn. The yahoo_finance library returns a dictionary, for each symbol, so we turn each of those into a row, and **df_equity_yql_data_yahoo** will contain a DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import yahoo_finance\n",
    "\n",
    "def get_yahoo_equity_data(symbol):\n",
    "    s = yahoo_finance.Share(symbol)\n",
    "    return pd.Series(s.data_set)\n",
    "\n",
    "@loman.node(comp)\n",
    "def df_equity_yql_data_yahoo(df_holdings_equity):\n",
    "    return df_holdings_equity.Symbol.apply(get_yahoo_equity_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, we can compute and inspect the node to see what it contains. Yahoo returns a large number of fields, and we capture them all. For now, we will only use a small number of those fields, but there is no extra cost to capture them, and they may be useful for other calculations that we would want to add in the future - for example, we may want to calculate sets of alerts as prices fall below certain moving averages, say."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AfterHoursChangeRealtime</th>\n",
       "      <th>AnnualizedGain</th>\n",
       "      <th>Ask</th>\n",
       "      <th>AskRealtime</th>\n",
       "      <th>AverageDailyVolume</th>\n",
       "      <th>Bid</th>\n",
       "      <th>BidRealtime</th>\n",
       "      <th>BookValue</th>\n",
       "      <th>Change</th>\n",
       "      <th>ChangeFromFiftydayMovingAverage</th>\n",
       "      <th>...</th>\n",
       "      <th>StockExchange</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>TickerTrend</th>\n",
       "      <th>TradeDate</th>\n",
       "      <th>TwoHundreddayMovingAverage</th>\n",
       "      <th>Volume</th>\n",
       "      <th>YearHigh</th>\n",
       "      <th>YearLow</th>\n",
       "      <th>YearRange</th>\n",
       "      <th>symbol</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>221.95</td>\n",
       "      <td>None</td>\n",
       "      <td>2400980</td>\n",
       "      <td>220.41</td>\n",
       "      <td>None</td>\n",
       "      <td>47.55</td>\n",
       "      <td>+0.51</td>\n",
       "      <td>2.30</td>\n",
       "      <td>...</td>\n",
       "      <td>NMS</td>\n",
       "      <td>AVGO</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>194.77</td>\n",
       "      <td>1533863</td>\n",
       "      <td>227.75</td>\n",
       "      <td>139.18</td>\n",
       "      <td>139.18 - 227.75</td>\n",
       "      <td>AVGO</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>1653080</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>57.91</td>\n",
       "      <td>+0.15</td>\n",
       "      <td>-4.19</td>\n",
       "      <td>...</td>\n",
       "      <td>NYQ</td>\n",
       "      <td>EVHC</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>54.35</td>\n",
       "      <td>1700248</td>\n",
       "      <td>82.66</td>\n",
       "      <td>53.12</td>\n",
       "      <td>53.12 - 82.66</td>\n",
       "      <td>EVHC</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>2260140</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>47.19</td>\n",
       "      <td>+0.04</td>\n",
       "      <td>4.75</td>\n",
       "      <td>...</td>\n",
       "      <td>NYQ</td>\n",
       "      <td>STT</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>78.02</td>\n",
       "      <td>2225627</td>\n",
       "      <td>85.38</td>\n",
       "      <td>50.60</td>\n",
       "      <td>50.60 - 85.38</td>\n",
       "      <td>STT</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>8545340</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>17.78</td>\n",
       "      <td>-0.04</td>\n",
       "      <td>-0.42</td>\n",
       "      <td>...</td>\n",
       "      <td>NYQ</td>\n",
       "      <td>DAL</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>47.42</td>\n",
       "      <td>6378922</td>\n",
       "      <td>52.76</td>\n",
       "      <td>32.60</td>\n",
       "      <td>32.60 - 52.76</td>\n",
       "      <td>DAL</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>650651</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>19.58</td>\n",
       "      <td>+0.89</td>\n",
       "      <td>9.52</td>\n",
       "      <td>...</td>\n",
       "      <td>NYQ</td>\n",
       "      <td>DY</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>85.42</td>\n",
       "      <td>415220</td>\n",
       "      <td>109.65</td>\n",
       "      <td>66.09</td>\n",
       "      <td>66.09 - 109.65</td>\n",
       "      <td>DY</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 84 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "  AfterHoursChangeRealtime AnnualizedGain     Ask AskRealtime  \\\n",
       "0                     None           None  221.95        None   \n",
       "1                     None           None    None        None   \n",
       "2                     None           None    None        None   \n",
       "3                     None           None    None        None   \n",
       "4                     None           None    None        None   \n",
       "\n",
       "  AverageDailyVolume     Bid BidRealtime BookValue Change  \\\n",
       "0            2400980  220.41        None     47.55  +0.51   \n",
       "1            1653080    None        None     57.91  +0.15   \n",
       "2            2260140    None        None     47.19  +0.04   \n",
       "3            8545340    None        None     17.78  -0.04   \n",
       "4             650651    None        None     19.58  +0.89   \n",
       "\n",
       "  ChangeFromFiftydayMovingAverage  ...   StockExchange Symbol TickerTrend  \\\n",
       "0                            2.30  ...             NMS   AVGO        None   \n",
       "1                           -4.19  ...             NYQ   EVHC        None   \n",
       "2                            4.75  ...             NYQ    STT        None   \n",
       "3                           -0.42  ...             NYQ    DAL        None   \n",
       "4                            9.52  ...             NYQ     DY        None   \n",
       "\n",
       "  TradeDate TwoHundreddayMovingAverage   Volume YearHigh YearLow  \\\n",
       "0      None                     194.77  1533863   227.75  139.18   \n",
       "1      None                      54.35  1700248    82.66   53.12   \n",
       "2      None                      78.02  2225627    85.38   50.60   \n",
       "3      None                      47.42  6378922    52.76   32.60   \n",
       "4      None                      85.42   415220   109.65   66.09   \n",
       "\n",
       "         YearRange symbol  \n",
       "0  139.18 - 227.75   AVGO  \n",
       "1    53.12 - 82.66   EVHC  \n",
       "2    50.60 - 85.38    STT  \n",
       "3    32.60 - 52.76    DAL  \n",
       "4   66.09 - 109.65     DY  \n",
       "\n",
       "[5 rows x 84 columns]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.compute_all()\n",
    "comp.v.df_equity_yql_data_yahoo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scraping Equity Betas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We would also like betas for the equities in our portfolio. Unfortunately, Yahoo doesn't expose these through its YQL API, so we instead scrape the data directly from the page. Again, we'd like to strongly recommend using paid data sources to avoid this sort of hack. Nonetheless, this does demonstrate the power of the libraries available for Python, as well as showcasing Loman's ability to easily integrate multiple data sources.\n",
    "\n",
    "We use the same strategy of iterating over each Symbol in **df_holdings_equity**, this time applying the function `scrape_yahoo_data` to get a web page and read beta from it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import requests, bs4\n",
    "\n",
    "def scrape_yahoo_data(symbol):\n",
    "    resp = requests.get('https://finance.yahoo.com/quote/{}?ltr=1'.format(symbol))\n",
    "    soup = bs4.BeautifulSoup(resp.content, 'lxml')\n",
    "    el = soup.find(attrs={'data-test': 'BETA-value'})\n",
    "    beta = float(el.text)\n",
    "    return pd.Series({'Symbol': symbol, 'Beta': beta})\n",
    "\n",
    "@loman.node(comp)\n",
    "def df_equity_scraped_data_yahoo(df_holdings_equity):\n",
    "    return df_holdings_equity.Symbol.apply(scrape_yahoo_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And again, we quickly compute and inspect the result. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Beta</th>\n",
       "      <th>Symbol</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.12</td>\n",
       "      <td>AVGO</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.35</td>\n",
       "      <td>EVHC</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.29</td>\n",
       "      <td>STT</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.07</td>\n",
       "      <td>DAL</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.54</td>\n",
       "      <td>DY</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Beta Symbol\n",
       "0  1.12   AVGO\n",
       "1  0.35   EVHC\n",
       "2  1.29    STT\n",
       "3  1.07    DAL\n",
       "4  1.54     DY"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.compute_all()\n",
    "comp.v.df_equity_scraped_data_yahoo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Futures Prices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parsing of futures prices from scrapes of the CME's website is slightly more onerous, requiring the future code to be parsed from an attribute using a regex. To move the exposition along, we won't cover it in detail, but just show that the DataFrame of prices we obtain is sensible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import re\n",
    "from dateutil import relativedelta\n",
    "\n",
    "id_regex = re.compile('quotesFuturesProductTable1_(?P<Symbol>.{4})_(?P<Field>.*)')\n",
    "\n",
    "def get_el_data(el):\n",
    "    m = id_regex.match(el['id'])\n",
    "    d = m.groupdict()\n",
    "    d['Value'] = el.text\n",
    "    return d\n",
    "\n",
    "def try_float(x):\n",
    "    try:\n",
    "        return float(x)\n",
    "    except:\n",
    "        return np.nan\n",
    "\n",
    "@loman.node(comp)\n",
    "def df_future_prices():\n",
    "    resp = requests.get('http://www.cmegroup.com/trading/equity-index/us-index/e-mini-sandp500.html')\n",
    "    soup = bs4.BeautifulSoup(resp.content, 'lxml')\n",
    "    els = soup.findAll('td', attrs={'id': id_regex})    \n",
    "    df = pd.DataFrame([get_el_data(el) for el in els])\n",
    "    df = df.set_index(['Symbol', 'Field']).Value.unstack()\n",
    "    for col in ['change', 'high', 'last', 'low', 'open', 'volume']:\n",
    "        df[col] = df[col].apply(try_float)    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>Field</th>\n",
       "      <th>change</th>\n",
       "      <th>high</th>\n",
       "      <th>highLowLimits</th>\n",
       "      <th>last</th>\n",
       "      <th>low</th>\n",
       "      <th>open</th>\n",
       "      <th>priorSettle</th>\n",
       "      <th>updated</th>\n",
       "      <th>volume</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Symbol</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></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>ESH8</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2498.50 / 2260.50</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2380.75</td>\n",
       "      <td>00:23:14 CT 02 May 2017</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ESM7</th>\n",
       "      <td>-1.25</td>\n",
       "      <td>2388.25</td>\n",
       "      <td>2504.50 / 2266.50</td>\n",
       "      <td>2385.75</td>\n",
       "      <td>2384.25</td>\n",
       "      <td>2386.25</td>\n",
       "      <td>2387.00</td>\n",
       "      <td>01:30:12 CT 02 May 2017</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ESM8</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2499.50 / 2261.50</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2381.75</td>\n",
       "      <td>00:20:46 CT 02 May 2017</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ESU7</th>\n",
       "      <td>-1.25</td>\n",
       "      <td>2385.75</td>\n",
       "      <td>2502.00 / 2264.00</td>\n",
       "      <td>2383.25</td>\n",
       "      <td>2382.50</td>\n",
       "      <td>2383.75</td>\n",
       "      <td>2384.50</td>\n",
       "      <td>01:25:00 CT 02 May 2017</td>\n",
       "      <td>55.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ESZ7</th>\n",
       "      <td>-0.75</td>\n",
       "      <td>2382.00</td>\n",
       "      <td>2500.50 / 2262.50</td>\n",
       "      <td>2382.00</td>\n",
       "      <td>2382.00</td>\n",
       "      <td>2382.00</td>\n",
       "      <td>2382.75</td>\n",
       "      <td>00:59:41 CT 02 May 2017</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Field   change     high      highLowLimits     last      low     open  \\\n",
       "Symbol                                                                  \n",
       "ESH8       NaN      NaN  2498.50 / 2260.50      NaN      NaN      NaN   \n",
       "ESM7     -1.25  2388.25  2504.50 / 2266.50  2385.75  2384.25  2386.25   \n",
       "ESM8       NaN      NaN  2499.50 / 2261.50      NaN      NaN      NaN   \n",
       "ESU7     -1.25  2385.75  2502.00 / 2264.00  2383.25  2382.50  2383.75   \n",
       "ESZ7     -0.75  2382.00  2500.50 / 2262.50  2382.00  2382.00  2382.00   \n",
       "\n",
       "Field  priorSettle                  updated  volume  \n",
       "Symbol                                               \n",
       "ESH8       2380.75  00:23:14 CT 02 May 2017     0.0  \n",
       "ESM7       2387.00  01:30:12 CT 02 May 2017     NaN  \n",
       "ESM8       2381.75  00:20:46 CT 02 May 2017     0.0  \n",
       "ESU7       2384.50  01:25:00 CT 02 May 2017    55.0  \n",
       "ESZ7       2382.75  00:59:41 CT 02 May 2017     2.0  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.compute_all()\n",
    "comp.v.df_future_prices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need some static data for futures. In this case we need two things: First, the contract unit i.e. the dollar amount of each point move in the index. And secondly, the beta, which in this case (glossing over technicalities) is 1, since the underlying of the future is the index itself. In a real system, this data would be stored in a database or security master system, which we could of course access from Loman. To keep this example self-contained, here we hardcode our static data, and insert it into a node **df_future_static_data**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data = [\n",
    "    ['ESM7', 50, 'USD', 1.],\n",
    "    ['ESU7', 50, 'USD', 1.],\n",
    "    ['ESZ7', 50, 'USD', 1.],\n",
    "    ['ESH8', 50, 'USD', 1.],\n",
    "    ['ESM8', 50, 'USD', 1.],\n",
    "]\n",
    "df = pd.DataFrame(data, columns=['Symbol', 'UnitAmount', 'UnitCurrency', 'Beta'])\n",
    "comp.add_node('df_future_static_data', value=df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating P&Ls\n",
    "\n",
    "Finally, we come onto the interesting bit - using our holdings data and market data to calculate P&Ls and exposure measures.\n",
    "\n",
    "We start with the equity portion of the portfolio. We'll add a new node **df_equity_pnl**, which will contain a DataFrame with a row for each holding we have, together with the market and other information that we want. This node will depend on the three relevant nodes **df_holdings_equity** (containing holdings data), **df_equity_yql_data_yahoo** (containing prices) and **df_equity_scraped_data_yahoo** (containing betas), and so these are the parameters of the function defining the node **df_equity_pnl**.\n",
    "\n",
    "In the first part of the computation, we use Pandas merge functionality to join the tables, based on looking up Symbol in each table. We also take the opportunity to limit the set of columns taken from **df_equity_yql_data_yahoo**, and to rename columns to our liking.\n",
    "\n",
    "In the second part of the computation, we calculate several measures. For example, intraday PNL is current value less value at the close. And we define an exposure metric called CurrentBetaAdjExposure, which is defined as Beta $\\times$ Current Exposure (Current Exposure is just Current Value for equities).\n",
    "\n",
    "As always, we check the results as we go."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>CostBasis</th>\n",
       "      <th>Close</th>\n",
       "      <th>Last</th>\n",
       "      <th>Beta</th>\n",
       "      <th>CloseValue</th>\n",
       "      <th>CurrentValue</th>\n",
       "      <th>PNL_Day</th>\n",
       "      <th>PNL_ITD</th>\n",
       "      <th>CurrentExposure</th>\n",
       "      <th>CurrentBetaAdjExposure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Equity</td>\n",
       "      <td>AVGO</td>\n",
       "      <td>126</td>\n",
       "      <td>22680.0</td>\n",
       "      <td>220.81</td>\n",
       "      <td>221.32</td>\n",
       "      <td>1.12</td>\n",
       "      <td>27822.06</td>\n",
       "      <td>27886.32</td>\n",
       "      <td>64.26</td>\n",
       "      <td>5206.32</td>\n",
       "      <td>27886.32</td>\n",
       "      <td>31232.6784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Equity</td>\n",
       "      <td>EVHC</td>\n",
       "      <td>349</td>\n",
       "      <td>22685.0</td>\n",
       "      <td>56.03</td>\n",
       "      <td>56.18</td>\n",
       "      <td>0.35</td>\n",
       "      <td>19554.47</td>\n",
       "      <td>19606.82</td>\n",
       "      <td>52.35</td>\n",
       "      <td>-3078.18</td>\n",
       "      <td>19606.82</td>\n",
       "      <td>6862.3870</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Equity</td>\n",
       "      <td>STT</td>\n",
       "      <td>287</td>\n",
       "      <td>22673.0</td>\n",
       "      <td>83.90</td>\n",
       "      <td>83.94</td>\n",
       "      <td>1.29</td>\n",
       "      <td>24079.30</td>\n",
       "      <td>24090.78</td>\n",
       "      <td>11.48</td>\n",
       "      <td>1417.78</td>\n",
       "      <td>24090.78</td>\n",
       "      <td>31077.1062</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DAL</td>\n",
       "      <td>454</td>\n",
       "      <td>22700.0</td>\n",
       "      <td>45.44</td>\n",
       "      <td>45.40</td>\n",
       "      <td>1.07</td>\n",
       "      <td>20629.76</td>\n",
       "      <td>20611.60</td>\n",
       "      <td>-18.16</td>\n",
       "      <td>-2088.40</td>\n",
       "      <td>20611.60</td>\n",
       "      <td>22054.4120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DY</td>\n",
       "      <td>283</td>\n",
       "      <td>22640.0</td>\n",
       "      <td>105.66</td>\n",
       "      <td>106.55</td>\n",
       "      <td>1.54</td>\n",
       "      <td>29901.78</td>\n",
       "      <td>30153.65</td>\n",
       "      <td>251.87</td>\n",
       "      <td>7513.65</td>\n",
       "      <td>30153.65</td>\n",
       "      <td>46436.6210</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Type Symbol  Qty  CostBasis   Close    Last  Beta  CloseValue  \\\n",
       "0  Equity   AVGO  126    22680.0  220.81  221.32  1.12    27822.06   \n",
       "1  Equity   EVHC  349    22685.0   56.03   56.18  0.35    19554.47   \n",
       "2  Equity    STT  287    22673.0   83.90   83.94  1.29    24079.30   \n",
       "3  Equity    DAL  454    22700.0   45.44   45.40  1.07    20629.76   \n",
       "4  Equity     DY  283    22640.0  105.66  106.55  1.54    29901.78   \n",
       "\n",
       "   CurrentValue  PNL_Day  PNL_ITD  CurrentExposure  CurrentBetaAdjExposure  \n",
       "0      27886.32    64.26  5206.32         27886.32              31232.6784  \n",
       "1      19606.82    52.35 -3078.18         19606.82               6862.3870  \n",
       "2      24090.78    11.48  1417.78         24090.78              31077.1062  \n",
       "3      20611.60   -18.16 -2088.40         20611.60              22054.4120  \n",
       "4      30153.65   251.87  7513.65         30153.65              46436.6210  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@loman.node(comp)\n",
    "def df_equity_pnl(df_holdings_equity, df_equity_yql_data_yahoo, df_equity_scraped_data_yahoo):\n",
    "    # Merge DataFrames\n",
    "    df = pd.merge(df_holdings_equity, df_equity_yql_data_yahoo[['Symbol', 'PreviousClose', 'LastTradePriceOnly']], \n",
    "                  how='left', on='Symbol')\n",
    "    df.rename(columns={'PreviousClose': 'Close', 'LastTradePriceOnly': 'Last'}, inplace=True)\n",
    "    for col in ['Close', 'Last']:\n",
    "        df[col] = df[col].astype(float)\n",
    "    df = pd.merge(df, df_equity_scraped_data_yahoo, how='left', on='Symbol')\n",
    "    \n",
    "    # Calculate Measures\n",
    "    df['CloseValue'] = df.Qty * df.Close\n",
    "    df['CurrentValue'] = df.Qty * df.Last\n",
    "    df['PNL_Day'] = df.CurrentValue - df.CloseValue\n",
    "    df['PNL_ITD'] = df.CurrentValue - df.CostBasis\n",
    "    df['CurrentExposure'] = df.CurrentValue\n",
    "    df['CurrentBetaAdjExposure'] = df.Beta * df.CurrentExposure\n",
    "    return df\n",
    "comp.compute_all()\n",
    "comp.v.df_equity_pnl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The process is very similar for futures. **df_future_pnl** is created by merging the holdings, price and static data in **df_holdings_future**, **df_future_prices** and **df_future_static_data** respectively. We again calculate each of the P&L and exposure measures that we would like to see, but note that the treatment for futures is different. For example, intraday P&L is calculated as $(\\text{Last Price} - \\text{Close Price}) \\times \\text{Quantity} \\times \\text{Contract Unit}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>CostBasis</th>\n",
       "      <th>Close</th>\n",
       "      <th>Last</th>\n",
       "      <th>UnitAmount</th>\n",
       "      <th>UnitCurrency</th>\n",
       "      <th>Beta</th>\n",
       "      <th>PNL_Day</th>\n",
       "      <th>CloseValue</th>\n",
       "      <th>CurrentValue</th>\n",
       "      <th>PNL_ITD</th>\n",
       "      <th>CurrentExposure</th>\n",
       "      <th>CurrentBetaAdjExposure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Future</td>\n",
       "      <td>ESM7</td>\n",
       "      <td>-1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2387.0</td>\n",
       "      <td>2385.75</td>\n",
       "      <td>50</td>\n",
       "      <td>USD</td>\n",
       "      <td>1.0</td>\n",
       "      <td>62.5</td>\n",
       "      <td>0</td>\n",
       "      <td>62.5</td>\n",
       "      <td>62.5</td>\n",
       "      <td>-119287.5</td>\n",
       "      <td>-119287.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Type Symbol  Qty  CostBasis   Close     Last  UnitAmount UnitCurrency  \\\n",
       "0  Future   ESM7   -1        0.0  2387.0  2385.75          50          USD   \n",
       "\n",
       "   Beta  PNL_Day  CloseValue  CurrentValue  PNL_ITD  CurrentExposure  \\\n",
       "0   1.0     62.5           0          62.5     62.5        -119287.5   \n",
       "\n",
       "   CurrentBetaAdjExposure  \n",
       "0               -119287.5  "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@loman.node(comp)\n",
    "def df_future_pnl(df_holdings_future, df_future_prices, df_future_static_data):\n",
    "    # Merge DataFrames\n",
    "    df = pd.merge(df_holdings_future, df_future_prices[['priorSettle', 'last']], how='left', left_on='Symbol', right_index=True)\n",
    "    df.rename(columns={'priorSettle': 'Close', 'last': 'Last'}, inplace=True)\n",
    "    for col in ['Close', 'Last']:\n",
    "        df[col] = df[col].astype(float)\n",
    "    df = pd.merge(df, df_future_static_data, how='left', on='Symbol')\n",
    "    \n",
    "    # Calculate Measures\n",
    "    df['PNL_Day'] = (df.Last - df.Close) * df.Qty * df.UnitAmount\n",
    "    df['CloseValue'] = 0\n",
    "    df['CurrentValue'] = df.PNL_Day \n",
    "    df['PNL_ITD'] = df.CurrentValue - df.CostBasis\n",
    "    df['CurrentExposure'] = df.Last * df.Qty * df.UnitAmount\n",
    "    df['CurrentBetaAdjExposure'] = df.Beta * df.CurrentExposure\n",
    "    return df\n",
    "comp.compute_all()\n",
    "comp.v.df_future_pnl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The calculations for the cash component are more basic, as cash has no exposure by these measures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>CostBasis</th>\n",
       "      <th>Close</th>\n",
       "      <th>Last</th>\n",
       "      <th>PNL_Day</th>\n",
       "      <th>PNL_ITD</th>\n",
       "      <th>CloseValue</th>\n",
       "      <th>CurrentValue</th>\n",
       "      <th>CurrentExposure</th>\n",
       "      <th>CurrentBetaAdjExposure</th>\n",
       "      <th>Beta</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Cash</td>\n",
       "      <td>USD</td>\n",
       "      <td>2000</td>\n",
       "      <td>2000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2000</td>\n",
       "      <td>2000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Type Symbol   Qty  CostBasis  Close  Last  PNL_Day  PNL_ITD  CloseValue  \\\n",
       "6  Cash    USD  2000       2000    NaN   NaN      0.0      0.0        2000   \n",
       "\n",
       "   CurrentValue  CurrentExposure  CurrentBetaAdjExposure  Beta  \n",
       "6          2000              0.0                     0.0     0  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@loman.node(comp)\n",
    "def df_cash_pnl(df_holdings_cash):\n",
    "    df = df_holdings_cash.copy()\n",
    "    df['Close'] = np.nan\n",
    "    df['Last'] = np.nan\n",
    "    df['PNL_Day'] = df['PNL_ITD'] = 0.\n",
    "    df['CloseValue'] = df['CurrentValue'] = df['CostBasis'] = df.Qty\n",
    "    df['CurrentExposure'] = df['CurrentBetaAdjExposure'] = 0.\n",
    "    df['Beta'] = 0\n",
    "    return df\n",
    "comp.compute_all()\n",
    "comp.v.df_cash_pnl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we add a node **df_pnl**, where we take all the rows from the equity, future and cash P&L and exposure DataFrames in **df_equity_pnl**, **df_future_pnl** and **df_cash_pnl** respectively. This gives us a position-by-position P&L report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type</th>\n",
       "      <th>Symbol</th>\n",
       "      <th>Qty</th>\n",
       "      <th>Close</th>\n",
       "      <th>Last</th>\n",
       "      <th>CostBasis</th>\n",
       "      <th>CloseValue</th>\n",
       "      <th>CurrentValue</th>\n",
       "      <th>PNL_ITD</th>\n",
       "      <th>PNL_Day</th>\n",
       "      <th>Beta</th>\n",
       "      <th>CurrentExposure</th>\n",
       "      <th>CurrentBetaAdjExposure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Equity</td>\n",
       "      <td>AVGO</td>\n",
       "      <td>126</td>\n",
       "      <td>220.81</td>\n",
       "      <td>221.32</td>\n",
       "      <td>22680.0</td>\n",
       "      <td>27822.06</td>\n",
       "      <td>27886.32</td>\n",
       "      <td>5206.32</td>\n",
       "      <td>64.26</td>\n",
       "      <td>1.12</td>\n",
       "      <td>27886.32</td>\n",
       "      <td>31232.6784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Equity</td>\n",
       "      <td>EVHC</td>\n",
       "      <td>349</td>\n",
       "      <td>56.03</td>\n",
       "      <td>56.18</td>\n",
       "      <td>22685.0</td>\n",
       "      <td>19554.47</td>\n",
       "      <td>19606.82</td>\n",
       "      <td>-3078.18</td>\n",
       "      <td>52.35</td>\n",
       "      <td>0.35</td>\n",
       "      <td>19606.82</td>\n",
       "      <td>6862.3870</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Equity</td>\n",
       "      <td>STT</td>\n",
       "      <td>287</td>\n",
       "      <td>83.90</td>\n",
       "      <td>83.94</td>\n",
       "      <td>22673.0</td>\n",
       "      <td>24079.30</td>\n",
       "      <td>24090.78</td>\n",
       "      <td>1417.78</td>\n",
       "      <td>11.48</td>\n",
       "      <td>1.29</td>\n",
       "      <td>24090.78</td>\n",
       "      <td>31077.1062</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DAL</td>\n",
       "      <td>454</td>\n",
       "      <td>45.44</td>\n",
       "      <td>45.40</td>\n",
       "      <td>22700.0</td>\n",
       "      <td>20629.76</td>\n",
       "      <td>20611.60</td>\n",
       "      <td>-2088.40</td>\n",
       "      <td>-18.16</td>\n",
       "      <td>1.07</td>\n",
       "      <td>20611.60</td>\n",
       "      <td>22054.4120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Equity</td>\n",
       "      <td>DY</td>\n",
       "      <td>283</td>\n",
       "      <td>105.66</td>\n",
       "      <td>106.55</td>\n",
       "      <td>22640.0</td>\n",
       "      <td>29901.78</td>\n",
       "      <td>30153.65</td>\n",
       "      <td>7513.65</td>\n",
       "      <td>251.87</td>\n",
       "      <td>1.54</td>\n",
       "      <td>30153.65</td>\n",
       "      <td>46436.6210</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Future</td>\n",
       "      <td>ESM7</td>\n",
       "      <td>-1</td>\n",
       "      <td>2387.00</td>\n",
       "      <td>2385.75</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>62.50</td>\n",
       "      <td>62.50</td>\n",
       "      <td>62.50</td>\n",
       "      <td>1.00</td>\n",
       "      <td>-119287.50</td>\n",
       "      <td>-119287.5000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Cash</td>\n",
       "      <td>USD</td>\n",
       "      <td>2000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2000.0</td>\n",
       "      <td>2000.00</td>\n",
       "      <td>2000.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.0000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Type Symbol   Qty    Close     Last  CostBasis  CloseValue  CurrentValue  \\\n",
       "0  Equity   AVGO   126   220.81   221.32    22680.0    27822.06      27886.32   \n",
       "1  Equity   EVHC   349    56.03    56.18    22685.0    19554.47      19606.82   \n",
       "2  Equity    STT   287    83.90    83.94    22673.0    24079.30      24090.78   \n",
       "3  Equity    DAL   454    45.44    45.40    22700.0    20629.76      20611.60   \n",
       "4  Equity     DY   283   105.66   106.55    22640.0    29901.78      30153.65   \n",
       "0  Future   ESM7    -1  2387.00  2385.75        0.0        0.00         62.50   \n",
       "6    Cash    USD  2000      NaN      NaN     2000.0     2000.00       2000.00   \n",
       "\n",
       "   PNL_ITD  PNL_Day  Beta  CurrentExposure  CurrentBetaAdjExposure  \n",
       "0  5206.32    64.26  1.12         27886.32              31232.6784  \n",
       "1 -3078.18    52.35  0.35         19606.82               6862.3870  \n",
       "2  1417.78    11.48  1.29         24090.78              31077.1062  \n",
       "3 -2088.40   -18.16  1.07         20611.60              22054.4120  \n",
       "4  7513.65   251.87  1.54         30153.65              46436.6210  \n",
       "0    62.50    62.50  1.00       -119287.50            -119287.5000  \n",
       "6     0.00     0.00  0.00             0.00                  0.0000  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@loman.node(comp)\n",
    "def df_pnl(df_equity_pnl, df_future_pnl, df_cash_pnl):\n",
    "    df = pd.concat([df_equity_pnl, df_future_pnl, df_cash_pnl])\n",
    "    df = df[['Type', 'Symbol', 'Qty', 'Close', 'Last', 'CostBasis', 'CloseValue', 'CurrentValue', 'PNL_ITD', 'PNL_Day', 'Beta', 'CurrentExposure', 'CurrentBetaAdjExposure']]\n",
    "    return df\n",
    "comp.compute_all()\n",
    "comp.v.df_pnl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From there, various aggregations are possible. For example, we can easily see intraday P&L, and inception-to-date P&L:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "424.299999999992"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.v.df_pnl.PNL_Day.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9033.669999999995"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.v.df_pnl.PNL_ITD.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As well as seeing our exposure, and beta-adjusted exposure metrics across the whole portfolio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CurrentExposure            3061.6700\n",
       "CurrentBetaAdjExposure    18375.7046\n",
       "dtype: float64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.v.df_pnl[['CurrentExposure', 'CurrentBetaAdjExposure']].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could even put the aggregated data itself into new nodes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Thoughts\n",
    "\n",
    "The first thing to point out is that our computation is now both reasonably complex, but very logically laid out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n",
       "<!-- Generated by graphviz version 2.38.0 (20140413.2041)\r\n",
       " -->\r\n",
       "<!-- Title: G Pages: 1 -->\r\n",
       "<svg width=\"576pt\" height=\"240pt\"\r\n",
       " viewBox=\"0.00 0.00 576.00 240.41\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(0.595082 0.595082) rotate(0) translate(4 400)\">\r\n",
       "<title>G</title>\r\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-400 963.934,-400 963.934,4 -4,4\"/>\r\n",
       "<!-- n0 -->\r\n",
       "<g id=\"node1\" class=\"node\"><title>n0</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"473.54\" cy=\"-378\" rx=\"41.6928\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"473.54\" y=\"-374.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">holdings</text>\r\n",
       "</g>\r\n",
       "<!-- n1 -->\r\n",
       "<g id=\"node2\" class=\"node\"><title>n1</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"473.54\" cy=\"-306\" rx=\"53.8905\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"473.54\" y=\"-302.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_holdings</text>\r\n",
       "</g>\r\n",
       "<!-- n0&#45;&gt;n1 -->\r\n",
       "<g id=\"edge1\" class=\"edge\"><title>n0&#45;&gt;n1</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M473.54,-359.697C473.54,-351.983 473.54,-342.712 473.54,-334.112\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"477.04,-334.104 473.54,-324.104 470.04,-334.104 477.04,-334.104\"/>\r\n",
       "</g>\r\n",
       "<!-- n2 -->\r\n",
       "<g id=\"node3\" class=\"node\"><title>n2</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"294.54\" cy=\"-234\" rx=\"81.4863\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"294.54\" y=\"-230.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_holdings_equity</text>\r\n",
       "</g>\r\n",
       "<!-- n1&#45;&gt;n2 -->\r\n",
       "<g id=\"edge2\" class=\"edge\"><title>n1&#45;&gt;n2</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M439.872,-291.834C412.365,-281.077 373.145,-265.739 342.379,-253.708\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"343.3,-250.31 332.712,-249.928 340.751,-256.829 343.3,-250.31\"/>\r\n",
       "</g>\r\n",
       "<!-- n3 -->\r\n",
       "<g id=\"node4\" class=\"node\"><title>n3</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"473.54\" cy=\"-234\" rx=\"79.8859\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"473.54\" y=\"-230.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_holdings_future</text>\r\n",
       "</g>\r\n",
       "<!-- n1&#45;&gt;n3 -->\r\n",
       "<g id=\"edge3\" class=\"edge\"><title>n1&#45;&gt;n3</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M473.54,-287.697C473.54,-279.983 473.54,-270.712 473.54,-262.112\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"477.04,-262.104 473.54,-252.104 470.04,-262.104 477.04,-262.104\"/>\r\n",
       "</g>\r\n",
       "<!-- n4 -->\r\n",
       "<g id=\"node5\" class=\"node\"><title>n4</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"884.54\" cy=\"-162\" rx=\"75.2868\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"884.54\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_holdings_cash</text>\r\n",
       "</g>\r\n",
       "<!-- n1&#45;&gt;n4 -->\r\n",
       "<g id=\"edge4\" class=\"edge\"><title>n1&#45;&gt;n4</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M526.806,-302.54C639.105,-296.807 891.965,-280.81 917.54,-252 933.646,-233.857 920.316,-207.149 906.078,-187.727\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"908.689,-185.383 899.79,-179.634 903.162,-189.678 908.689,-185.383\"/>\r\n",
       "</g>\r\n",
       "<!-- n5 -->\r\n",
       "<g id=\"node6\" class=\"node\"><title>n5</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"108.54\" cy=\"-162\" rx=\"108.581\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"108.54\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_equity_yql_data_yahoo</text>\r\n",
       "</g>\r\n",
       "<!-- n2&#45;&gt;n5 -->\r\n",
       "<g id=\"edge5\" class=\"edge\"><title>n2&#45;&gt;n5</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M255.095,-218.155C227.286,-207.689 189.786,-193.576 159.681,-182.247\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"160.78,-178.921 150.188,-178.674 158.315,-185.472 160.78,-178.921\"/>\r\n",
       "</g>\r\n",
       "<!-- n6 -->\r\n",
       "<g id=\"node7\" class=\"node\"><title>n6</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"361.54\" cy=\"-162\" rx=\"126.178\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"361.54\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_equity_scraped_data_yahoo</text>\r\n",
       "</g>\r\n",
       "<!-- n2&#45;&gt;n6 -->\r\n",
       "<g id=\"edge6\" class=\"edge\"><title>n2&#45;&gt;n6</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M310.759,-216.055C318.949,-207.498 329.036,-196.959 338.057,-187.535\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"340.619,-189.92 345.005,-180.275 335.562,-185.079 340.619,-189.92\"/>\r\n",
       "</g>\r\n",
       "<!-- n9 -->\r\n",
       "<g id=\"node10\" class=\"node\"><title>n9</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"476.54\" cy=\"-90\" rx=\"61.99\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"476.54\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_equity_pnl</text>\r\n",
       "</g>\r\n",
       "<!-- n2&#45;&gt;n9 -->\r\n",
       "<g id=\"edge7\" class=\"edge\"><title>n2&#45;&gt;n9</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M352.878,-221.458C409.304,-209.706 487.585,-191.608 496.54,-180 510.506,-161.897 502.359,-135.906 492.598,-116.682\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"495.637,-114.945 487.766,-107.852 489.496,-118.305 495.637,-114.945\"/>\r\n",
       "</g>\r\n",
       "<!-- n10 -->\r\n",
       "<g id=\"node11\" class=\"node\"><title>n10</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"642.54\" cy=\"-162\" rx=\"60.3893\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"642.54\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_future_pnl</text>\r\n",
       "</g>\r\n",
       "<!-- n3&#45;&gt;n10 -->\r\n",
       "<g id=\"edge8\" class=\"edge\"><title>n3&#45;&gt;n10</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M510.211,-217.811C536.436,-206.948 571.827,-192.289 599.41,-180.865\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"600.914,-184.03 608.813,-176.97 598.235,-177.563 600.914,-184.03\"/>\r\n",
       "</g>\r\n",
       "<!-- n11 -->\r\n",
       "<g id=\"node12\" class=\"node\"><title>n11</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"831.54\" cy=\"-90\" rx=\"55.7903\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"831.54\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_cash_pnl</text>\r\n",
       "</g>\r\n",
       "<!-- n4&#45;&gt;n11 -->\r\n",
       "<g id=\"edge9\" class=\"edge\"><title>n4&#45;&gt;n11</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M871.711,-144.055C865.331,-135.629 857.495,-125.28 850.443,-115.966\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"853.079,-113.649 844.252,-107.789 847.498,-117.874 853.079,-113.649\"/>\r\n",
       "</g>\r\n",
       "<!-- n5&#45;&gt;n9 -->\r\n",
       "<g id=\"edge10\" class=\"edge\"><title>n5&#45;&gt;n9</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M176.896,-147.998C245.557,-134.937 350.348,-115.004 416.069,-102.503\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"417.1,-105.87 426.269,-100.562 415.791,-98.9928 417.1,-105.87\"/>\r\n",
       "</g>\r\n",
       "<!-- n6&#45;&gt;n9 -->\r\n",
       "<g id=\"edge11\" class=\"edge\"><title>n6&#45;&gt;n9</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M388.794,-144.411C404.857,-134.633 425.323,-122.176 442.448,-111.752\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"444.336,-114.7 451.058,-106.511 440.696,-108.721 444.336,-114.7\"/>\r\n",
       "</g>\r\n",
       "<!-- n7 -->\r\n",
       "<g id=\"node8\" class=\"node\"><title>n7</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"642.54\" cy=\"-234\" rx=\"71.4873\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"642.54\" y=\"-230.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_future_prices</text>\r\n",
       "</g>\r\n",
       "<!-- n7&#45;&gt;n10 -->\r\n",
       "<g id=\"edge12\" class=\"edge\"><title>n7&#45;&gt;n10</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M642.54,-215.697C642.54,-207.983 642.54,-198.712 642.54,-190.112\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"646.04,-190.104 642.54,-180.104 639.04,-190.104 646.04,-190.104\"/>\r\n",
       "</g>\r\n",
       "<!-- n8 -->\r\n",
       "<g id=\"node9\" class=\"node\"><title>n8</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"820.54\" cy=\"-234\" rx=\"88.2844\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"820.54\" y=\"-230.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_future_static_data</text>\r\n",
       "</g>\r\n",
       "<!-- n8&#45;&gt;n10 -->\r\n",
       "<g id=\"edge13\" class=\"edge\"><title>n8&#45;&gt;n10</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M781.478,-217.638C753.618,-206.682 716.107,-191.931 687.083,-180.517\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"688.179,-177.187 677.592,-176.784 685.617,-183.701 688.179,-177.187\"/>\r\n",
       "</g>\r\n",
       "<!-- n12 -->\r\n",
       "<g id=\"node13\" class=\"node\"><title>n12</title>\r\n",
       "<ellipse fill=\"#15b01a\" stroke=\"black\" cx=\"642.54\" cy=\"-18\" rx=\"34.394\" ry=\"18\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"642.54\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">df_pnl</text>\r\n",
       "</g>\r\n",
       "<!-- n9&#45;&gt;n12 -->\r\n",
       "<g id=\"edge14\" class=\"edge\"><title>n9&#45;&gt;n12</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M510.133,-74.8345C538.391,-62.9182 578.663,-45.9361 607.36,-33.835\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"608.76,-37.0433 616.614,-29.9327 606.04,-30.5933 608.76,-37.0433\"/>\r\n",
       "</g>\r\n",
       "<!-- n10&#45;&gt;n12 -->\r\n",
       "<g id=\"edge15\" class=\"edge\"><title>n10&#45;&gt;n12</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M642.54,-143.871C642.54,-119.67 642.54,-75.2108 642.54,-46.3932\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"646.04,-46.1892 642.54,-36.1893 639.04,-46.1893 646.04,-46.1892\"/>\r\n",
       "</g>\r\n",
       "<!-- n11&#45;&gt;n12 -->\r\n",
       "<g id=\"edge16\" class=\"edge\"><title>n11&#45;&gt;n12</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M795.991,-75.8335C762.706,-63.5058 713.176,-45.1613 679.455,-32.6723\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"680.556,-29.3475 669.963,-29.1564 678.124,-35.9117 680.556,-29.3475\"/>\r\n",
       "</g>\r\n",
       "</g>\r\n",
       "</svg>\r\n"
      ],
      "text/plain": [
       "<pydotplus.graphviz.Dot at 0x1671563b710>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp.draw(graph_attr={'size': '\"8,6\"'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is serves a practical purpose. Code typically spends the bulk of its life being maintained, so it is important to make that maintenance as easy and fast as possible. Returning to this after several months, it takes a time to reacquaint with even a modest amount of code, while the logical structure and visualization capabilities offered by Loman make it easy to see how a computation occurs.\n",
    "\n",
    "There are also benefits when we are first creating code. Because Loman keeps track of state for us, as we interactively add nodes (and possibily take several iterations to get them correct), we do not have to re-run upstream dependencies. Contrast this with a writing a program by adding sub-routines or sections of code. Each re-run would necessitate fetching data from several external websites, and by the end, even in this small case, the process of trying out new iterations becomes quite onerous.\n",
    "\n",
    "Of course there are other possibilities. An interactive environment such as IPython Notebook requires us to manually keep track ourselves of what needs to be re-run each time. Or a program that serializes data from external websites to disk and then reads in the cached copy also imposes a substantial cognitive load keeping track of that cache.\n",
    "\n",
    "Our solution is extensible. It is easy to add new asset types, new measures, or new classifications to cover more complex portfolios, and create more detailed reports. Also, we can combine with other data sources to create entirely new reports - for example, it is easy to imagine using earnings announcement calendars to create a node with a list of equities reporting earnings in the next week, which could be used to provide alerts. Or we could progarm a node to show how near our portfolio is to risk or compliance limits.\n",
    "\n",
    "For real-time use, Loman's ability to track state allows us to update different inputs at different cadences. For example, we might update the equity and price nodes every tick, or every few seconds, but update semi-static data less frequently. \n",
    "\n",
    "We can also control output cadence by specifying which nodes to calculate, when. We only produce one set of results here, but consider if we had a valuation or risk model that we wanted to use, but which was slow to calculate. We could still calculate P&L at a relatively high frequency, which calculating the more time-consuming model every few minutes, say.\n",
    "\n",
    "Finally, our solution is potentially usable in a variety of different contexts. We might have a batch system using this computation graph, to produce daily, or periodic intraday valuations centrally, while the investment team managing a particular portfolio might appreciate the ability to run the same computation graph on their portfolios and model portfolios whenever they desire.\n",
    "\n",
    "That brings us to the end of this example. We looked at how to use Loman to create a basic valuation system for a limited portfolio. In doing so, we explored several tangible benefits that we hope make life easier for quant practitioners. If anything is unclear in this example, feel free to contact the authors through the [Loman Forum on Google Groups](https://groups.google.com/forum/#!forum/loman-python)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}