PnF-Chart-Creator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "        <script type=\"text/javascript\">\n",
       "        window.PlotlyConfig = {MathJaxConfig: 'local'};\n",
       "        if (window.MathJax) {MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}\n",
       "        if (typeof require !== 'undefined') {\n",
       "        require.undef(\"plotly\");\n",
       "        requirejs.config({\n",
       "            paths: {\n",
       "                'plotly': ['https://cdn.plot.ly/plotly-latest.min']\n",
       "            }\n",
       "        });\n",
       "        require(['plotly'], function(Plotly) {\n",
       "            window._Plotly = Plotly;\n",
       "        });\n",
       "        }\n",
       "        </script>\n",
       "        "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import requests\n",
    "import warnings\n",
    "\n",
    "from datetime import datetime\n",
    "from dateutil.relativedelta import relativedelta\n",
    "from time import sleep\n",
    "\n",
    "# Plotting\n",
    "import plotly.offline as py\n",
    "import plotly.graph_objs as go\n",
    "py.init_notebook_mode(connected=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5/30/19</th>\n",
       "      <td>177.95</td>\n",
       "      <td>179.23</td>\n",
       "      <td>176.67</td>\n",
       "      <td>178.30</td>\n",
       "      <td>21218412</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5/29/19</th>\n",
       "      <td>176.42</td>\n",
       "      <td>179.35</td>\n",
       "      <td>176.00</td>\n",
       "      <td>177.38</td>\n",
       "      <td>28481164</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5/28/19</th>\n",
       "      <td>178.92</td>\n",
       "      <td>180.59</td>\n",
       "      <td>177.91</td>\n",
       "      <td>178.23</td>\n",
       "      <td>27948160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5/24/19</th>\n",
       "      <td>180.20</td>\n",
       "      <td>182.14</td>\n",
       "      <td>178.62</td>\n",
       "      <td>178.97</td>\n",
       "      <td>23714686</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5/23/19</th>\n",
       "      <td>179.80</td>\n",
       "      <td>180.54</td>\n",
       "      <td>177.81</td>\n",
       "      <td>179.66</td>\n",
       "      <td>36529736</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           open    high     low   close    volume\n",
       "date                                             \n",
       "5/30/19  177.95  179.23  176.67  178.30  21218412\n",
       "5/29/19  176.42  179.35  176.00  177.38  28481164\n",
       "5/28/19  178.92  180.59  177.91  178.23  27948160\n",
       "5/24/19  180.20  182.14  178.62  178.97  23714686\n",
       "5/23/19  179.80  180.54  177.81  179.66  36529736"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import AAPL data\n",
    "raw_data = pd.read_csv('./data/aapl_1y.csv', index_col='date')\n",
    "raw_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define Security Class\n",
    "This class holds information for securities that will be used for PnF charting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Security:\n",
    "    def __init__(self, data, date_format='%Y-%m-%d'):\n",
    "        self.data = data # Date-indexed OHLC data\n",
    "        self._chart = None\n",
    "        self._pnf_bars = None\n",
    "        self._pnf_points = []\n",
    "        self._pnf_columns = None\n",
    "        self._default_format = '%Y-%m-%d'\n",
    "        self.date_format = date_format\n",
    "        \n",
    "        # Ensure that index of data is of format %Y-%m-%d\n",
    "        self.format_index()\n",
    "        \n",
    "    @property\n",
    "    def data(self):\n",
    "        return self._data\n",
    "    \n",
    "    @data.setter\n",
    "    def data(self, d):\n",
    "        # Ensure data has correct columns and date index\n",
    "        required_cols = set(['close', 'high', 'low'])\n",
    "        cols = set(d.columns)\n",
    "        if len(required_cols.intersection(cols)) != len(required_cols):\n",
    "            raise ValueError(\"Security data doesn't contain all required columns: ('close', 'high', 'low')\")\n",
    "        self._data = d\n",
    "        #else:\n",
    "            # Check index is of right dtype\n",
    "            #required_type = pd._libs.tslib.Timestamp\n",
    "            #if d.index.dtype != required_type:\n",
    "            #    raise ValueError(\"Security data needs to have index values of type pd.Timestamp\")\n",
    "            #else:\n",
    "                #self._data = d\n",
    "                \n",
    "    @property\n",
    "    def pnf_points(self):\n",
    "        return self._pnf_points\n",
    "    \n",
    "    @pnf_points.setter\n",
    "    def pnf_points(self, p):\n",
    "        if len(p) == 0:\n",
    "            raise ValueError('List of PnF points can not be empty')\n",
    "        if type(p[0]) != PnfPoint:\n",
    "            raise ValueError('PnF points in list must be of type PnfPoint')\n",
    "        self._pnf_points = p\n",
    "        \n",
    "    @property\n",
    "    def chart(self):\n",
    "        return self._chart\n",
    "    \n",
    "    @chart.setter\n",
    "    def chart(self, c):\n",
    "        if type(c) != Chart:\n",
    "            raise ValueError('self._chart must be of type Chart')\n",
    "        self._chart = c\n",
    "        \n",
    "    @property\n",
    "    def pnf_bars(self):\n",
    "        return self._pnf_bars\n",
    "    \n",
    "    @pnf_bars.setter\n",
    "    def pnf_bars(self, pb):\n",
    "        if type(pb) != pd.DataFrame:\n",
    "            raise ValueError('self._pnf_bars must be a pd.DataFrame')\n",
    "        self._pnf_bars = pb\n",
    "        \n",
    "    @property\n",
    "    def pnf_columns(self):\n",
    "        return self._pnf_columns\n",
    "    \n",
    "    @pnf_columns.setter\n",
    "    def pnf_columns(self, c):\n",
    "        if len(c) == 0:\n",
    "            raise ValueError('self._pnf_columns cannot be empty')\n",
    "        if type(c[0]) != PnfColumn:\n",
    "            raise ValueError('self._pnf_columns must be a list of PnfColumn objects')\n",
    "        self._pnf_columns = c\n",
    "        \n",
    "    @property\n",
    "    def date_format(self):\n",
    "        return self._date_format\n",
    "    \n",
    "    @date_format.setter\n",
    "    def date_format(self, df):\n",
    "        if type(df) != str:\n",
    "            raise ValueError('self.date_format must be a date format string')\n",
    "        self._date_format = df\n",
    "        \n",
    "    def format_index(self):\n",
    "        '''\n",
    "            Formats self._data index so that it is in format %Y-%m-%d\n",
    "        '''\n",
    "        idx = pd.Series(self.data.index)\n",
    "        idx = idx.apply(lambda d: datetime.strptime(d, self.date_format))\n",
    "        idx = idx.apply(lambda d: datetime.strftime(d, '%Y-%m-%d'))\n",
    "        self.data.index = idx\n",
    "        \n",
    "    def generate_pnf_data(self, method='trad'):\n",
    "        '''\n",
    "            Generates PnF data necessary for plotting/bar creation\n",
    "        '''\n",
    "        # Create chart instance\n",
    "        self.chart = Chart(self.data)\n",
    "        # Get PnfPoints\n",
    "        self.chart.generate_pnf_points(scaling=method)\n",
    "        self.pnf_points = self.chart.pnf_points\n",
    "        # Get Pnf Columns\n",
    "        self.chart.generate_pnf_columns()\n",
    "        self.pnf_columns = self.chart.columns\n",
    "        \n",
    "    def plot_chart(self):\n",
    "        '''\n",
    "            Generates a PnF Chart\n",
    "        '''\n",
    "        if self.chart == None:\n",
    "            raise ValueError('Chart not instantiated. Please call self.generate_pnf_data before \\\n",
    "            calling self.plot_chart')\n",
    "        else:\n",
    "            self.chart.plot_chart()\n",
    "        \n",
    "    def generate_pnf_bars(self):\n",
    "        '''\n",
    "            Generates PnF bars using self._pnf_points\n",
    "            \n",
    "            Args:\n",
    "                None\n",
    "                \n",
    "            Returns:\n",
    "                (pd.DataFrame): dataframe of PnF bars\n",
    "        '''\n",
    "        # Generate rough dataframe from _pnf_points\n",
    "        pnf_df = pd.DataFrame()\n",
    "        for p in self.pnf_points:\n",
    "            pnf_df = pnf_df.append(pd.DataFrame.from_dict({\n",
    "                'date': [p.date],\n",
    "                'direction': [p.direction],\n",
    "                'value': [p.value],\n",
    "                'double_top': [p.signals['double_top']],\n",
    "                'double_bottom': [p.signals['double_bottom']],\n",
    "                'triple_top_break': [p.signals['triple_top_break']],\n",
    "                'triple_bottom_break': [p.signals['triple_bottom_break']],\n",
    "            }))\n",
    "        \n",
    "        pnf_df = pnf_df.reset_index().drop(['index'], axis=1)\n",
    "        \n",
    "        # Find time between ticks\n",
    "        pnf_df['date'] = pnf_df.date.apply(lambda d: datetime.strptime(d, self._default_format))\n",
    "        pnf_df['timedelta'] = pnf_df.date - pnf_df.date.shift(1)\n",
    "        \n",
    "        # Change index to date\n",
    "        pnf_df = pnf_df.set_index('date')\n",
    "        pnf_df.dropna(inplace=True)\n",
    "        \n",
    "        # Aggregate data so only one bar per day\n",
    "        dates = pnf_df.index.unique()\n",
    "        agg_df = pd.DataFrame()\n",
    "        for date in dates:\n",
    "            # Get all bars for this date\n",
    "            date_df = pnf_df.loc[[date]]\n",
    "            # Get attributes\n",
    "            direction = date_df.iloc[0].direction\n",
    "            timedelta = np.max(date_df.timedelta)\n",
    "            # Get signals\n",
    "            double_top = True in date_df['double_top'].values\n",
    "            double_bottom = True in date_df['double_bottom'].values\n",
    "            triple_top_break = True in date_df['triple_top_break'].values\n",
    "            triple_bottom_break = True in date_df['triple_bottom_break'].values\n",
    "            # Get signals\n",
    "            if direction == 'x':\n",
    "                value = np.max(date_df.value)\n",
    "            else:\n",
    "                value = np.min(date_df.value)\n",
    "\n",
    "            # Append aggregated row to df\n",
    "            agg_df = agg_df.append(pd.DataFrame.from_dict({\n",
    "                'value': [value],\n",
    "                'direction': [direction],\n",
    "                'timedelta': [timedelta],\n",
    "                'double_top': [double_top],\n",
    "                'double_bottom': [double_bottom],\n",
    "                'triple_top_break': [triple_top_break],\n",
    "                'triple_bottom_break': [triple_bottom_break],\n",
    "                'date': [date]\n",
    "            }))\n",
    "\n",
    "        agg_df = agg_df.set_index('date')\n",
    "        self.pnf_bars = agg_df\n",
    "        \n",
    "    def get_pnf_signals(self):\n",
    "        '''\n",
    "            Will identify pnf buy/sell signals and append these signal occurrences\n",
    "            to pnf points on the day they occurred\n",
    "        '''\n",
    "        # Create pattern finder using pnf columns\n",
    "        pf = PatternFinder(self.pnf_columns)\n",
    "        # Identify all signals using pattern finder\n",
    "        pf.identify_all_signals()\n",
    "        # Set points back to security\n",
    "        self.pnf_points = pf.pnf_points\n",
    "        \n",
    "    def is_on_buy(self):\n",
    "        '''\n",
    "            Returns True if pnf chart is currently on a buy signal, false otherwise\n",
    "        '''\n",
    "        # Iterate through pnf points from end -> beginning and find most recent signal.\n",
    "        # If it is a buy, return true, if it is a sell or no signal, return False\n",
    "        for p in self.pnf_points[::-1]:\n",
    "            buy_signal = p.signals['double_top']\n",
    "            sell_signal = p.signals['double_bottom']\n",
    "            # Return True if on a buy signal, False if on a sell signal\n",
    "            if buy_signal:\n",
    "                return True\n",
    "            if sell_signal:\n",
    "                return False            \n",
    "        # If we iterate through all points and there are no signals, return False\n",
    "        return False\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define PnfPoint Class\n",
    "This class represents the data for a point on our PnF chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PnfPoint:\n",
    "    def __init__(self, direction, value, date, marker):\n",
    "        self.direction = direction\n",
    "        self.value = value\n",
    "        self.date = date\n",
    "        self.marker = marker\n",
    "        self.signals = {\n",
    "            'double_top': False,\n",
    "            'double_bottom': False,\n",
    "            'triple_top_break': False,\n",
    "            'triple_bottom_break': False,\n",
    "        }\n",
    "        \n",
    "    def __str__(self):\n",
    "        '''\n",
    "            Overloaded print function\n",
    "        '''\n",
    "        return 'Date: {} | Value: {} | Dir: {} |  Signals: {}'.format(self.date, \n",
    "                                                                      self.value, \n",
    "                                                                      self.direction,\n",
    "                                                                      self.signals)\n",
    "        \n",
    "    @property\n",
    "    def direction(self):\n",
    "        return self._direction\n",
    "    \n",
    "    @direction.setter\n",
    "    def direction(self, d):\n",
    "        self._direction = d\n",
    "        \n",
    "    @property\n",
    "    def value(self):\n",
    "        return self._value\n",
    "    \n",
    "    @value.setter\n",
    "    def value(self, v):\n",
    "        self._value = v\n",
    "        \n",
    "    @property\n",
    "    def date(self):\n",
    "        return self._date\n",
    "    @date.setter\n",
    "    def date(self, d):\n",
    "        self._date = d\n",
    "        \n",
    "    @property\n",
    "    def marker(self):\n",
    "        return self._marker    \n",
    "    @marker.setter\n",
    "    def marker(self, m):\n",
    "        self._marker = m\n",
    "        \n",
    "    @property\n",
    "    def signals(self):\n",
    "        return self._signals\n",
    "    @signals.setter\n",
    "    def signals(self, s):\n",
    "        if type(s) != dict:\n",
    "            raise ValueError('self.signals must be of type dict with the signal name as the key ' +\n",
    "                            'and a bool as the value.')\n",
    "        self._signals = s\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define a Column Class\n",
    "This will hold a set of points corresponding to a column on a PnfChart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PnfColumn:\n",
    "    def __init__(self, points, direction):\n",
    "        self.pnf_points = points\n",
    "        self.direction = direction\n",
    "        \n",
    "    @property\n",
    "    def pnf_points(self):\n",
    "        return self._pnf_points\n",
    "    \n",
    "    @pnf_points.setter\n",
    "    def pnf_points(self, points):\n",
    "        if len(points) == 0:\n",
    "            raise ValueError('self._pnf_points cannot be empty')\n",
    "        if type(points[0]) != PnfPoint:\n",
    "            raise ValueError('self._pnf_points must be an iterable with elements of type PnfPoint')\n",
    "        \n",
    "        # May want to enforce some sorting here\n",
    "        self._pnf_points = points    \n",
    "        \n",
    "    @property\n",
    "    def direction(self):\n",
    "        return self._direction\n",
    "    \n",
    "    @direction.setter\n",
    "    def direction(self, d):\n",
    "        if type(d) != str:\n",
    "            raise ValueError('self._direction must be a string')\n",
    "        if d.lower() not in ['x', 'o']:\n",
    "            raise ValueError('self._direction must be either \"x\" or \"o\"')\n",
    "        self._direction = d\n",
    "        \n",
    "    def max(self):\n",
    "        '''\n",
    "            Iterate through all points in column and find one with highest value\n",
    "        '''\n",
    "        max_val = 0\n",
    "        for p in self._pnf_points:\n",
    "            if p._value > max_val:\n",
    "                max_val = p._value\n",
    "        return max_val\n",
    "    \n",
    "    def min(self):\n",
    "        '''\n",
    "            Iterate through all points in column and find one with the lowest value\n",
    "        '''\n",
    "        min_val = 1e9\n",
    "        for p in self._pnf_points:\n",
    "            if p._value < min_val:\n",
    "                min_val = p._value\n",
    "        return min_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define a Chart Class\n",
    "This class will be used to calculate and plot the PnF events for a given security"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Chart:\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self._pnf_points = []\n",
    "        self._columns = []\n",
    "        self._boxes = []\n",
    "        self.scale_methods = ['trad', 'pct']\n",
    "        \n",
    "    @property\n",
    "    def data(self):\n",
    "        return self._data    \n",
    "    @data.setter\n",
    "    def data(self, d):\n",
    "        # Ensure data has correct columns and date index\n",
    "        required_cols = set(['close', 'high', 'low'])\n",
    "        cols = set(d.columns)\n",
    "        if len(required_cols.intersection(cols)) != len(required_cols):\n",
    "            raise ValueError(\"Security data doesn't contain all required columns: ('close', 'high', 'low')\")\n",
    "        else:\n",
    "            # Check index is of right dtype\n",
    "            required_type = pd._libs.tslib.Timestamp\n",
    "            if d.index.dtype != required_type:\n",
    "                raise ValueError(\"Security data needs to have index values of type pd.Timestamp\")\n",
    "            else:\n",
    "                self._data = d\n",
    "    \n",
    "    @property\n",
    "    def pnf_points(self):\n",
    "        return self._pnf_points    \n",
    "    @pnf_points.setter\n",
    "    def pnf_points(self, p):\n",
    "        if len(p) == 0:\n",
    "            raise ValueError('List of PnF points can not be empty')\n",
    "        if type(p[0]) != PnfPoint:\n",
    "            raise ValueError('PnF points in list must be of type PnfPoint')\n",
    "        self._pnf_points = p\n",
    "        \n",
    "    @property\n",
    "    def columns(self):\n",
    "        return self._columns    \n",
    "    @columns.setter\n",
    "    def columns(self, c):\n",
    "        if len(c) == 0:\n",
    "            raise ValueError('PnF Columns cannot be empty')\n",
    "        if not type(c[0]) != PnfColumn:\n",
    "            raise ValueError('Columns must be of type PnfColumn')\n",
    "        self._columns = c\n",
    "        \n",
    "    @property\n",
    "    def boxes(self):\n",
    "        return self._boxes    \n",
    "    @boxes.setter\n",
    "    def boxes(self, b):\n",
    "        if type(b) != pd.Series:\n",
    "            raise ValueError('self._boxes must be of type pd.Series')\n",
    "        self._boxes = b\n",
    "        \n",
    "    @property\n",
    "    def scale_methods(self):\n",
    "        return self._scale_methods\n",
    "    @scale_methods.setter\n",
    "    def scale_methods(self, sm):\n",
    "        # Check that sm is list\n",
    "        if type(sm) != list:\n",
    "            raise ValueError('self.scale_methods must be of type list')\n",
    "        # Check that sm isn't empty\n",
    "        if len(sm) == 0:\n",
    "            raise ValueError('self.scale_methods cannot be empty.')\n",
    "        # Check that sm values are strings\n",
    "        for elt in sm:\n",
    "            if type(elt) != str:\n",
    "                raise ValueError('self.scale_methods must contain elements of type str')\n",
    "        self._scale_methods = sm\n",
    "        \n",
    "        \n",
    "    def get_trad_box_increment(self, value):\n",
    "        '''\n",
    "            Gets the box size for traditional box sizing method\n",
    "            \n",
    "            Args:\n",
    "                value (numeric): the value whose increment we are returning\n",
    "                \n",
    "            Returns:\n",
    "                (numeric): a box increment value dependent upon input value\n",
    "        '''\n",
    "\n",
    "        scale_dict = {\n",
    "        0: 0.0625,\n",
    "        0.25: 0.125,\n",
    "        1: 0.25,\n",
    "        5: 0.5,\n",
    "        20: 1.0,\n",
    "        100: 2.0,\n",
    "        200: 4.0,\n",
    "        500: 5.0,\n",
    "        1000: 50.0,\n",
    "        25000: 500.0\n",
    "    }\n",
    "        # Get possible ranges\n",
    "        ranges = sorted(list(scale_dict.keys()))\n",
    "        # Find price range\n",
    "        scale_key = 1\n",
    "        for r in ranges:\n",
    "            if value >= r:\n",
    "                scale_key = r\n",
    "            else:\n",
    "                break\n",
    "\n",
    "        return scale_dict[scale_key]\n",
    "        \n",
    "        \n",
    "    def generate_boxes(self, value=0, method='trad'):\n",
    "        '''\n",
    "            Generate a series of values representing the boxes of a pnf chart.\n",
    "            \n",
    "            Args:\n",
    "                value (numeric): value around which to generate box sizes (optional for \n",
    "                                    'trad' scaling method)\n",
    "                method (str): the scaling method to use. See self.valid_methods\n",
    "                \n",
    "            Returns:\n",
    "                None. Sets self._boxes to a pd.Series\n",
    "        '''\n",
    "        # Ensure that method is valid\n",
    "        if method not in self.scale_methods:\n",
    "            raise ValueError('Unknown scaling method passed. Options are: {}'.format(self._scale_methods))\n",
    "            \n",
    "        # If method is traditional, then boxes will always be the same. Generate them\n",
    "        # up to 100000\n",
    "        max_val = 100000\n",
    "        boxes = []\n",
    "        if method == 'trad':\n",
    "            boxes.append(0)\n",
    "            while boxes[-1] < max_val:\n",
    "                inc = self.get_trad_box_increment(boxes[-1])\n",
    "                boxes.append(boxes[-1] + inc)\n",
    "                \n",
    "        #If method is percentage, then we will generate 100 boxes above and below the value\n",
    "        if method == 'pct':\n",
    "            boxes_to_gen = 200\n",
    "            boxes = [round(0.01 * ii * value, 2) for ii in range(boxes_to_gen)]\n",
    "                \n",
    "        # Set boxes\n",
    "        self.boxes = pd.Series(boxes)\n",
    "    \n",
    "    def get_box_diff(self, val, prev_val, direction):\n",
    "        '''\n",
    "            Get the box difference between val and prev_val\n",
    "            \n",
    "            Args:\n",
    "                val (numeric): the current value during pnf generation\n",
    "                prev_val (numeric): the previous value plotted on the pnf chart\n",
    "                direction (char, 'x' or 'o'): are we checking box differences for \n",
    "                            column of Xs or Os?\n",
    "                \n",
    "            Returns:\n",
    "                (numeric): the number of boxes val has moved from prev_val\n",
    "        '''\n",
    "        \n",
    "        \n",
    "        if direction == 'x':\n",
    "            # If determining Xs, need to look at boxes below\n",
    "            prev_boxes = len(self.boxes[self.boxes <= prev_val])\n",
    "            val_boxes = len(self.boxes[self.boxes <= val])\n",
    "        else:\n",
    "            # If determining Os, need to find boxes above\n",
    "            prev_boxes = len(self.boxes[self.boxes >= prev_val])\n",
    "            val_boxes = len(self.boxes[self.boxes >= val])\n",
    "        \n",
    "        # Get difference\n",
    "        return val_boxes - prev_boxes\n",
    "        \n",
    "    \n",
    "    def generate_pnf_points(self, scaling='trad'):\n",
    "        '''\n",
    "            Generate the PnF events for the chart's associated security\n",
    "            \n",
    "            Args: \n",
    "                scaling (str): method used to determine box sizes (see self.get_scale)\n",
    "            \n",
    "            Returns:\n",
    "                Nothing. Events stored in self._pnf_points\n",
    "                \n",
    "        '''\n",
    "        #print('Length of chart dataset: {}'.format(len(self._data)))\n",
    "        # Use first close as starting point\n",
    "        self.prev_val = self.data.close[0]\n",
    "        \n",
    "        # If using 'trad' scaling method, get boxes now as they are fixed\n",
    "        if scaling == 'trad':\n",
    "            self.generate_boxes(method='trad')\n",
    "\n",
    "        # Is the current column an X or O?\n",
    "        col_is_x = False\n",
    "        col_is_o = False\n",
    "        \n",
    "        # Iterate through data and calculate pnf events\n",
    "        for ii, row in self.data.iterrows():\n",
    "            # Skip the first day\n",
    "            if(ii == self.data.index[0]):\n",
    "                continue\n",
    "                \n",
    "            # For percentage based method, calculate boxes each iteration\n",
    "            if scaling == 'pct':\n",
    "                self.generate_boxes(value=self.prev_val, method='pct')\n",
    "                \n",
    "            # Get daily high and low\n",
    "            high = row.high\n",
    "            low = row.low\n",
    "            \n",
    "            # Find number of boxes between last box price and current\n",
    "            # highs and lows. We will be concerned with positive difference\n",
    "            # for X columns and negative differences for O columns\n",
    "            high_box_diff = self.get_box_diff(high, self.prev_val, direction='x')\n",
    "            low_box_diff = self.get_box_diff(low, self.prev_val, direction='o')\n",
    "            \n",
    "            # Determine how many boxes of movement are needed to add an X or O\n",
    "            x_thresh = 1 if col_is_x else 3\n",
    "            o_thresh = 1 if col_is_o else 3\n",
    "            \n",
    "            # Check edge case to see if both boxes broke their thresholds\n",
    "            if high_box_diff >= x_thresh and low_box_diff >= o_thresh:\n",
    "                # Check current column, and give priority to current symbol\n",
    "                if col_is_x:\n",
    "                    self.append_pnf_point('x', high_box_diff, date=ii)\n",
    "                    col_is_x, col_is_o = True, False\n",
    "                else:\n",
    "                    self.append_pnf_point('o', low_box_diff, date=ii)\n",
    "                    col_is_o, col_is_x = True, False\n",
    "            else:\n",
    "                # If only one threshold broken, determine which one (if any) and append accordingly.\n",
    "                if high_box_diff >= x_thresh:\n",
    "                    self.append_pnf_point('x', high_box_diff, date=ii)\n",
    "                    col_is_x, col_is_o = True, False\n",
    "\n",
    "                if low_box_diff >= o_thresh:\n",
    "                    self.append_pnf_point('o', low_box_diff, date=ii)\n",
    "                    col_is_o, col_is_x = True, False\n",
    "                    \n",
    "            # Set last value\n",
    "            if len(self.pnf_points) > 0:\n",
    "                self.prev_val = self.pnf_points[-1].value\n",
    "    \n",
    "    def append_pnf_point(self, direction, diff, date):\n",
    "        '''\n",
    "            Append a new PnF point to self._pnf_points\n",
    "            \n",
    "            Args:\n",
    "                direction (char): 'x' or 'o' -- direction of PnF Chart\n",
    "                diff (int): number of boxes we've moved\n",
    "                date (pd.Timestamp): date point was added to chart\n",
    "                \n",
    "            Returns:\n",
    "                Nothing. New points are appended to self._pnf_points\n",
    "        '''\n",
    "        # Get index of previously charted box\n",
    "        val_box_idx = self.boxes[self.boxes <= self.prev_val].idxmax()\n",
    "        # Get date of previously charted value\n",
    "        prev_date = self.pnf_points[-1].date if len(self.pnf_points) > 0 else None\n",
    "        prev_month = datetime.strptime(prev_date, '%Y-%m-%d').month if prev_date != None else None\n",
    "        app_seq = []\n",
    "        for ii in range(1, diff+1):\n",
    "            # Determine if we are moving up or down boxes\n",
    "            box_dir = 1 if direction == 'x' else -1\n",
    "            value = self.boxes[val_box_idx + (ii * box_dir)]\n",
    "            # Determine what marker will be used to plot. If this is the first\n",
    "            # plotted point of a month, we will use a special marker\n",
    "            if datetime.strptime(date, '%Y-%m-%d').month != prev_month:\n",
    "                marker = '^'\n",
    "                prev_month = datetime.strptime(date, '%Y-%m-%d').month\n",
    "            else:\n",
    "                marker = direction\n",
    "            # Create point\n",
    "            point = PnfPoint(direction, value, date, marker)\n",
    "            # Append point to sequence\n",
    "            app_seq.append(point)\n",
    "\n",
    "        # Append these PnF Points to chart's list\n",
    "        if len(self.pnf_points) > 0:\n",
    "            self.pnf_points += app_seq\n",
    "        else:\n",
    "            self.pnf_points = app_seq      \n",
    "            \n",
    "    def generate_pnf_columns(self):\n",
    "        '''\n",
    "            Take the points contained in self._pnf_points and generate the columns\n",
    "            of the corresponding PnF chart\n",
    "            \n",
    "            Args:\n",
    "                None\n",
    "            \n",
    "            Returns:\n",
    "                None. Columns saved to self._columns\n",
    "        '''\n",
    "        prev_dir = ''\n",
    "        column_points = []\n",
    "        for ii, point in enumerate(self.pnf_points):\n",
    "            # X or O?\n",
    "            curr_dir = point.direction\n",
    "            # If same as prev symbol, append to curr column\n",
    "            if curr_dir == prev_dir:\n",
    "                column_points[-1].append(point)\n",
    "            else:\n",
    "                # New column\n",
    "                prev_dir = curr_dir\n",
    "                column_points.append([point])\n",
    "                \n",
    "        # Once we have the points for each column, make PnfColumn objects\n",
    "        for col in column_points:\n",
    "            pnf_col = PnfColumn(points=col, direction=col[0].direction)\n",
    "            self.columns.append(pnf_col)\n",
    "                \n",
    "    def plot_chart(self):\n",
    "        '''\n",
    "            Plot the PnF Chart\n",
    "        '''\n",
    "        fig = plt.figure(1, figsize=(20, 10))\n",
    "        ax = fig.add_subplot(111)\n",
    "        for ii, col in enumerate(self.columns):\n",
    "            # Plot each point in column\n",
    "            for p in col.pnf_points:\n",
    "                y = p.value\n",
    "                x = ii+1\n",
    "                direction = p.direction\n",
    "                marker = p.marker\n",
    "                # Make month transitions blue\n",
    "                if marker == '^':\n",
    "                    color = 'blue'\n",
    "                else:\n",
    "                    color = 'black' if direction == 'x' else 'red'\n",
    "                # Plot points\n",
    "                plt.scatter(x, y, color=color, marker=marker)\n",
    "\n",
    "\n",
    "        # Set Y range for plot\n",
    "        #low = int(np.min([p.price for l in self._columns for p in l]))\n",
    "        #high = int(np.max([p.price for l in self._columns for p in l]))\n",
    "        plt.grid(True)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Instantiate Security and Generate PnF Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sec = Security(raw_data[::-1], date_format='%m/%d/%y')\n",
    "sec.generate_pnf_data(method='trad')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use PnF Data to Make PnF Chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sec.plot_chart()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identify Buy/Sell Signals\n",
    "We will create a class called PatternFinder which will be passed a list of lists of PnfPoints (chart columns) that can be used to identify common chart patterns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PatternFinder():\n",
    "    def __init__(self, pnf_columns):\n",
    "        self.columns = pnf_columns\n",
    "        self._pnf_points = None\n",
    "        \n",
    "    @property\n",
    "    def columns(self):\n",
    "        return self._columns    \n",
    "    @columns.setter\n",
    "    def columns(self, c):\n",
    "        if len(c) == 0:\n",
    "            raise ValueError('self._columns cannot be empty.')\n",
    "        if type(c[0]) != PnfColumn:\n",
    "            raise ValueError('self._columns must be a list of PnfColumn objects')            \n",
    "        self._columns = c\n",
    "        \n",
    "    @property\n",
    "    def pnf_points(self):\n",
    "        return self._pnf_points    \n",
    "    @pnf_points.setter\n",
    "    def pnf_points(self, p):\n",
    "        if len(p) == 0:\n",
    "            raise ValueError('self._pnf_points cannot be empty.')\n",
    "        if type(p[0]) != PnfPoint:\n",
    "            raise ValueError('self._pnf_points must contain elements of type PnfPoint')\n",
    "        self._pnf_points = p\n",
    "        \n",
    "        \n",
    "    def point_from_cols(self):\n",
    "        '''\n",
    "            This will iterate through self._columns and will place each point into\n",
    "            self._pnf_points\n",
    "        '''\n",
    "        points = []        \n",
    "        for col in self.columns:\n",
    "            for p in col.pnf_points:\n",
    "                points.append(p)                \n",
    "        self._pnf_points = points\n",
    "        \n",
    "        \n",
    "    def double_top_break(self):\n",
    "        '''\n",
    "            Identify where double top breaks occur (if at all) in the dataset. A double\n",
    "            top breakout occurs when the current column of Xs exceeds the previous column\n",
    "            of Xs \n",
    "            \n",
    "            Returns:\n",
    "                None. Appends double_top_break feature to PnfPoint._signals\n",
    "        '''\n",
    "        # Start by identifying all X columns\n",
    "        x_col_idxs = []\n",
    "        for ii, col in enumerate(self.columns):\n",
    "            if col.direction == 'x':\n",
    "                x_col_idxs.append(ii)\n",
    "        \n",
    "        # Find all successive pairs of X columns\n",
    "        x_pairs = []\n",
    "        for ii, idx in enumerate(x_col_idxs):\n",
    "            # Break if we are at the last element and can't make a new pair\n",
    "            if ii == len(x_col_idxs) - 1:\n",
    "                break            \n",
    "            # Create pairs\n",
    "            x_pairs.append((x_col_idxs[ii], x_col_idxs[ii+1]))\n",
    "            \n",
    "        # Go through all pairs. If the second column in the pair has a higher max\n",
    "        # than the first, this is a double top breakout\n",
    "        for pair in x_pairs:\n",
    "            col1 = self.columns[pair[0]]\n",
    "            col2 = self.columns[pair[1]]\n",
    "            \n",
    "            if col2.max() > col1.max():\n",
    "                # We have identified that a breakout has occurred in col2. Now\n",
    "                # we must find the point responsible.\n",
    "                for p in self.columns[pair[1]].pnf_points:\n",
    "                    if p.value > col1.max():\n",
    "                        p.signals['double_top'] = True\n",
    "                        break\n",
    "                \n",
    "    def double_bottom_break(self):\n",
    "        '''\n",
    "            A double bottom breakdown occurs when a column of Os dips lower than the previous\n",
    "            column of Os\n",
    "            \n",
    "            Returns:\n",
    "                None. Appends double_bottom key/value to PnfPoint._signals\n",
    "        '''\n",
    "        # First identify all O columns\n",
    "        o_col_idxs = []\n",
    "        for ii, col in enumerate(self.columns):\n",
    "            if col.direction == 'o':\n",
    "                o_col_idxs.append(ii)\n",
    "                \n",
    "        # Find all successive pairs of O columns\n",
    "        o_pairs = []\n",
    "        for ii, idx in enumerate(o_col_idxs):\n",
    "            # Break if we don't have enough remaining points to create a pair\n",
    "            if ii == len(o_col_idxs) - 1:\n",
    "                break\n",
    "            # Create pairs\n",
    "            o_pairs.append((o_col_idxs[ii], o_col_idxs[ii+1]))\n",
    "            \n",
    "        # Go through all pairs. If the second column in the pair has a lower\n",
    "        # min than the first column, this is a double bottom breakdown\n",
    "        for pair in o_pairs:\n",
    "            col1 = self.columns[pair[0]]\n",
    "            col2 = self.columns[pair[1]]\n",
    "            \n",
    "            if col2.min() < col1.min():\n",
    "                # We've identified a double bottom breakdown in this column. Now\n",
    "                # we must find the point responsible\n",
    "                for p in self.columns[pair[1]].pnf_points:\n",
    "                    if p.value < col1.min():\n",
    "                        p.signals['double_bottom'] = True\n",
    "                        break\n",
    "                \n",
    "    def triple_top_break(self):\n",
    "        '''\n",
    "            A triple top breakout occurs when the chart reaches a certain X column level twice,\n",
    "            before breaking through that level on the third column of Xs\n",
    "            \n",
    "            Returns:\n",
    "                None. Appends triple_top_break key/value pair to PnfPoint._signals\n",
    "        '''\n",
    "        # From columns get all X columns\n",
    "        x_col_idxs = []\n",
    "        for ii, col in enumerate(self.columns):\n",
    "            if col.direction == 'x':\n",
    "                x_col_idxs.append(ii)\n",
    "                \n",
    "        # Create triplets of all successive x columns\n",
    "        x_triplets = []\n",
    "        for ii, idx in enumerate(x_col_idxs):\n",
    "            # If we don't have enough remaining indices to make a triplet, break\n",
    "            if ii >= len(x_col_idxs) - 2:\n",
    "                break\n",
    "            # Create triplet\n",
    "            try:\n",
    "                triplet = (idx, x_col_idxs[ii+1], x_col_idxs[ii+2])\n",
    "                x_triplets.append(triplet)\n",
    "            except:\n",
    "                raise ValueError('ERROR: ii: {} | x_cols: {}'.format(ii, len(x_col_idxs)))\n",
    "            \n",
    "        # Check that first two in triplet hit same level, if they did, and third col\n",
    "        # breaks that level, this is a triple top breakout\n",
    "        for triplet in x_triplets:\n",
    "            # Get Columns\n",
    "            col1 = self.columns[triplet[0]]\n",
    "            col2 = self.columns[triplet[1]]\n",
    "            col3 = self.columns[triplet[2]]\n",
    "            \n",
    "            # First two cols hit same level\n",
    "            if col1.max() == col2.max():\n",
    "                # Col 3 exceeds two column level\n",
    "                if col3.max() > col1.max():\n",
    "                    # We know that a triple top break has occurred in \n",
    "                    # this column, now we must find the point responsible\n",
    "                    for p in self.columns[triplet[2]].pnf_points:\n",
    "                        if p.value > col1.max():\n",
    "                            p.signals['triple_top_break'] = True\n",
    "                            break\n",
    "                            \n",
    "    def triple_bottom_break(self):\n",
    "        '''\n",
    "            A triple bottom break occurs when two successive columns of Os dip down to the same\n",
    "            level, and the next column of Os breaks through that level.\n",
    "            \n",
    "            Returns:\n",
    "            None. Appends triple_bottom_break key/value pair to PnfPoint._signals\n",
    "        '''\n",
    "        # First we identify all O columns\n",
    "        o_col_idxs = []\n",
    "        for ii, col in enumerate(self.columns):\n",
    "            if col.direction == 'o':\n",
    "                o_col_idxs.append(ii)\n",
    "                \n",
    "        # Next we create a triplet of all successive 3 O columns\n",
    "        triplets = []\n",
    "        for ii, idx in enumerate(o_col_idxs):\n",
    "            # Break if we are at end of idxs and can't create another triplet\n",
    "            if ii >= len(o_col_idxs) - 2:\n",
    "                break\n",
    "            # Create triplets\n",
    "            try:\n",
    "                triplet = (o_col_idxs[ii], o_col_idxs[ii+1], o_col_idxs[ii+2])\n",
    "                triplets.append(triplet)\n",
    "            except:\n",
    "                raise ValueError('ERROR: ii: {} | o_cols: {}'.format(ii, len(o_col_idxs)))\n",
    "            \n",
    "        # Go through all triplets. If first two cols in triplet have same min level, and\n",
    "        # third col has a lower level, this is a triple bottom breakdown\n",
    "        for triplet in triplets:\n",
    "            col1 = self.columns[triplet[0]]\n",
    "            col2 = self.columns[triplet[1]]\n",
    "            col3 = self.columns[triplet[2]]\n",
    "            \n",
    "            # First two cols have same min value\n",
    "            if col1.min() == col2.min():\n",
    "                # Third column breaks through min\n",
    "                if col3.min() < col1.min():\n",
    "                    # We have identified a triple bottom break in this column.\n",
    "                    # Now we must find the point responsible\n",
    "                    for p in self.columns[triplet[2]].pnf_points:\n",
    "                        if p.value < col1.min():\n",
    "                            p.signals['triple_bottom_break'] = True\n",
    "                            break\n",
    "                            \n",
    "                            \n",
    "    def identify_all_signals(self):\n",
    "        '''\n",
    "            Identify all supported buy/sell signals\n",
    "        '''\n",
    "        self.double_top_break()\n",
    "        self.double_bottom_break()\n",
    "        self.triple_top_break()\n",
    "        self.triple_bottom_break()\n",
    "        self.point_from_cols()\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utilize pattern finder to get all buy/sell signals\n",
    "sec.get_pnf_signals()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use PnF Data to Generate Bars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>direction</th>\n",
       "      <th>double_bottom</th>\n",
       "      <th>double_top</th>\n",
       "      <th>timedelta</th>\n",
       "      <th>triple_bottom_break</th>\n",
       "      <th>triple_top_break</th>\n",
       "      <th>value</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",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-03-12</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>180.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-13</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>182.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-15</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>2 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>186.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-19</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>4 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>188.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-21</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>2 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>194.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-22</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>196.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-25</th>\n",
       "      <td>o</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>3 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>186.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-03-26</th>\n",
       "      <td>o</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>184.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-01</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>6 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>190.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-02</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>192.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-03</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>194.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-05</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>2 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>196.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-08</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>3 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>198.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-09</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>200.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-22</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>13 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>204.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-01</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>9 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>212.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-09</th>\n",
       "      <td>o</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>8 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>196.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-10</th>\n",
       "      <td>o</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>194.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-13</th>\n",
       "      <td>o</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>3 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>184.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-15</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>2 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>190.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-16</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>192.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-20</th>\n",
       "      <td>o</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>4 days</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>182.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-21</th>\n",
       "      <td>x</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>188.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-23</th>\n",
       "      <td>o</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>2 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>178.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-05-29</th>\n",
       "      <td>o</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>6 days</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>176.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           direction  double_bottom  double_top timedelta  \\\n",
       "date                                                        \n",
       "2019-03-12         x          False       False    1 days   \n",
       "2019-03-13         x          False       False    1 days   \n",
       "2019-03-15         x          False       False    2 days   \n",
       "2019-03-19         x          False       False    4 days   \n",
       "2019-03-21         x          False       False    2 days   \n",
       "2019-03-22         x          False       False    1 days   \n",
       "2019-03-25         o          False       False    3 days   \n",
       "2019-03-26         o          False       False    1 days   \n",
       "2019-04-01         x          False       False    6 days   \n",
       "2019-04-02         x          False       False    1 days   \n",
       "2019-04-03         x          False       False    1 days   \n",
       "2019-04-05         x          False       False    2 days   \n",
       "2019-04-08         x          False        True    3 days   \n",
       "2019-04-09         x          False       False    1 days   \n",
       "2019-04-22         x          False       False   13 days   \n",
       "2019-05-01         x          False       False    9 days   \n",
       "2019-05-09         o          False       False    8 days   \n",
       "2019-05-10         o          False       False    1 days   \n",
       "2019-05-13         o          False       False    3 days   \n",
       "2019-05-15         x          False       False    2 days   \n",
       "2019-05-16         x          False       False    1 days   \n",
       "2019-05-20         o           True       False    4 days   \n",
       "2019-05-21         x          False       False    1 days   \n",
       "2019-05-23         o           True       False    2 days   \n",
       "2019-05-29         o          False       False    6 days   \n",
       "\n",
       "            triple_bottom_break  triple_top_break  value  \n",
       "date                                                      \n",
       "2019-03-12                False             False  180.0  \n",
       "2019-03-13                False             False  182.0  \n",
       "2019-03-15                False             False  186.0  \n",
       "2019-03-19                False             False  188.0  \n",
       "2019-03-21                False             False  194.0  \n",
       "2019-03-22                False             False  196.0  \n",
       "2019-03-25                False             False  186.0  \n",
       "2019-03-26                False             False  184.0  \n",
       "2019-04-01                False             False  190.0  \n",
       "2019-04-02                False             False  192.0  \n",
       "2019-04-03                False             False  194.0  \n",
       "2019-04-05                False             False  196.0  \n",
       "2019-04-08                False             False  198.0  \n",
       "2019-04-09                False             False  200.0  \n",
       "2019-04-22                False             False  204.0  \n",
       "2019-05-01                False             False  212.0  \n",
       "2019-05-09                False             False  196.0  \n",
       "2019-05-10                False             False  194.0  \n",
       "2019-05-13                False             False  184.0  \n",
       "2019-05-15                False             False  190.0  \n",
       "2019-05-16                False             False  192.0  \n",
       "2019-05-20                 True             False  182.0  \n",
       "2019-05-21                False             False  188.0  \n",
       "2019-05-23                False             False  178.0  \n",
       "2019-05-29                False             False  176.0  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sec.generate_pnf_bars()\n",
    "sec.pnf_bars.head(15)\n",
    "sec.pnf_bars.iloc[-25:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sec.is_on_buy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define a Relative Strength Class\n",
    "This class will be able to do all relevant RS calculations between two assets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RSInstrument(Security):\n",
    "    def __init__(self, num, den, date_format='%Y-%m-%d'):\n",
    "        # Set numerator and denominator of RS Calc\n",
    "        self.num_sec = num \n",
    "        self.den_sec = den \n",
    "        # Create the combined dataset by dividing metrics from numerator\n",
    "        # by the metrics of the denominator\n",
    "        self.get_rs_data()\n",
    "        # Initialize security using the quotient data\n",
    "        Security.__init__(self, self.data, date_format=date_format)\n",
    "        \n",
    "    @property\n",
    "    def num_sec(self):\n",
    "        return self._num_sec    \n",
    "    @num_sec.setter\n",
    "    def num_sec(self, ns):\n",
    "        if type(ns) != pd.DataFrame:\n",
    "            raise ValueError('self._num_sec must be of type pd.DataFrame')\n",
    "        self._num_sec = ns\n",
    "        \n",
    "    @property\n",
    "    def den_sec(self):\n",
    "        return self._den_sec    \n",
    "    @den_sec.setter\n",
    "    def den_sec(self, ds):\n",
    "        if type(ds) != pd.DataFrame:\n",
    "            raise ValueError('self._den_sec must be of type pd.DataFrame')            \n",
    "        self._den_sec = ds\n",
    "        \n",
    "    def in_col_x(self):\n",
    "        '''\n",
    "            Returns true if the RS Chart is in a column of Xs\n",
    "        '''\n",
    "        if self.pnf_columns == None or len(self.pnf_columns) == 0:\n",
    "            #raise ValueError('self.pnf_columns is not instantiated. Have you run self.generate_pnf_data()?')\n",
    "            return False\n",
    "        return self.pnf_columns[-1].direction ==  'x'\n",
    "        \n",
    "    def get_rs_data(self):\n",
    "        '''\n",
    "            Take data from numerator and divide by data in denominator to get the data\n",
    "            required to create the RS chart\n",
    "        '''\n",
    "        # Do some sort of index checking here to ensure that data actually occurs during\n",
    "        # the same time frame\n",
    "        combined_idx = self.num_sec.index.union(self.den_sec.index)\n",
    "        data = self.num_sec.join(self.den_sec, lsuffix='_num', rsuffix='_den')\n",
    "        \n",
    "        # Back fill to account for any times when either the num/den did not have data\n",
    "        data.fillna(method='bfill', inplace=True)\n",
    "        \n",
    "        # Get the quotient data --  divide numerator values by denominator closes\n",
    "        data['open'] = data['open_num'] / data['close_den']\n",
    "        data['high'] = data['high_num'] / data['close_den']\n",
    "        data['low'] = data['low_num'] / data['close_den']\n",
    "        data['close'] = data['close_num'] / data['close_den']\n",
    "        data['volume'] = data['volume_num'] / data['volume_den']\n",
    "        \n",
    "        # Multiply all quotients by 100 to get percentage points instead of decimals\n",
    "        self.data = data[['open', 'high', 'low', 'close', 'volume']]\n",
    "        self.data *= 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_stockcharts_csv(filename):\n",
    "    '''\n",
    "        Loads data ripped from StockCharts historical data\n",
    "    '''\n",
    "    # Read in file\n",
    "    df = pd.read_csv(filename, index_col='Date')\n",
    "    # Convert columns to lowercase\n",
    "    df.columns = [c.lower() for c in df.columns]\n",
    "    # Drop day column\n",
    "    df = df.drop(['day'], axis=1)\n",
    "    # Drop 1st row -- it is just a horizontal line of ===\n",
    "    df = df.iloc[1:]\n",
    "    # Convert all columns to numeric\n",
    "    for col in df.columns:\n",
    "        df[col] = df[col].apply(lambda x: float(x))\n",
    "    # Reverse to have oldest data first\n",
    "    df = df.loc[::-1]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xlf_df = load_stockcharts_csv('./data/sector/xlf_3y.csv')\n",
    "xlu_df = load_stockcharts_csv('./data/sector/xlu_3y.csv')\n",
    "rsi = RSInstrument(num=xlf_df, den=xlu_df, date_format='%m/%d/%y')\n",
    "rsi.generate_pnf_data()\n",
    "rsi.plot_chart()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create an RS Matrix Class\n",
    "This class will be instantiated with data from at least 2 tickers and then generate an RS matrix using those tickers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RSMatrix:\n",
    "    def __init__(self, ticker_dict):\n",
    "        self.ticker_dict = ticker_dict\n",
    "        self.pattern_finder = None\n",
    "        \n",
    "    @property\n",
    "    def ticker_dict(self):\n",
    "        return self._ticker_dict    \n",
    "    @ticker_dict.setter\n",
    "    def ticker_dict(self, td):\n",
    "        # Check that td is a dictionary\n",
    "        if type(td) != dict:\n",
    "            raise ValueError('self._ticker_dict must be a dictionary')\n",
    "        # Check that td has at least two tickers\n",
    "        if len(list(td.keys())) < 2:\n",
    "            raise ValueError('self._ticker_dict must have at least two tickers worth of data')\n",
    "        # Check that values of td are pd.DataFrames\n",
    "        for k,v in td.items():\n",
    "            if type(v) != pd.DataFrame:\n",
    "                raise ValueError('Values of self._ticker_dict must be of type pd.DataFrame')\n",
    "        self._ticker_dict = td\n",
    "        \n",
    "    @property\n",
    "    def matrix(self):\n",
    "        return self._matrix\n",
    "    \n",
    "    @matrix.setter\n",
    "    def matrix(self, m):\n",
    "        if type(m) != pd.DataFrame:\n",
    "            raise ValueError('self.matrix must be of type pd.DataFrame')\n",
    "        self._matrix = m\n",
    "        \n",
    "    def generate_matrix(self, date_format='%m/%d/%y'):\n",
    "        '''\n",
    "            Create RS matrix using tickers/data in self.ticker_dict\n",
    "        '''\n",
    "        # Matrix is going to be a pandas dataframe whose index is all of the tickers in\n",
    "        # ticker_dict and whose columns are the tickers in ticker_dict plus additional columns\n",
    "        # for buy signal count and X column count\n",
    "        idx = list(self.ticker_dict.keys())\n",
    "        columns = ['buy_count', 'x_count'] + idx[::-1]\n",
    "        self.matrix = pd.DataFrame(columns=columns, index=idx)\n",
    "        self.matrix['buy_count'] = pd.Series(0, index=self.matrix.index)\n",
    "        self.matrix['x_count'] = pd.Series(0, index=self.matrix.index)\n",
    "        \n",
    "        \n",
    "        # For each pair of tickers create an RSInstrument \n",
    "        self.rsi_dict = {}\n",
    "        curr_item = 0\n",
    "        total_items = len(list(self.ticker_dict.keys())) ** 2\n",
    "        for kn,vn in self.ticker_dict.items(): # Numerator symbols\n",
    "            for kd,vd in self.ticker_dict.items(): # Den symbols\n",
    "                # Progress\n",
    "                curr_item += 1\n",
    "                print('Calculating Matrix Element {}/{}'.format(str(curr_item), str(total_items)),\n",
    "                     end='\\r', flush=True)\n",
    "                # Don't compare to self\n",
    "                if kn == kd:\n",
    "                    self.matrix.loc[kn, kd] = '--'\n",
    "                else:\n",
    "                    # Create RSInstrument using symbols\n",
    "                    rsi = RSInstrument(num=vn, den=vd, date_format=date_format)\n",
    "                    rsi.generate_pnf_data(method='trad')\n",
    "                    # Determine if RS Chart is on buy or sell signal\n",
    "                    rsi.get_pnf_signals()\n",
    "                    if rsi.is_on_buy():\n",
    "                        entry = 'B'\n",
    "                        self.matrix.loc[kn, 'buy_count'] += 1\n",
    "                    else:\n",
    "                        entry = 'S'                    \n",
    "                    # Determine if RS Chart in column of Xs or Os\n",
    "                    if rsi.in_col_x():\n",
    "                        entry += 'X'\n",
    "                        self.matrix.loc[kn, 'x_count'] += 1\n",
    "                    else:\n",
    "                        entry += 'O'\n",
    "                        \n",
    "                    # If there is no pnf_data, then put --\n",
    "                    if len(rsi.pnf_points) == 0:\n",
    "                        entry = '--'\n",
    "                    \n",
    "                    # Add entry to RS matrix\n",
    "                    self.matrix.loc[kn, kd] = entry\n",
    "                    \n",
    "    def show(self):\n",
    "        '''\n",
    "            Prints out the RS Matrix in a plotly table\n",
    "        '''\n",
    "        # Add ticker column to matrix\n",
    "        self.matrix['ticker'] = pd.Series(list(self.matrix.index), index=self.matrix.index)\n",
    "        self.matrix['ticker'] = self.matrix.ticker.apply(lambda x: '<b>{}</b>'.format(x.upper()))\n",
    "        col_order = ['ticker'] + [c for c in self.matrix.columns if c != 'ticker']\n",
    "        self.matrix = self.matrix[col_order]\n",
    "        # Determine colors for each cell\n",
    "        cell_colors = []\n",
    "        for c in self.matrix.columns:\n",
    "            col_colors = []\n",
    "            # If this is the buy_count or x_count col, set color to grey\n",
    "            if c in ['buy_count', 'x_count']:\n",
    "                col_colors = ['grey' for cell in self.matrix[c]]\n",
    "            elif c == 'ticker':\n",
    "                col_colors = ['white' for cell in self.matrix[c]]\n",
    "            else:\n",
    "                # If on buy signal, make color green, if on sell make red. If \n",
    "                # this is self:self cell, make white.\n",
    "                for cell in self.matrix[c]:\n",
    "                    if cell == '--':\n",
    "                        col_colors.append('white')\n",
    "                    elif 'B' in cell:\n",
    "                        col_colors.append('green')                    \n",
    "                    else:\n",
    "                        col_colors.append('red')\n",
    "            cell_colors.append(col_colors)\n",
    "                    \n",
    "        \n",
    "        trace = go.Table(\n",
    "            header = dict(\n",
    "                values = ['<b>{}</b>'.format(c.upper()) for c in self.matrix.columns],\n",
    "                line = dict(color=['black']),\n",
    "                fill = dict(color='white'),\n",
    "                align = 'center',\n",
    "                font = dict(color = ['white','black'] , size=16)\n",
    "            ),\n",
    "            cells = dict(\n",
    "                values = [self.matrix[c] for c in self.matrix.columns],\n",
    "                line = dict(color = 'black'),\n",
    "                fill = dict(color = cell_colors),\n",
    "                align = 'center',\n",
    "                font = dict(color = ['black','white'], size = 16),\n",
    "                height = 30\n",
    "            )\n",
    "        )\n",
    "        \n",
    "        # Set table data\n",
    "        table_data = [trace]        \n",
    "        # Plot data\n",
    "        py.iplot(table_data)\n",
    "        \n",
    "        # Drop ticker column\n",
    "        self.matrix = self.matrix.drop(['ticker'], axis=1)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create Sector RS Matrix\n",
    "Using the SP500 Sector ETFs, create a basic RS matrix showing the relative strength between each sector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize all sector ETF dataframes\n",
    "root = './data/sector/'\n",
    "spy_df = load_stockcharts_csv(root + 'spy_3y.csv') # S&P 500\n",
    "xlb_df = load_stockcharts_csv(root + 'xlb_3y.csv') # Building/Materials\n",
    "xlc_df = load_stockcharts_csv(root + 'xlc_3y.csv') # Comm. Services\n",
    "xle_df = load_stockcharts_csv(root + 'xle_3y.csv') # Energy\n",
    "xlf_df = load_stockcharts_csv(root + 'xlf_3y.csv') # Financials\n",
    "xli_df = load_stockcharts_csv(root + 'xli_3y.csv') # Industrials\n",
    "xlk_df = load_stockcharts_csv(root + 'xlk_3y.csv') # Technology\n",
    "xlp_df = load_stockcharts_csv(root + 'xlp_3y.csv') # Staples\n",
    "xlre_df = load_stockcharts_csv(root + 'xlre_3y.csv') # Real Estate\n",
    "xlu_df = load_stockcharts_csv(root + 'xlu_3y.csv') # Utilities\n",
    "xlv_df = load_stockcharts_csv(root + 'xlv_3y.csv') # Healthcare\n",
    "xly_df = load_stockcharts_csv(root + 'xly_3y.csv') # Cons. Discretionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rs = RSInstrument(xlb_df, xlf_df, date_format='%m/%d/%y')\n",
    "rs.generate_pnf_data()\n",
    "rs.get_pnf_signals()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ticker_dict = {\n",
    "    'spy': spy_df,\n",
    "    'xlb': xlb_df,\n",
    "    'xlc': xlc_df,\n",
    "    'xle': xle_df,\n",
    "    'xlf': xlf_df,\n",
    "    'xli': xli_df,\n",
    "    'xlk': xlk_df,\n",
    "    'xlp': xlp_df,\n",
    "    'xlre': xlre_df,\n",
    "    'xlu': xlu_df,\n",
    "    'xlv': xlv_df,\n",
    "    'xly': xly_df\n",
    "}\n",
    "\n",
    "# Run RS Matrix\n",
    "rs_mat = RSMatrix(ticker_dict)\n",
    "rs_mat.generate_matrix()\n",
    "rs_mat.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create an API Controller class\n",
    "The API class will controll all API requests made by our other classes. Within it we can enable functionality for contacting AlphaVantage, FinViz, AWS, etc. This structure will allow for fall back mechanisms in case one method fails, e.g. default to making and AlphaVantage call if our AWS database doesn't have data on a requested security."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class API:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def get_alphavantage(self, tickers, start_date=None, end_date=None):\n",
    "        '''\n",
    "            Get the data for requested tickers using the AlphaVantage API\n",
    "            \n",
    "            Args:\n",
    "                tickers (list of str): the requested tickers\n",
    "                start_date (datetime): the start of the data range\n",
    "                end_date (datetime): the end of the data range\n",
    "                \n",
    "            Returns:\n",
    "                (dict): a dictionary where the key is the ticker and the value is \n",
    "                        the data for that ticker\n",
    "        '''\n",
    "        # Read API key from file. This file is placed in the .gitignore, so you\n",
    "        # will have to supply your own AlphaVantage API key. The file is a .txt\n",
    "        # with only one line containing the api key.\n",
    "        api_file = './config/api_key.txt'\n",
    "        api_key = ''\n",
    "        with open(api_file) as f:\n",
    "            api_key = f.readline()\n",
    "        \n",
    "        # If no start/end date given, default to last two years. If only start date\n",
    "        # given get all data from start date to now. If only end date given, get data\n",
    "        # from the two years prior to the end date.\n",
    "        if start_date == None and end_date == None:\n",
    "            # Get date two years ago\n",
    "            start_date = datetime.now() - relativedelta(years=2)\n",
    "            # End today\n",
    "            end_date = datetime.now()\n",
    "        \n",
    "        if start_date != None and end_date == None:\n",
    "            # End date is today\n",
    "            end_date = datetime.now()\n",
    "            \n",
    "        if start_date == None and end_date != None:\n",
    "            start_date = end_date - relativedelta(years=2)\n",
    "            \n",
    "        start_date = start_date.strftime('%Y-%m-%d')\n",
    "        end_date = end_date.strftime('%Y-%m-%d')\n",
    "        \n",
    "            \n",
    "        # For each ETF, grab data from 1998-2019\n",
    "        data = {}    \n",
    "        for idx, ticker in enumerate(tickers):\n",
    "            # Get daily data from API\n",
    "            print('Obtaining Data for {0} -- {1}/{2}'.format(ticker, (idx+1), len(tickers)),\n",
    "                  end='\\r', flush=True)            \n",
    "            api_path = 'https://www.alphavantage.co/query?function=TIME_SERIES_DAILY'\n",
    "            api_path += '&symbol={0}&outputsize=full&apikey={1}'.format(ticker, api_key)                \n",
    "            r = requests.get(api_path)\n",
    "            df = pd.DataFrame.from_dict(r.json()['Time Series (Daily)']).transpose()\n",
    "            # Rename columns and convert to numeric values\n",
    "            df.columns = [c[3:] for c in df.columns]\n",
    "            for col in df.columns:\n",
    "                df[col] = pd.to_numeric(df[col])\n",
    "            # Save to data dict -- truncate to range between start and end dates\n",
    "            data[ticker] = df.truncate(before=start_date, after=end_date)\n",
    "            # Sleep to avoid API limit of 5 calls per minute -- don't have to sleep after last call\n",
    "            if idx != (len(tickers)-1):\n",
    "                sleep(15)\n",
    "\n",
    "        return data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use API class to get Data from AlphaVantage\n",
    "Using our API class, use the AlphaVantage functionality to get data for sector etfs and generate matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "api = API()\n",
    "sector_etfs = ['spy','xlb','xlc','xle','xlf','xli','xlk','xlp','xlre', 'xlu', 'xlv','xly']\n",
    "ticker_data = api.get_alphavantage(sector_etfs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = RSMatrix(ticker_dict)\n",
    "mat.generate_matrix()\n",
    "mat.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La Lista Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obtaining Data for ttc -- 30/300\r"
     ]
    }
   ],
   "source": [
    "la_lista = ['zts', 'isrg', 'ew', 'masi', 'algn', 'nvda', 'soxx', 'fb', 'robo', 'tyl', 'adbe',\n",
    "           'crm', 'nflx', 'dpz', 'amzn', 'bfam', 'eri', 'race', 'htht', 'hd', 'plnt', 'mktx',\n",
    "           'msci', 'v', 'pypl', 'stz', 'xar', 'rop', 'zbra', 'ttc']\n",
    "api = API()\n",
    "la_lista_data = api.get_alphavantage(la_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "rsi = RSInstrument(num=la_lista_data['amzn'], den=la_lista_data['plnt'])\n",
    "rsi.generate_pnf_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>buy_count</th>\n",
       "      <th>x_count</th>\n",
       "      <th>v</th>\n",
       "      <th>soxx</th>\n",
       "      <th>algn</th>\n",
       "      <th>eri</th>\n",
       "      <th>ew</th>\n",
       "      <th>zts</th>\n",
       "      <th>masi</th>\n",
       "      <th>msci</th>\n",
       "      <th>...</th>\n",
       "      <th>bfam</th>\n",
       "      <th>rop</th>\n",
       "      <th>mktx</th>\n",
       "      <th>tyl</th>\n",
       "      <th>plnt</th>\n",
       "      <th>pypl</th>\n",
       "      <th>race</th>\n",
       "      <th>xar</th>\n",
       "      <th>amzn</th>\n",
       "      <th>fb</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>fb</th>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>amzn</th>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>xar</th>\n",
       "      <td>14</td>\n",
       "      <td>19</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>race</th>\n",
       "      <td>24</td>\n",
       "      <td>17</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pypl</th>\n",
       "      <td>19</td>\n",
       "      <td>9</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plnt</th>\n",
       "      <td>25</td>\n",
       "      <td>13</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>--</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tyl</th>\n",
       "      <td>17</td>\n",
       "      <td>7</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mktx</th>\n",
       "      <td>29</td>\n",
       "      <td>29</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>...</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rop</th>\n",
       "      <td>21</td>\n",
       "      <td>10</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>BO</td>\n",
       "      <td>--</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bfam</th>\n",
       "      <td>25</td>\n",
       "      <td>13</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>...</td>\n",
       "      <td>--</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>isrg</th>\n",
       "      <td>9</td>\n",
       "      <td>12</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>crm</th>\n",
       "      <td>7</td>\n",
       "      <td>27</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>adbe</th>\n",
       "      <td>10</td>\n",
       "      <td>18</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>zbra</th>\n",
       "      <td>14</td>\n",
       "      <td>23</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ttc</th>\n",
       "      <td>13</td>\n",
       "      <td>9</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dpz</th>\n",
       "      <td>22</td>\n",
       "      <td>13</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>htht</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>stz</th>\n",
       "      <td>5</td>\n",
       "      <td>12</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>nvda</th>\n",
       "      <td>1</td>\n",
       "      <td>14</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>robo</th>\n",
       "      <td>3</td>\n",
       "      <td>8</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hd</th>\n",
       "      <td>13</td>\n",
       "      <td>10</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>nflx</th>\n",
       "      <td>9</td>\n",
       "      <td>11</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>msci</th>\n",
       "      <td>26</td>\n",
       "      <td>28</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>masi</th>\n",
       "      <td>9</td>\n",
       "      <td>13</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>zts</th>\n",
       "      <td>20</td>\n",
       "      <td>25</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ew</th>\n",
       "      <td>11</td>\n",
       "      <td>19</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eri</th>\n",
       "      <td>12</td>\n",
       "      <td>13</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algn</th>\n",
       "      <td>6</td>\n",
       "      <td>24</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>--</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>soxx</th>\n",
       "      <td>4</td>\n",
       "      <td>10</td>\n",
       "      <td>SO</td>\n",
       "      <td>--</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>v</th>\n",
       "      <td>18</td>\n",
       "      <td>12</td>\n",
       "      <td>--</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>...</td>\n",
       "      <td>BO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>30 rows × 32 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      buy_count  x_count   v soxx algn eri  ew zts masi msci ... bfam rop  \\\n",
       "fb            3        7  SO   SX   SO  SO  SO  SO   SO   SO ...   SO  SO   \n",
       "amzn          6        9  SO   SO   SO  SO  SO  SO   SO   SO ...   SO  SO   \n",
       "xar          14       19  BX   BX   SX  SX  BX  SO   BX   SX ...   SO  SO   \n",
       "race         24       17  BO   BO   SX  BO  BO  BO   BX   SO ...   BX  SX   \n",
       "pypl         19        9  BO   BO   SO  BO  BO  SX   SO   SO ...   SX  BO   \n",
       "plnt         25       13  BO   BX   SX  BO  BO  SO   BO   SO ...   BO  BX   \n",
       "tyl          17        7  SO   BO   BO  BO  BO  SO   BO   SO ...   SO  SO   \n",
       "mktx         29       29  BX   BX   BX  BX  BX  BX   BX   BX ...   BX  BX   \n",
       "rop          21       10  BO   BX   SO  BO  BO  SO   BX   SO ...   BO  --   \n",
       "bfam         25       13  SO   BO   BO  BO  BO  BO   BX   BO ...   --  SX   \n",
       "isrg          9       12  SO   BX   BO  BO  SO  SX   BX   SO ...   SX  SO   \n",
       "crm           7       27  SX   BX   SX  SX  SX  SX   SX   SX ...   SX  SX   \n",
       "adbe         10       18  SO   BX   BX  SX  SX  SO   BO   SO ...   SX  SO   \n",
       "zbra         14       23  SX   BX   SO  BX  SX  SX   SX   SO ...   SX  SO   \n",
       "ttc          13        9  SO   BO   SO  SO  BO  SO   SX   SO ...   SO  BO   \n",
       "dpz          22       13  BO   BO   BO  BO  BO  SO   BX   SO ...   BO  BO   \n",
       "htht          2        0  SO   SO   SO  SO  SO  SO   SO   SO ...   SO  SO   \n",
       "stz           5       12  BO   BO   SO  SO  SO  SO   SX   SO ...   SX  SO   \n",
       "nvda          1       14  SO   SO   SO  SX  SO  SX   SX   SO ...   SX  SO   \n",
       "robo          3        8  SO   SO   SO  SO  SX  SO   SO   SO ...   SO  SO   \n",
       "hd           13       10  SX   BO   SO  BO  BO  SO   SO   SO ...   SO  SX   \n",
       "nflx          9       11  SO   SX   BO  SO  BO  SO   SX   SO ...   SX  SX   \n",
       "msci         26       28  BX   BX   BX  BX  BX  SX   BX   -- ...   SX  BX   \n",
       "masi          9       13  SX   BX   SO  SO  SO  SO   --   SO ...   SX  BO   \n",
       "zts          20       25  BX   BX   SX  BX  BX  --   SX   SX ...   SX  SO   \n",
       "ew           11       19  SX   BX   BX  SO  --  SX   SX   SO ...   SO  SO   \n",
       "eri          12       13  SX   BO   SO  --  BO  SO   SO   SO ...   SO  BX   \n",
       "algn          6       24  SX   SX   --  BX  SX  SX   SX   SO ...   SX  SX   \n",
       "soxx          4       10  SO   --   SO  SO  BO  SX   SX   SO ...   SO  SO   \n",
       "v            18       12  --   BX   SO  BO  BO  SO   BO   BO ...   BO  SX   \n",
       "\n",
       "     mktx tyl plnt pypl race xar amzn  fb  \n",
       "fb     SO  SO   SO   SO   SO  SX   SO  --  \n",
       "amzn   SO  SO   SO   SO   SO  SO   --  BX  \n",
       "xar    SO  SX   SX   BX   SO  --   SO  BX  \n",
       "race   SO  BX   BO   BX   --  BX   SX  BX  \n",
       "pypl   SO  BO   SO   --   SO  SO   SX  BO  \n",
       "plnt   BO  BO   --   BO   BO  BX   SX  BX  \n",
       "tyl    SO  --   SO   SO   SO  SO   BX  BX  \n",
       "mktx   --  BX   BX   BX   BX  BX   BX  BX  \n",
       "rop    SO  BX   BX   BO   SO  SO   BX  BX  \n",
       "bfam   SO  BX   BO   BO   BO  BX   SX  BX  \n",
       "isrg   SO  SO   SX   SO   SO  SX   SO  BX  \n",
       "crm    SO  SX   SX   SX   SX  SX   SO  BX  \n",
       "adbe   SO  SO   SX   SO   SX  SX   BX  BX  \n",
       "zbra   SO  BX   SX   BX   SX  BX   BO  BX  \n",
       "ttc    SO  SO   SO   SX   SO  BO   BX  SX  \n",
       "dpz    SO  BX   SX   BX   SX  BO   BX  BX  \n",
       "htht   SO  SO   SO   SO   SO  SO   SO  SO  \n",
       "stz    SO  SO   SX   SO   SX  BX   SX  SX  \n",
       "nvda   SO  SX   SO   SX   SO  SX   SO  SX  \n",
       "robo   SO  SO   SO   SO   SO  SO   SO  SO  \n",
       "hd     SO  BX   SO   SX   SX  SO   SO  SX  \n",
       "nflx   SO  SX   SX   SO   SO  SO   BX  BX  \n",
       "msci   SO  BX   BX   BX   BX  BX   BX  BX  \n",
       "masi   SO  SO   SX   SX   SX  SO   SO  BX  \n",
       "zts    SO  BX   BX   BX   BX  BX   SX  BX  \n",
       "ew     SO  BX   SO   SX   SX  SX   BO  BX  \n",
       "eri    SO  BO   BX   SO   SX  SO   SX  SX  \n",
       "algn   SO  SX   SX   SX   SX  SX   BX  BX  \n",
       "soxx   SO  SO   SO   SO   SO  SO   BO  SX  \n",
       "v      SO  BX   SO   SO   SO  SX   SX  BX  \n",
       "\n",
       "[30 rows x 32 columns]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ll_mat.matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating Matrix Element 900/900\r"
     ]
    },
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "linkText": "Export to plot.ly",
        "plotlyServerURL": "https://plot.ly",
        "showLink": false
       },
       "data": [
        {
         "cells": {
          "align": "center",
          "fill": {
           "color": [
            [
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white",
             "white"
            ],
            [
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey"
            ],
            [
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey",
             "grey"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "white"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "red",
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "white",
             "green"
            ],
            [
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "red",
             "green",
             "green",
             "red",
             "green",
             "red",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "red",
             "red",
             "green",
             "red",
             "white",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "white",
             "green",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "red",
             "green",
             "white",
             "green",
             "red",
             "green",
             "green"
            ],
            [
             "red",
             "red",
             "red",
             "green",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "white",
             "red",
             "red",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "white",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "white",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "green",
             "white",
             "green",
             "green",
             "red",
             "red",
             "green",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "white",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "green",
             "green",
             "red",
             "red",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "white",
             "green",
             "red",
             "green",
             "red",
             "green",
             "green",
             "green",
             "red",
             "red",
             "green"
            ],
            [
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "white",
             "red",
             "green",
             "green",
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green"
            ],
            [
             "green",
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "white",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green"
            ],
            [
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "white",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "green",
             "green"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "white",
             "red",
             "red",
             "red",
             "green",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "white",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "white",
             "green",
             "red",
             "red",
             "green",
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "white",
             "red",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "white",
             "red",
             "red",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "green"
            ],
            [
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "white",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "red",
             "green",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "green",
             "white",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "red",
             "green",
             "white",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "red",
             "red",
             "green",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "white",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "white",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "green",
             "green",
             "red",
             "red",
             "green"
            ],
            [
             "red",
             "red",
             "red",
             "green",
             "red",
             "white",
             "red",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "green",
             "green",
             "white",
             "green",
             "red",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "red",
             "white",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "red",
             "white",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red"
            ],
            [
             "red",
             "white",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "red",
             "red",
             "green",
             "red",
             "green",
             "green",
             "red"
            ],
            [
             "white",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "red",
             "red",
             "red",
             "red",
             "green",
             "green",
             "green",
             "green",
             "green",
             "red",
             "green",
             "red",
             "green"
            ]
           ]
          },
          "font": {
           "color": [
            "black",
            "white"
           ],
           "size": 16
          },
          "height": 30,
          "line": {
           "color": "black"
          },
          "values": [
           [
            "<b>FB</b>",
            "<b>AMZN</b>",
            "<b>XAR</b>",
            "<b>RACE</b>",
            "<b>PYPL</b>",
            "<b>PLNT</b>",
            "<b>TYL</b>",
            "<b>MKTX</b>",
            "<b>ROP</b>",
            "<b>BFAM</b>",
            "<b>ISRG</b>",
            "<b>CRM</b>",
            "<b>ADBE</b>",
            "<b>ZBRA</b>",
            "<b>TTC</b>",
            "<b>DPZ</b>",
            "<b>HTHT</b>",
            "<b>STZ</b>",
            "<b>NVDA</b>",
            "<b>ROBO</b>",
            "<b>HD</b>",
            "<b>NFLX</b>",
            "<b>MSCI</b>",
            "<b>MASI</b>",
            "<b>ZTS</b>",
            "<b>EW</b>",
            "<b>ERI</b>",
            "<b>ALGN</b>",
            "<b>SOXX</b>",
            "<b>V</b>"
           ],
           [
            3,
            6,
            14,
            24,
            19,
            25,
            17,
            29,
            21,
            25,
            9,
            7,
            10,
            14,
            13,
            22,
            2,
            5,
            1,
            3,
            13,
            9,
            26,
            9,
            20,
            11,
            12,
            6,
            4,
            18
           ],
           [
            7,
            9,
            19,
            17,
            9,
            13,
            7,
            29,
            10,
            13,
            12,
            27,
            18,
            23,
            9,
            13,
            0,
            12,
            14,
            8,
            10,
            11,
            28,
            13,
            25,
            19,
            13,
            24,
            10,
            12
           ],
           [
            "SO",
            "SO",
            "BX",
            "BO",
            "BO",
            "BO",
            "SO",
            "BX",
            "BO",
            "SO",
            "SO",
            "SX",
            "SO",
            "SX",
            "SO",
            "BO",
            "SO",
            "BO",
            "SO",
            "SO",
            "SX",
            "SO",
            "BX",
            "SX",
            "BX",
            "SX",
            "SX",
            "SX",
            "SO",
            "--"
           ],
           [
            "SX",
            "SO",
            "BX",
            "BO",
            "BO",
            "BX",
            "BO",
            "BX",
            "BX",
            "BO",
            "BX",
            "BX",
            "BX",
            "BX",
            "BO",
            "BO",
            "SO",
            "BO",
            "SO",
            "SO",
            "BO",
            "SX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BO",
            "SX",
            "--",
            "BX"
           ],
           [
            "SO",
            "SO",
            "SX",
            "SX",
            "SO",
            "SX",
            "BO",
            "BX",
            "SO",
            "BO",
            "BO",
            "SX",
            "BX",
            "SO",
            "SO",
            "BO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "BO",
            "BX",
            "SO",
            "SX",
            "BX",
            "SO",
            "--",
            "SO",
            "SO"
           ],
           [
            "SO",
            "SO",
            "SX",
            "BO",
            "BO",
            "BO",
            "BO",
            "BX",
            "BO",
            "BO",
            "BO",
            "SX",
            "SX",
            "BX",
            "SO",
            "BO",
            "SO",
            "SO",
            "SX",
            "SO",
            "BO",
            "SO",
            "BX",
            "SO",
            "BX",
            "SO",
            "--",
            "BX",
            "SO",
            "BO"
           ],
           [
            "SO",
            "SO",
            "BX",
            "BO",
            "BO",
            "BO",
            "BO",
            "BX",
            "BO",
            "BO",
            "SO",
            "SX",
            "SX",
            "SX",
            "BO",
            "BO",
            "SO",
            "SO",
            "SO",
            "SX",
            "BO",
            "BO",
            "BX",
            "SO",
            "BX",
            "--",
            "BO",
            "SX",
            "BO",
            "BO"
           ],
           [
            "SO",
            "SO",
            "SO",
            "BO",
            "SX",
            "SO",
            "SO",
            "BX",
            "SO",
            "BO",
            "SX",
            "SX",
            "SO",
            "SX",
            "SO",
            "SO",
            "SO",
            "SO",
            "SX",
            "SO",
            "SO",
            "SO",
            "SX",
            "SO",
            "--",
            "SX",
            "SO",
            "SX",
            "SX",
            "SO"
           ],
           [
            "SO",
            "SO",
            "BX",
            "BX",
            "SO",
            "BO",
            "BO",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "BO",
            "SX",
            "SX",
            "BX",
            "SO",
            "SX",
            "SX",
            "SO",
            "SO",
            "SX",
            "BX",
            "--",
            "SX",
            "SX",
            "SO",
            "SX",
            "SX",
            "BO"
           ],
           [
            "SO",
            "SO",
            "SX",
            "SO",
            "SO",
            "SO",
            "SO",
            "BX",
            "SO",
            "BO",
            "SO",
            "SX",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "--",
            "SO",
            "SX",
            "SO",
            "SO",
            "SO",
            "SO",
            "BO"
           ],
           [
            "SO",
            "SX",
            "SX",
            "BX",
            "BO",
            "BX",
            "BO",
            "BX",
            "BO",
            "BX",
            "BO",
            "SX",
            "SX",
            "SX",
            "BO",
            "BO",
            "BO",
            "SX",
            "SO",
            "SX",
            "BX",
            "--",
            "BX",
            "BO",
            "SX",
            "SO",
            "BX",
            "SX",
            "SX",
            "BO"
           ],
           [
            "SX",
            "SO",
            "BX",
            "BO",
            "BO",
            "BO",
            "BO",
            "BX",
            "BO",
            "BX",
            "SO",
            "SX",
            "SX",
            "BX",
            "BO",
            "BO",
            "SO",
            "SX",
            "SX",
            "SO",
            "--",
            "SO",
            "BX",
            "SO",
            "BX",
            "SX",
            "BO",
            "SX",
            "SO",
            "BO"
           ],
           [
            "SX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "BX",
            "SX",
            "BO",
            "BO",
            "SX",
            "SX",
            "BX",
            "BX",
            "SX",
            "SO",
            "SO",
            "SX",
            "--",
            "BO",
            "SX",
            "BX",
            "SX",
            "BX",
            "BX",
            "BX",
            "SX",
            "SX",
            "BX"
           ],
           [
            "BO",
            "BX",
            "BO",
            "BO",
            "BX",
            "BO",
            "BX",
            "BX",
            "BO",
            "BO",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BO",
            "SO",
            "--",
            "SX",
            "BO",
            "BO",
            "BX",
            "SX",
            "BX",
            "BO",
            "BO",
            "BO",
            "BX",
            "BO"
           ],
           [
            "BX",
            "BX",
            "SX",
            "BX",
            "BO",
            "BX",
            "BO",
            "BX",
            "BO",
            "BO",
            "SX",
            "BX",
            "BX",
            "BX",
            "SX",
            "BO",
            "SO",
            "--",
            "SX",
            "BX",
            "BX",
            "BO",
            "BX",
            "BX",
            "SX",
            "BX",
            "SO",
            "BX",
            "SX",
            "BX"
           ],
           [
            "SX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "--",
            "SO",
            "BO",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "BO",
            "BX",
            "BX"
           ],
           [
            "SO",
            "SX",
            "BO",
            "BX",
            "BO",
            "BO",
            "SO",
            "BX",
            "SO",
            "BX",
            "SX",
            "SX",
            "SX",
            "SX",
            "BO",
            "--",
            "SO",
            "SX",
            "SX",
            "BO",
            "SX",
            "SO",
            "BX",
            "SO",
            "BO",
            "SO",
            "SO",
            "SX",
            "SO",
            "SO"
           ],
           [
            "SX",
            "BO",
            "SX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "--",
            "BX",
            "SO",
            "SX",
            "SO",
            "SX",
            "BO",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "SX",
            "SX",
            "BX"
           ],
           [
            "SO",
            "SX",
            "BO",
            "BO",
            "BO",
            "BO",
            "BO",
            "BX",
            "BO",
            "BO",
            "SO",
            "SX",
            "SO",
            "--",
            "BO",
            "SO",
            "SO",
            "BO",
            "SX",
            "SX",
            "BO",
            "BO",
            "BX",
            "BO",
            "BX",
            "SX",
            "BX",
            "SX",
            "SO",
            "SO"
           ],
           [
            "SO",
            "SO",
            "SX",
            "BX",
            "BX",
            "BX",
            "BO",
            "BX",
            "BX",
            "BX",
            "SO",
            "SX",
            "--",
            "SX",
            "SO",
            "BX",
            "SO",
            "SX",
            "SX",
            "SO",
            "SO",
            "SO",
            "BX",
            "SO",
            "BX",
            "SX",
            "SX",
            "SX",
            "SX",
            "BX"
           ],
           [
            "SO",
            "SX",
            "BO",
            "BO",
            "BO",
            "BO",
            "BO",
            "BX",
            "BO",
            "BO",
            "SO",
            "--",
            "SO",
            "SX",
            "SO",
            "BO",
            "SO",
            "SO",
            "SO",
            "SO",
            "BO",
            "SO",
            "BX",
            "SO",
            "BO",
            "SX",
            "BO",
            "SO",
            "SO",
            "BO"
           ],
           [
            "BO",
            "SO",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BO",
            "BX",
            "--",
            "BX",
            "BO",
            "BO",
            "BX",
            "BX",
            "SO",
            "BO",
            "SO",
            "SX",
            "BO",
            "SO",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "SO",
            "BX"
           ],
           [
            "SO",
            "SO",
            "SO",
            "BX",
            "SX",
            "BO",
            "SO",
            "BX",
            "BO",
            "--",
            "SX",
            "SX",
            "SX",
            "SX",
            "SO",
            "BO",
            "SO",
            "SX",
            "SX",
            "SO",
            "SO",
            "SX",
            "SX",
            "SX",
            "SX",
            "SO",
            "SO",
            "SX",
            "SO",
            "BO"
           ],
           [
            "SO",
            "SO",
            "SO",
            "SX",
            "BO",
            "BX",
            "SO",
            "BX",
            "--",
            "SX",
            "SO",
            "SX",
            "SO",
            "SO",
            "BO",
            "BO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SX",
            "SX",
            "BX",
            "BO",
            "SO",
            "SO",
            "BX",
            "SX",
            "SO",
            "SX"
           ],
           [
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "BO",
            "SO",
            "--",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO",
            "SO"
           ],
           [
            "SO",
            "SO",
            "SX",
            "BX",
            "BO",
            "BO",
            "--",
            "BX",
            "BX",
            "BX",
            "SO",
            "SX",
            "SO",
            "BX",
            "SO",
            "BX",
            "SO",
            "SO",
            "SX",
            "SO",
            "BX",
            "SX",
            "BX",
            "SO",
            "BX",
            "BX",
            "BO",
            "SX",
            "SO",
            "BX"
           ],
           [
            "SO",
            "SO",
            "SX",
            "BO",
            "SO",
            "--",
            "SO",
            "BX",
            "BX",
            "BO",
            "SX",
            "SX",
            "SX",
            "SX",
            "SO",
            "SX",
            "SO",
            "SX",
            "SO",
            "SO",
            "SO",
            "SX",
            "BX",
            "SX",
            "BX",
            "SO",
            "BX",
            "SX",
            "SO",
            "SO"
           ],
           [
            "SO",
            "SO",
            "BX",
            "BX",
            "--",
            "BO",
            "SO",
            "BX",
            "BO",
            "BO",
            "SO",
            "SX",
            "SO",
            "BX",
            "SX",
            "BX",
            "SO",
            "SO",
            "SX",
            "SO",
            "SX",
            "SO",
            "BX",
            "SX",
            "BX",
            "SX",
            "SO",
            "SX",
            "SO",
            "SO"
           ],
           [
            "SO",
            "SO",
            "SO",
            "--",
            "SO",
            "BO",
            "SO",
            "BX",
            "SO",
            "BO",
            "SO",
            "SX",
            "SX",
            "SX",
            "SO",
            "SX",
            "SO",
            "SX",
            "SO",
            "SO",
            "SX",
            "SO",
            "BX",
            "SX",
            "BX",
            "SX",
            "SX",
            "SX",
            "SO",
            "SO"
           ],
           [
            "SX",
            "SO",
            "--",
            "BX",
            "SO",
            "BX",
            "SO",
            "BX",
            "SO",
            "BX",
            "SX",
            "SX",
            "SX",
            "BX",
            "BO",
            "BO",
            "SO",
            "BX",
            "SX",
            "SO",
            "SO",
            "SO",
            "BX",
            "SO",
            "BX",
            "SX",
            "SO",
            "SX",
            "SO",
            "SX"
           ],
           [
            "SO",
            "--",
            "SO",
            "SX",
            "SX",
            "SX",
            "BX",
            "BX",
            "BX",
            "SX",
            "SO",
            "SO",
            "BX",
            "BO",
            "BX",
            "BX",
            "SO",
            "SX",
            "SO",
            "SO",
            "SO",
            "BX",
            "BX",
            "SO",
            "SX",
            "BO",
            "SX",
            "BX",
            "BO",
            "SX"
           ],
           [
            "--",
            "BX",
            "BX",
            "BX",
            "BO",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "BX",
            "SO",
            "SX",
            "SX",
            "SO",
            "SX",
            "BX",
            "BX",
            "BX",
            "BX",
            "BX",
            "SX",
            "BX",
            "SX",
            "BX"
           ]
          ]
         },
         "header": {
          "align": "center",
          "fill": {
           "color": "white"
          },
          "font": {
           "color": [
            "white",
            "black"
           ],
           "size": 16
          },
          "line": {
           "color": [
            "black"
           ]
          },
          "values": [
           "<b>TICKER</b>",
           "<b>BUY_COUNT</b>",
           "<b>X_COUNT</b>",
           "<b>V</b>",
           "<b>SOXX</b>",
           "<b>ALGN</b>",
           "<b>ERI</b>",
           "<b>EW</b>",
           "<b>ZTS</b>",
           "<b>MASI</b>",
           "<b>MSCI</b>",
           "<b>NFLX</b>",
           "<b>HD</b>",
           "<b>ROBO</b>",
           "<b>NVDA</b>",
           "<b>STZ</b>",
           "<b>HTHT</b>",
           "<b>DPZ</b>",
           "<b>TTC</b>",
           "<b>ZBRA</b>",
           "<b>ADBE</b>",
           "<b>CRM</b>",
           "<b>ISRG</b>",
           "<b>BFAM</b>",
           "<b>ROP</b>",
           "<b>MKTX</b>",
           "<b>TYL</b>",
           "<b>PLNT</b>",
           "<b>PYPL</b>",
           "<b>RACE</b>",
           "<b>XAR</b>",
           "<b>AMZN</b>",
           "<b>FB</b>"
          ]
         },
         "type": "table",
         "uid": "92570486-d152-4974-b9bc-d0458583f549"
        }
       ],
       "layout": {}
      },
      "text/html": [
       "<div>\n",
       "        \n",
       "        \n",
       "            <div id=\"88789d47-c2f0-48ab-b540-65dcf8d71986\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>\n",
       "            <script type=\"text/javascript\">\n",
       "                require([\"plotly\"], function(Plotly) {\n",
       "                    window.PLOTLYENV=window.PLOTLYENV || {};\n",
       "                    window.PLOTLYENV.BASE_URL='https://plot.ly';\n",
       "                    \n",
       "                if (document.getElementById(\"88789d47-c2f0-48ab-b540-65dcf8d71986\")) {\n",
       "                    Plotly.newPlot(\n",
       "                        '88789d47-c2f0-48ab-b540-65dcf8d71986',\n",
       "                        [{\"cells\": {\"align\": \"center\", \"fill\": {\"color\": [[\"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\", \"white\"], [\"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\"], [\"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\", \"grey\"], [\"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"white\"], [\"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"red\", \"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"white\", \"green\"], [\"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"red\", \"green\", \"green\", \"red\", \"green\", \"red\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"red\", \"red\", \"green\", \"red\", \"white\", \"red\", \"red\"], [\"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"white\", \"green\", \"red\", \"green\"], [\"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"red\", \"green\", \"white\", \"green\", \"red\", \"green\", \"green\"], [\"red\", \"red\", \"red\", \"green\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"white\", \"red\", \"red\", \"red\", \"red\", \"red\"], [\"red\", \"red\", \"green\", \"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"white\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"white\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"green\", \"white\", \"green\", \"green\", \"red\", \"red\", \"green\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"white\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"green\"], [\"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"green\", \"green\", \"red\", \"red\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"white\", \"green\", \"red\", \"green\", \"red\", \"green\", \"green\", \"green\", \"red\", \"red\", \"green\"], [\"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"white\", \"red\", \"green\", \"green\", \"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\"], [\"green\", \"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"white\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\"], [\"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"white\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"green\", \"green\"], [\"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"white\", \"red\", \"red\", \"red\", \"green\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\"], [\"red\", \"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"white\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"white\", \"green\", \"red\", \"red\", \"green\", \"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\"], [\"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"white\", \"red\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"white\", \"red\", \"red\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"green\"], [\"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"white\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"red\", \"green\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"green\", \"white\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"red\", \"green\", \"white\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"red\", \"red\", \"green\", \"red\", \"red\", \"red\"], [\"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"white\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\"], [\"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"white\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"green\", \"green\", \"red\", \"red\", \"green\"], [\"red\", \"red\", \"red\", \"green\", \"red\", \"white\", \"red\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\"], [\"red\", \"red\", \"green\", \"green\", \"white\", \"green\", \"red\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\"], [\"red\", \"red\", \"red\", \"white\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\"], [\"red\", \"red\", \"white\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\"], [\"red\", \"white\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"red\", \"red\", \"green\", \"red\", \"green\", \"green\", \"red\"], [\"white\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"red\", \"red\", \"red\", \"red\", \"green\", \"green\", \"green\", \"green\", \"green\", \"red\", \"green\", \"red\", \"green\"]]}, \"font\": {\"color\": [\"black\", \"white\"], \"size\": 16}, \"height\": 30, \"line\": {\"color\": \"black\"}, \"values\": [[\"<b>FB</b>\", \"<b>AMZN</b>\", \"<b>XAR</b>\", \"<b>RACE</b>\", \"<b>PYPL</b>\", \"<b>PLNT</b>\", \"<b>TYL</b>\", \"<b>MKTX</b>\", \"<b>ROP</b>\", \"<b>BFAM</b>\", \"<b>ISRG</b>\", \"<b>CRM</b>\", \"<b>ADBE</b>\", \"<b>ZBRA</b>\", \"<b>TTC</b>\", \"<b>DPZ</b>\", \"<b>HTHT</b>\", \"<b>STZ</b>\", \"<b>NVDA</b>\", \"<b>ROBO</b>\", \"<b>HD</b>\", \"<b>NFLX</b>\", \"<b>MSCI</b>\", \"<b>MASI</b>\", \"<b>ZTS</b>\", \"<b>EW</b>\", \"<b>ERI</b>\", \"<b>ALGN</b>\", \"<b>SOXX</b>\", \"<b>V</b>\"], [3, 6, 14, 24, 19, 25, 17, 29, 21, 25, 9, 7, 10, 14, 13, 22, 2, 5, 1, 3, 13, 9, 26, 9, 20, 11, 12, 6, 4, 18], [7, 9, 19, 17, 9, 13, 7, 29, 10, 13, 12, 27, 18, 23, 9, 13, 0, 12, 14, 8, 10, 11, 28, 13, 25, 19, 13, 24, 10, 12], [\"SO\", \"SO\", \"BX\", \"BO\", \"BO\", \"BO\", \"SO\", \"BX\", \"BO\", \"SO\", \"SO\", \"SX\", \"SO\", \"SX\", \"SO\", \"BO\", \"SO\", \"BO\", \"SO\", \"SO\", \"SX\", \"SO\", \"BX\", \"SX\", \"BX\", \"SX\", \"SX\", \"SX\", \"SO\", \"--\"], [\"SX\", \"SO\", \"BX\", \"BO\", \"BO\", \"BX\", \"BO\", \"BX\", \"BX\", \"BO\", \"BX\", \"BX\", \"BX\", \"BX\", \"BO\", \"BO\", \"SO\", \"BO\", \"SO\", \"SO\", \"BO\", \"SX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BO\", \"SX\", \"--\", \"BX\"], [\"SO\", \"SO\", \"SX\", \"SX\", \"SO\", \"SX\", \"BO\", \"BX\", \"SO\", \"BO\", \"BO\", \"SX\", \"BX\", \"SO\", \"SO\", \"BO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"BO\", \"BX\", \"SO\", \"SX\", \"BX\", \"SO\", \"--\", \"SO\", \"SO\"], [\"SO\", \"SO\", \"SX\", \"BO\", \"BO\", \"BO\", \"BO\", \"BX\", \"BO\", \"BO\", \"BO\", \"SX\", \"SX\", \"BX\", \"SO\", \"BO\", \"SO\", \"SO\", \"SX\", \"SO\", \"BO\", \"SO\", \"BX\", \"SO\", \"BX\", \"SO\", \"--\", \"BX\", \"SO\", \"BO\"], [\"SO\", \"SO\", \"BX\", \"BO\", \"BO\", \"BO\", \"BO\", \"BX\", \"BO\", \"BO\", \"SO\", \"SX\", \"SX\", \"SX\", \"BO\", \"BO\", \"SO\", \"SO\", \"SO\", \"SX\", \"BO\", \"BO\", \"BX\", \"SO\", \"BX\", \"--\", \"BO\", \"SX\", \"BO\", \"BO\"], [\"SO\", \"SO\", \"SO\", \"BO\", \"SX\", \"SO\", \"SO\", \"BX\", \"SO\", \"BO\", \"SX\", \"SX\", \"SO\", \"SX\", \"SO\", \"SO\", \"SO\", \"SO\", \"SX\", \"SO\", \"SO\", \"SO\", \"SX\", \"SO\", \"--\", \"SX\", \"SO\", \"SX\", \"SX\", \"SO\"], [\"SO\", \"SO\", \"BX\", \"BX\", \"SO\", \"BO\", \"BO\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"BO\", \"SX\", \"SX\", \"BX\", \"SO\", \"SX\", \"SX\", \"SO\", \"SO\", \"SX\", \"BX\", \"--\", \"SX\", \"SX\", \"SO\", \"SX\", \"SX\", \"BO\"], [\"SO\", \"SO\", \"SX\", \"SO\", \"SO\", \"SO\", \"SO\", \"BX\", \"SO\", \"BO\", \"SO\", \"SX\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"--\", \"SO\", \"SX\", \"SO\", \"SO\", \"SO\", \"SO\", \"BO\"], [\"SO\", \"SX\", \"SX\", \"BX\", \"BO\", \"BX\", \"BO\", \"BX\", \"BO\", \"BX\", \"BO\", \"SX\", \"SX\", \"SX\", \"BO\", \"BO\", \"BO\", \"SX\", \"SO\", \"SX\", \"BX\", \"--\", \"BX\", \"BO\", \"SX\", \"SO\", \"BX\", \"SX\", \"SX\", \"BO\"], [\"SX\", \"SO\", \"BX\", \"BO\", \"BO\", \"BO\", \"BO\", \"BX\", \"BO\", \"BX\", \"SO\", \"SX\", \"SX\", \"BX\", \"BO\", \"BO\", \"SO\", \"SX\", \"SX\", \"SO\", \"--\", \"SO\", \"BX\", \"SO\", \"BX\", \"SX\", \"BO\", \"SX\", \"SO\", \"BO\"], [\"SX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"BX\", \"SX\", \"BO\", \"BO\", \"SX\", \"SX\", \"BX\", \"BX\", \"SX\", \"SO\", \"SO\", \"SX\", \"--\", \"BO\", \"SX\", \"BX\", \"SX\", \"BX\", \"BX\", \"BX\", \"SX\", \"SX\", \"BX\"], [\"BO\", \"BX\", \"BO\", \"BO\", \"BX\", \"BO\", \"BX\", \"BX\", \"BO\", \"BO\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BO\", \"SO\", \"--\", \"SX\", \"BO\", \"BO\", \"BX\", \"SX\", \"BX\", \"BO\", \"BO\", \"BO\", \"BX\", \"BO\"], [\"BX\", \"BX\", \"SX\", \"BX\", \"BO\", \"BX\", \"BO\", \"BX\", \"BO\", \"BO\", \"SX\", \"BX\", \"BX\", \"BX\", \"SX\", \"BO\", \"SO\", \"--\", \"SX\", \"BX\", \"BX\", \"BO\", \"BX\", \"BX\", \"SX\", \"BX\", \"SO\", \"BX\", \"SX\", \"BX\"], [\"SX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"--\", \"SO\", \"BO\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"BO\", \"BX\", \"BX\"], [\"SO\", \"SX\", \"BO\", \"BX\", \"BO\", \"BO\", \"SO\", \"BX\", \"SO\", \"BX\", \"SX\", \"SX\", \"SX\", \"SX\", \"BO\", \"--\", \"SO\", \"SX\", \"SX\", \"BO\", \"SX\", \"SO\", \"BX\", \"SO\", \"BO\", \"SO\", \"SO\", \"SX\", \"SO\", \"SO\"], [\"SX\", \"BO\", \"SX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"--\", \"BX\", \"SO\", \"SX\", \"SO\", \"SX\", \"BO\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"SX\", \"SX\", \"BX\"], [\"SO\", \"SX\", \"BO\", \"BO\", \"BO\", \"BO\", \"BO\", \"BX\", \"BO\", \"BO\", \"SO\", \"SX\", \"SO\", \"--\", \"BO\", \"SO\", \"SO\", \"BO\", \"SX\", \"SX\", \"BO\", \"BO\", \"BX\", \"BO\", \"BX\", \"SX\", \"BX\", \"SX\", \"SO\", \"SO\"], [\"SO\", \"SO\", \"SX\", \"BX\", \"BX\", \"BX\", \"BO\", \"BX\", \"BX\", \"BX\", \"SO\", \"SX\", \"--\", \"SX\", \"SO\", \"BX\", \"SO\", \"SX\", \"SX\", \"SO\", \"SO\", \"SO\", \"BX\", \"SO\", \"BX\", \"SX\", \"SX\", \"SX\", \"SX\", \"BX\"], [\"SO\", \"SX\", \"BO\", \"BO\", \"BO\", \"BO\", \"BO\", \"BX\", \"BO\", \"BO\", \"SO\", \"--\", \"SO\", \"SX\", \"SO\", \"BO\", \"SO\", \"SO\", \"SO\", \"SO\", \"BO\", \"SO\", \"BX\", \"SO\", \"BO\", \"SX\", \"BO\", \"SO\", \"SO\", \"BO\"], [\"BO\", \"SO\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BO\", \"BX\", \"--\", \"BX\", \"BO\", \"BO\", \"BX\", \"BX\", \"SO\", \"BO\", \"SO\", \"SX\", \"BO\", \"SO\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"SO\", \"BX\"], [\"SO\", \"SO\", \"SO\", \"BX\", \"SX\", \"BO\", \"SO\", \"BX\", \"BO\", \"--\", \"SX\", \"SX\", \"SX\", \"SX\", \"SO\", \"BO\", \"SO\", \"SX\", \"SX\", \"SO\", \"SO\", \"SX\", \"SX\", \"SX\", \"SX\", \"SO\", \"SO\", \"SX\", \"SO\", \"BO\"], [\"SO\", \"SO\", \"SO\", \"SX\", \"BO\", \"BX\", \"SO\", \"BX\", \"--\", \"SX\", \"SO\", \"SX\", \"SO\", \"SO\", \"BO\", \"BO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SX\", \"SX\", \"BX\", \"BO\", \"SO\", \"SO\", \"BX\", \"SX\", \"SO\", \"SX\"], [\"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"BO\", \"SO\", \"--\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\", \"SO\"], [\"SO\", \"SO\", \"SX\", \"BX\", \"BO\", \"BO\", \"--\", \"BX\", \"BX\", \"BX\", \"SO\", \"SX\", \"SO\", \"BX\", \"SO\", \"BX\", \"SO\", \"SO\", \"SX\", \"SO\", \"BX\", \"SX\", \"BX\", \"SO\", \"BX\", \"BX\", \"BO\", \"SX\", \"SO\", \"BX\"], [\"SO\", \"SO\", \"SX\", \"BO\", \"SO\", \"--\", \"SO\", \"BX\", \"BX\", \"BO\", \"SX\", \"SX\", \"SX\", \"SX\", \"SO\", \"SX\", \"SO\", \"SX\", \"SO\", \"SO\", \"SO\", \"SX\", \"BX\", \"SX\", \"BX\", \"SO\", \"BX\", \"SX\", \"SO\", \"SO\"], [\"SO\", \"SO\", \"BX\", \"BX\", \"--\", \"BO\", \"SO\", \"BX\", \"BO\", \"BO\", \"SO\", \"SX\", \"SO\", \"BX\", \"SX\", \"BX\", \"SO\", \"SO\", \"SX\", \"SO\", \"SX\", \"SO\", \"BX\", \"SX\", \"BX\", \"SX\", \"SO\", \"SX\", \"SO\", \"SO\"], [\"SO\", \"SO\", \"SO\", \"--\", \"SO\", \"BO\", \"SO\", \"BX\", \"SO\", \"BO\", \"SO\", \"SX\", \"SX\", \"SX\", \"SO\", \"SX\", \"SO\", \"SX\", \"SO\", \"SO\", \"SX\", \"SO\", \"BX\", \"SX\", \"BX\", \"SX\", \"SX\", \"SX\", \"SO\", \"SO\"], [\"SX\", \"SO\", \"--\", \"BX\", \"SO\", \"BX\", \"SO\", \"BX\", \"SO\", \"BX\", \"SX\", \"SX\", \"SX\", \"BX\", \"BO\", \"BO\", \"SO\", \"BX\", \"SX\", \"SO\", \"SO\", \"SO\", \"BX\", \"SO\", \"BX\", \"SX\", \"SO\", \"SX\", \"SO\", \"SX\"], [\"SO\", \"--\", \"SO\", \"SX\", \"SX\", \"SX\", \"BX\", \"BX\", \"BX\", \"SX\", \"SO\", \"SO\", \"BX\", \"BO\", \"BX\", \"BX\", \"SO\", \"SX\", \"SO\", \"SO\", \"SO\", \"BX\", \"BX\", \"SO\", \"SX\", \"BO\", \"SX\", \"BX\", \"BO\", \"SX\"], [\"--\", \"BX\", \"BX\", \"BX\", \"BO\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"BX\", \"SO\", \"SX\", \"SX\", \"SO\", \"SX\", \"BX\", \"BX\", \"BX\", \"BX\", \"BX\", \"SX\", \"BX\", \"SX\", \"BX\"]]}, \"header\": {\"align\": \"center\", \"fill\": {\"color\": \"white\"}, \"font\": {\"color\": [\"white\", \"black\"], \"size\": 16}, \"line\": {\"color\": [\"black\"]}, \"values\": [\"<b>TICKER</b>\", \"<b>BUY_COUNT</b>\", \"<b>X_COUNT</b>\", \"<b>V</b>\", \"<b>SOXX</b>\", \"<b>ALGN</b>\", \"<b>ERI</b>\", \"<b>EW</b>\", \"<b>ZTS</b>\", \"<b>MASI</b>\", \"<b>MSCI</b>\", \"<b>NFLX</b>\", \"<b>HD</b>\", \"<b>ROBO</b>\", \"<b>NVDA</b>\", \"<b>STZ</b>\", \"<b>HTHT</b>\", \"<b>DPZ</b>\", \"<b>TTC</b>\", \"<b>ZBRA</b>\", \"<b>ADBE</b>\", \"<b>CRM</b>\", \"<b>ISRG</b>\", \"<b>BFAM</b>\", \"<b>ROP</b>\", \"<b>MKTX</b>\", \"<b>TYL</b>\", \"<b>PLNT</b>\", \"<b>PYPL</b>\", \"<b>RACE</b>\", \"<b>XAR</b>\", \"<b>AMZN</b>\", \"<b>FB</b>\"]}, \"type\": \"table\", \"uid\": \"92570486-d152-4974-b9bc-d0458583f549\"}],\n",
       "                        {},\n",
       "                        {\"plotlyServerURL\": \"https://plot.ly\", \"showLink\": false, \"linkText\": \"Export to plot.ly\", \"responsive\": true}\n",
       "                    ).then(function(){\n",
       "                            \n",
       "var gd = document.getElementById('88789d47-c2f0-48ab-b540-65dcf8d71986');\n",
       "var x = new MutationObserver(function (mutations, observer) {{\n",
       "        var display = window.getComputedStyle(gd).display;\n",
       "        if (!display || display === 'none') {{\n",
       "            console.log([gd, 'removed!']);\n",
       "            Plotly.purge(gd);\n",
       "            observer.disconnect();\n",
       "        }}\n",
       "}});\n",
       "\n",
       "// Listen for the removal of the full notebook cells\n",
       "var notebookContainer = gd.closest('#notebook-container');\n",
       "if (notebookContainer) {{\n",
       "    x.observe(notebookContainer, {childList: true});\n",
       "}}\n",
       "\n",
       "// Listen for the clearing of the current output cell\n",
       "var outputEl = gd.closest('.output');\n",
       "if (outputEl) {{\n",
       "    x.observe(outputEl, {childList: true});\n",
       "}}\n",
       "\n",
       "                        })\n",
       "                };\n",
       "                });\n",
       "            </script>\n",
       "        </div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ll_mat = RSMatrix(la_lista_data)\n",
    "ll_mat.generate_matrix(date_format='%Y-%m-%d')\n",
    "ll_mat.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>buy_count</th>\n",
       "      <th>x_count</th>\n",
       "      <th>v</th>\n",
       "      <th>soxx</th>\n",
       "      <th>algn</th>\n",
       "      <th>eri</th>\n",
       "      <th>ew</th>\n",
       "      <th>zts</th>\n",
       "      <th>masi</th>\n",
       "      <th>msci</th>\n",
       "      <th>...</th>\n",
       "      <th>bfam</th>\n",
       "      <th>rop</th>\n",
       "      <th>mktx</th>\n",
       "      <th>tyl</th>\n",
       "      <th>plnt</th>\n",
       "      <th>pypl</th>\n",
       "      <th>race</th>\n",
       "      <th>xar</th>\n",
       "      <th>amzn</th>\n",
       "      <th>fb</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mktx</th>\n",
       "      <td>29</td>\n",
       "      <td>29</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>...</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>msci</th>\n",
       "      <td>26</td>\n",
       "      <td>28</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plnt</th>\n",
       "      <td>25</td>\n",
       "      <td>13</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>--</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bfam</th>\n",
       "      <td>25</td>\n",
       "      <td>13</td>\n",
       "      <td>SO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>...</td>\n",
       "      <td>--</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>race</th>\n",
       "      <td>24</td>\n",
       "      <td>17</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dpz</th>\n",
       "      <td>22</td>\n",
       "      <td>13</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SO</td>\n",
       "      <td>...</td>\n",
       "      <td>BO</td>\n",
       "      <td>BO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>zts</th>\n",
       "      <td>20</td>\n",
       "      <td>25</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>--</td>\n",
       "      <td>SX</td>\n",
       "      <td>SX</td>\n",
       "      <td>...</td>\n",
       "      <td>SX</td>\n",
       "      <td>SO</td>\n",
       "      <td>SO</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>BX</td>\n",
       "      <td>SX</td>\n",
       "      <td>BX</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>7 rows × 32 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      buy_count  x_count   v soxx algn eri  ew zts masi msci ... bfam rop  \\\n",
       "mktx         29       29  BX   BX   BX  BX  BX  BX   BX   BX ...   BX  BX   \n",
       "msci         26       28  BX   BX   BX  BX  BX  SX   BX   -- ...   SX  BX   \n",
       "plnt         25       13  BO   BX   SX  BO  BO  SO   BO   SO ...   BO  BX   \n",
       "bfam         25       13  SO   BO   BO  BO  BO  BO   BX   BO ...   --  SX   \n",
       "race         24       17  BO   BO   SX  BO  BO  BO   BX   SO ...   BX  SX   \n",
       "dpz          22       13  BO   BO   BO  BO  BO  SO   BX   SO ...   BO  BO   \n",
       "zts          20       25  BX   BX   SX  BX  BX  --   SX   SX ...   SX  SO   \n",
       "\n",
       "     mktx tyl plnt pypl race xar amzn  fb  \n",
       "mktx   --  BX   BX   BX   BX  BX   BX  BX  \n",
       "msci   SO  BX   BX   BX   BX  BX   BX  BX  \n",
       "plnt   BO  BO   --   BO   BO  BX   SX  BX  \n",
       "bfam   SO  BX   BO   BO   BO  BX   SX  BX  \n",
       "race   SO  BX   BO   BX   --  BX   SX  BX  \n",
       "dpz    SO  BX   SX   BX   SX  BO   BX  BX  \n",
       "zts    SO  BX   BX   BX   BX  BX   SX  BX  \n",
       "\n",
       "[7 rows x 32 columns]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rank by best short term\n",
    "short_term_idx = ll_mat.matrix.sort_values(by=['x_count'], ascending=False).index\n",
    "\n",
    "# Rank by best long term\n",
    "long_term_idx = ll_mat.matrix.sort_values(by=['buy_count'], ascending=False).index\n",
    "\n",
    "# Find top half short term performers who are also in the top third of long term\n",
    "rows = len(ll_mat.matrix)\n",
    "top_half_short = ll_mat.matrix.nlargest(rows//2, 'x_count').index\n",
    "top_third_long = ll_mat.matrix.nlargest(rows//3, 'buy_count').index\n",
    "\n",
    "# Find index overlap\n",
    "idx = top_third_long.intersection(top_half_short)\n",
    "ll_mat.matrix.loc[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'll_mat' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-eaa65bf68367>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mll_mat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'll_mat' is not defined"
     ]
    }
   ],
   "source": [
    "ll_mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:julie-stav-ws]",
   "language": "python",
   "name": "conda-env-julie-stav-ws-py"
  },
  "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}