Market Breadth Technical v1.2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ad7898e87ab44d2ae207dce3eec9c5d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='\\n    <div style=\"font-size:14px; color:lightskyblue;\">\\n        <i class=\"fa fa-ci…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "__version__='0.1.2'\n",
    "# env mar.2020\n",
    "# Import the required libraries\n",
    "import bql\n",
    "import bqport\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import heatMap\n",
    "from collections import OrderedDict\n",
    "#from bqwidgets import TickerAutoComplete, DataGrid, DatePicker\n",
    "import bqwidgets as bqw\n",
    "import bqviz as bqv\n",
    "import bqplot as bqp\n",
    "from bqplot import  Tooltip,Figure,Lines, Axis\n",
    "from bqplot.interacts import IndexSelector\n",
    "from ipywidgets import *\n",
    "import bqwidgets as bqw\n",
    "from IPython.display import display, clear_output\n",
    "np.warnings.filterwarnings('ignore', category=np.RankWarning)\n",
    "import datetime as dt\n",
    "import warnings\n",
    "from bql.om.exceptions import InvalidParameterGroupError\n",
    "warnings.filterwarnings(\"ignore\", category=np.VisibleDeprecationWarning) \n",
    "warnings.filterwarnings(\"ignore\") \n",
    "#Loading animation\n",
    "loading_html = HTML(\"\"\"\n",
    "    <div style=\"font-size:14px; color:lightskyblue;\">\n",
    "        <i class=\"fa fa-circle-o-notch fa-spin\"></i><span>&nbsp;Loading...</span>\n",
    "    </div>\"\"\")\n",
    "\n",
    "preload_box = HBox([loading_html])\n",
    "preload_box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Create an instance of BQL for querying data.\n",
    "# Instantiate an object to interface with the BQL service\n",
    "if \"bq\" not in globals(): \n",
    "    bq = bql.Service()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "path=''\n",
    "color_selection = '#F39F41'\n",
    "\n",
    "import pickle\n",
    "from collections import OrderedDict\n",
    "from datetime import timedelta\n",
    "\n",
    "try: \n",
    "    f = open(path + 'settings_breadth.pckl', 'rb')\n",
    "    deft_settings = pickle.load(f)\n",
    "    f.close() \n",
    "    \n",
    "except:\n",
    "    deft_settings = OrderedDict()\n",
    "    deft_settings['universe_settings'] = {}\n",
    "    deft_settings['date_settings'] = {}\n",
    "    \n",
    "def save_settings(caller=None):\n",
    "    dict_settings = OrderedDict()\n",
    "    dict_settings['universe_settings'] = universe_picker.settings\n",
    "    dict_settings['date_settings'] = date_picker.settings\n",
    "    \n",
    "    f=open(path + 'settings_breadth.pckl','wb')\n",
    "    pickle.dump(dict_settings, f)\n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import apputils\n",
    "\n",
    "bq = bql.Service()\n",
    "#apputils.bq = bq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class DatePicker:\n",
    "    def __init__(self, deft_settings=None):\n",
    "        try:\n",
    "            defalut_interval = deft_settings['univ_dropdown']\n",
    "        except:\n",
    "            defalut_interval = '365d'\n",
    "        self._label_as_of_date = Label(value='As of Date:',layout=Layout(width='180px'))\n",
    "        self.as_of_date_picker=bqw.DatePicker(value=(dt.datetime.now()).strftime('%Y-%m-%d'),date_format='%Y-%m-%d')\n",
    "        self._label_interval = Label(value='History Length (days)',layout=Layout(width='180px'))\n",
    "        self.text_interval = Text(value=defalut_interval)\n",
    "        self._box = VBox([HBox([self._label_interval,self.text_interval]), \n",
    "                          HBox([self._label_as_of_date,self.as_of_date_picker])])\n",
    "    def show(self):\n",
    "        return self._box\n",
    "    \n",
    "    @property\n",
    "    def settings(self):\n",
    "        dict_settings={}\n",
    "        dict_settings['interval'] = self._label_interval.value\n",
    "        return dict_settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "universe_picker = apputils.UniversePicker(lst_universe_types=['Index', 'Portfolio', 'Exchanges', 'List', 'All Active Equities'],ipw_container=False,deft_settings=deft_settings['universe_settings'],\n",
    "                                         max_universe_count=20000, _bq=bq)\n",
    "date_picker = DatePicker(deft_settings=deft_settings['date_settings'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Senting\n",
    "upper_thurshold={}\n",
    "upper_thurshold['default'] = 50\n",
    "upper_thurshold['Advanced'] = 60\n",
    "upper_thurshold['Declined'] = 60\n",
    "upper_thurshold['52w High'] = 30\n",
    "upper_thurshold['52w Low'] = 30\n",
    "upper_thurshold['4w High'] = 50\n",
    "upper_thurshold['4w Low'] = 50\n",
    "upper_thurshold['RSI < 30'] = 20\n",
    "upper_thurshold['RSI > 70'] = 20\n",
    "upper_thurshold['>10D Avg'] = 80\n",
    "upper_thurshold['>50D Avg'] = 60\n",
    "upper_thurshold['>250D Avg'] = 60\n",
    "upper_thurshold['Trender'] = 60\n",
    "upper_thurshold['>Boll UB'] = 30\n",
    "upper_thurshold['&ltBoll LB'] = 30\n",
    "\n",
    "lower_thurshold={}\n",
    "lower_thurshold['>10D Avg'] = 20\n",
    "lower_thurshold['>50D Avg'] = 40\n",
    "lower_thurshold['>250D Avg'] = 40\n",
    "lower_thurshold['Trender'] = 40\n",
    "\n",
    "lower_is_better_fields = ['Declined','52w Low','RSI < 30','4w Low','52w Low','&ltBoll LB']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def _get_sector_details():\n",
    "    #global df_details, request, response\n",
    "    as_of_date=asof_datepicker.value\n",
    "    label_as_of = Label('As of: ' + date_picker.as_of_date_picker.value)\n",
    "    datafields=OrderedDict()\n",
    "    datafields['Name'] = bq.data.name().value(mapby=\"ORDINAL\")\n",
    "    px_last = bq.data.px_last(start='-10d',end=as_of_date,per='d',ca_adj='full')\n",
    "    dates = px_last['DATE']\n",
    "    for k,v in build_bq_dateitem([bq.data.id(),dates],'-10d',as_of_date).items():\n",
    "        datafields[k] = v\n",
    "    #datafields.update(build_bq_dateitem(bq.data.id(),'-10d',as_of_date))\n",
    "    request =  bql.Request(bq.univ.filter(universe_picker.universe,universe_picker.grouping_bqitem==selected_sector), datafields)\n",
    "    response = bq.execute(request)\n",
    "    rename_col = {dates.format_for_query_string().upper():'Date',bq.data.id().format_for_query_string().upper():'ID'}\n",
    "    def merge(response): return pd.concat([sir.df().rename(columns=rename_col).set_index(['ID','Date']).dropna(how='all')[sir.name] for sir in response[1:]], axis=1)\n",
    "    #def merge(response): return pd.concat([sir.df()[sir.name] for sir in response], axis=1)\n",
    "    df_details = merge(response)\n",
    "    df_details = df_details.reset_index()\n",
    "    df_details = df_details.loc[df_details['Date'] == df_details['Date'].max()].set_index('ID')\n",
    "    df_details = response[0].df().join(df_details)\n",
    "    df_details.index.name='ID'\n",
    "    df_details = df_details.reset_index()\n",
    "    df_details['ID'] = df_details['ID'].apply(lambda x:x.split(' ')[0] + ': ')\n",
    "    df_details['ID'] = df_details['ID'] + df_details['Name']\n",
    "    df_details = df_details.set_index('ID')\n",
    "    heatmap_details = heatMap.GenerateHeatMap()\n",
    "#     heatmap_details.generate_heatmaps([{'data': df_details[['Name']],'table_mode':True,'width':'200px'}]+\n",
    "#                           [{'data':df_details[[name]],'reverse_color':True if name in lower_is_better_fields else False,'upper_bound':1} for name in df_details.columns if name not in ['Name','#Company','Price']], \n",
    "#                       empty_space_width='0px',button_width='68px', header_height='30px',row_select=True, upper_bound=thurshold.get('default',None))\n",
    "    heatmap_details.generate_heatmaps([{'data':df_details[[name]],'reverse_color':True if name in lower_is_better_fields else False,\n",
    "                                        'upper_bound':1,\n",
    "                                        'lower_bound':0 if lower_thurshold.get(name,None) else None\n",
    "                                       } for name in df_details.columns if name not in ['Name','#Company','Price','Date','ORIG_IDS']], \n",
    "                      empty_space_width='0px',button_width='68px', header_height='30px',row_select=True, upper_bound=upper_thurshold.get('default',None))\n",
    "    box_heatmap_details.children = [VBox([label_as_of,VBox(layout={'min_height':'20px'}), heatmap_details.get_widget()],layout={'overflow_y':'scroll'})]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def build_bq_dateitem(grouping, date_interval, as_of_date):\n",
    "\n",
    "    px_last = bq.data.px_last(start=date_interval,end=as_of_date,per='d',ca_adj='full')\n",
    "    px_last_w = bq.data.px_last(start=date_interval,end=as_of_date,per='w',ca_adj='full')\n",
    "    px_high = bq.data.px_high(start=date_interval,end=as_of_date,per='d',ca_adj='full')\n",
    "    px_low = bq.data.px_low(start=date_interval,end=as_of_date,per='d',ca_adj='full')\n",
    "    dates = px_last['DATE']\n",
    "    roc = bq.data.roc(px_last,period=1)\n",
    "    mxmn = bq.data.maxmin(px_high,px_low)\n",
    "    boll = bq.data.boll(px_last)\n",
    "\n",
    "    datafields=OrderedDict()\n",
    "    datafields['Advanced'] = (bq.func.if_(roc>0,1,0)).group(grouping).sum()/roc.group(grouping).count()\n",
    "    datafields['Declined'] = (bq.func.if_(roc<0,1,0)).group(grouping).sum()/roc.group(grouping).count()\n",
    "    datafields['>10D Avg'] = (bq.func.if_(px_last-bq.data.smavg(px_last,period=10)>0,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['>50D Avg'] = (bq.func.if_(px_last-bq.data.smavg(px_last,period=50)>0,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['>250D Avg'] = (bq.func.if_(px_last-bq.data.smavg(px_last,period=250)>0,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['4w High'] = (bq.func.if_(mxmn.with_additional_parameters(period=20)['maxline']/px_high==1,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['4w Low'] = (bq.func.if_(mxmn.with_additional_parameters(period=20)['minline']/px_low==1,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['52w High'] = (bq.func.if_(mxmn.with_additional_parameters(period=260)['maxline']/px_high==1,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['52w Low'] = (bq.func.if_(mxmn.with_additional_parameters(period=260)['minline']/px_low==1,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['RSI < 30'] = (bq.func.if_(bq.data.RSI(px_last,period=14)<30,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    datafields['RSI > 70'] = (bq.func.if_(bq.data.RSI(px_last,period=14)>70,1,0).group(grouping).sum()/\n",
    "                px_last.group(grouping).count())\n",
    "    \n",
    "#     datafields['Abv BOLL'] = (bq.func.if_(boll['UPPERBAND']<px_last,1,0).group(grouping).sum()/\n",
    "#                 px_last.group(grouping).count())\n",
    "#     datafields['Blw BOLL'] = (bq.func.if_(boll['LOWERBAND']>px_last,1,0).group(grouping).sum()/\n",
    "#                 px_last.group(grouping).count())\n",
    "    datafields['MACD'] = (bq.func.if_(bq.data.macd(px_last)['MACD2']>0,1,0).group(grouping).sum()/\n",
    "                              px_last.group(grouping).count())\n",
    "    datafields['>Boll UB'] = (bq.func.if_(bq.data.boll(px_last)['UpperBand']<=px_last,1,0).group(grouping).sum()/\n",
    "                              px_last.group(grouping).count())\n",
    "    datafields['&ltBoll LB'] = (bq.func.if_(bq.data.boll(px_last)['LowerBand']>=px_last,1,0).group(grouping).sum()/\n",
    "                              px_last.group(grouping).count())\n",
    "#     datafields['MACD (W)'] = (bq.func.if_(bq.data.macd(px_last_w)['MACD2']>0,1,0).group(grouping).sum()/\n",
    "#                               px_last_w.group(grouping).count())\n",
    "    datafields['Trender'] = (bq.data.TRENDER(px_high, px_low, px_last,SENSITIVITY = 'MEDIUMTERM6')['TRENDERUP'].group(grouping).count()/\n",
    "                px_last.group(grouping).count())\n",
    "    return datafields\n",
    "\n",
    "\n",
    "\n",
    "def button_run_on_click(btn=None):\n",
    "    global grid_data, df_main, heatmap, lower_is_better_fields, selected_sector, box_heatmap_details, df_overall\n",
    "    global RSI_Line_plot, adv_dec_plot\n",
    "    global intsel, asof_datepicker, df_return, df_main, df_adv_dec, df_RSI, df_MA\n",
    "    \n",
    "    #box_status.children=[loading_html]\n",
    "    as_of_date=date_picker.as_of_date_picker.value\n",
    "    date_interval = date_picker.text_interval.value\n",
    "    if date_interval[0]!='-': date_interval='-' + date_interval\n",
    "    if date_interval[-1].upper()!='D': date_interval= date_interval +'D'\n",
    "    \n",
    "    px_last = bq.data.px_last(start=date_interval,end=as_of_date,per='d',ca_adj='full')\n",
    "    px_high = bq.data.px_high(start=date_interval,end=as_of_date,per='d',ca_adj='full')\n",
    "    px_low = bq.data.px_low(start=date_interval,end=as_of_date,per='d',ca_adj='full')\n",
    "    mxmn = bq.data.maxmin(px_high,px_low)\n",
    "    dates = px_last['DATE']\n",
    "    sector = universe_picker.grouping_bqitem\n",
    "    grouping = [sector, dates]\n",
    "    datafields = build_bq_dateitem(grouping, date_interval, as_of_date)\n",
    "    datafields['Mkt Cap'] = (bq.data.cur_mkt_cap(start=date_interval,end=as_of_date,per='d',currency='USD',fill='prev')/1000000).group(grouping).sum()\n",
    "    datafields['Return'] = (bq.data.day_to_day_tot_return_gross_dvds(start=date_interval,end=as_of_date,per='d',currency='USD') * \n",
    "                               bq.data.cur_mkt_cap(start=date_interval,end=as_of_date,per='d',currency='USD',fill='prev')/1000000).group(grouping).sum()\n",
    "    datafields['#Company'] = px_last.group(grouping).count()\n",
    "    \n",
    "    \n",
    "    rename_col = {dates.format_for_query_string().upper():'Date',sector.format_for_query_string().upper():'Sector'}\n",
    "#     univ = universe_picker.universe\n",
    "#     if univ is None:\n",
    "#         box_status.children=[]\n",
    "#         return None\n",
    "#     request=bql.Request(univ, datafields)\n",
    "#     try:\n",
    "#         response= bq.execute(request)\n",
    "#     except bql.ResponseError as reserror:\n",
    "#         universe_picker._update_status(reserror.exception_messages, warning=True)\n",
    "#         return None\n",
    "#     #response[0].df()\n",
    "    def merge(response): return pd.concat([sir.df().rename(columns=rename_col).set_index(['Sector','Date']).dropna(how='all')[sir.name] for sir in response], axis=1)\n",
    "#     df_main = merge(response).dropna()\n",
    "    df_main = universe_picker.request_data(datafields, merge)\n",
    "    if df_main is None:\n",
    "        #box_status.children=[]\n",
    "        return None\n",
    "    df_main = df_main.dropna()\n",
    "    df_main = df_main.loc[df_main.index.dropna()]\n",
    "    df_main=df_main.reset_index()\n",
    "    try: #2018-11-19 backward capable to BQL change\n",
    "        df_main['Date']=df_main['Date'].apply(lambda x:dt.datetime.strptime(x[:10],'%Y-%m-%d'))\n",
    "    except:\n",
    "        pass\n",
    "    date_max=df_main['Date'].max()\n",
    "    date_min=df_main['Date'].min()\n",
    "    \n",
    "    # universe overall\n",
    "    grouping = [dates]\n",
    "    datafields = build_bq_dateitem(grouping, date_interval, as_of_date)\n",
    "    datafields['Mkt Cap'] = (bq.data.cur_mkt_cap(start=date_interval,end=as_of_date,per='d',currency='USD',fill='prev')/1000000).group(grouping).sum()\n",
    "    datafields['Return'] = (bq.data.day_to_day_tot_return_gross_dvds(start=date_interval,end=as_of_date,per='d',currency='USD') * \n",
    "                               bq.data.cur_mkt_cap(start=date_interval,end=as_of_date,per='d',currency='USD',fill='prev')/1000000).group(grouping).sum()\n",
    "    datafields['#Company'] = px_last.group(grouping).count()\n",
    "#     request=bql.Request(univ, datafields)\n",
    "#     response= bq.execute(request)\n",
    "    #response[0].df()\n",
    "    def merge(response): return pd.concat([sir.df().rename(columns=rename_col).set_index(['Date']).dropna(how='all')[sir.name] for sir in response], axis=1)\n",
    "    #df_overall = merge(response).dropna()\n",
    "    df_overall = universe_picker.request_data(datafields, merge)\n",
    "    if df_overall is None:\n",
    "        #box_status.children=[]\n",
    "        return None\n",
    "    df_overall = df_overall.dropna()\n",
    "    df_overall['Sector'] = \"Overall Universe\"\n",
    "    df_overall=df_overall.reset_index()\n",
    "    df_main = df_main.append(df_overall)[df_main.columns]\n",
    "    \n",
    "    df_main=df_main.set_index(['Sector','Date']).apply(lambda x:round(x*100))\n",
    "    df_main['#Company']=df_main['#Company'].apply(lambda x:x/100)\n",
    "    df_main['Price']=df_main['Return']/df_main['Mkt Cap']\n",
    "    grid_data = df_main.xs(date_max,level='Date')\n",
    "    \n",
    "    df_return = df_main.reset_index().pivot(index='Date',columns='Sector',values='Price')\n",
    "    df_return = df_return.dropna()\n",
    "    #df_return = (df_return.pct_change().fillna(value=0)+1).cumprod()-1\n",
    "    df_return = (df_return.fillna(value=0)+1).cumprod()-1\n",
    "    \n",
    "    def on_selected_change(*args):\n",
    "        global grid_data\n",
    "        try:\n",
    "            if args[0]['old']['selected']['type'] == 'float':\n",
    "                args[0]['old']['selected']['type'] = 'object'\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        try:\n",
    "            if args[0]['new']['selected']['type'] == 'float':\n",
    "                args[0]['new']['selected']['type'] = 'object'\n",
    "        except:\n",
    "            pass\n",
    "    \n",
    "\n",
    "        if(indx_px_plot._figure.marks[0].selected is None or not indx_px_plot._figure.marks[0].selected):\n",
    "            return\n",
    "        #try:\n",
    "        date=df_return.index[indx_px_plot._figure.marks[0].selected][0]\n",
    "#             grid.data = df_main.xs(date,level='Date').reset_index()\n",
    "        asof_datepicker.unobserve(on_datepicker)\n",
    "        asof_datepicker.value = date.strftime('%Y-%m-%d')\n",
    "        asof_datepicker.observe(on_datepicker)\n",
    "        grid_data = df_main.xs(date,level='Date')\n",
    "        update_heatmap(grid_data)\n",
    "#         except:\n",
    "#             pass\n",
    "    display_fields=[]\n",
    "\n",
    "\n",
    "    def on_datepicker(*args):\n",
    "        intsel.unobserve(on_selected_change)\n",
    "        intsel.selected = [np.datetime64(dt.datetime.strptime(asof_datepicker.value,'%Y-%m-%d'))]\n",
    "        grid_data = df_main.xs(asof_datepicker.value,level='Date')\n",
    "        update_heatmap(grid_data)\n",
    "        intsel.observe(on_selected_change)\n",
    "    \n",
    "    asof_datepicker = bqw.DatePicker(date_format='%Y-%m-%d',description='As of date: ',value = date_max.strftime('%Y-%m-%d'), \n",
    "                                     min_date=date_min.strftime('%Y-%m-%d'), max_date=date_max.strftime('%Y-%m-%d'), layout={'left':'5px'})\n",
    "    asof_datepicker.observe(on_datepicker)\n",
    "\n",
    "    flag_indx = False\n",
    "    if universe_picker._dropdown_type.value=='Index':\n",
    "        flag_indx = True\n",
    "        indx = universe_picker._ac_index.value\n",
    "        datafields=OrderedDict()\n",
    "        datafields['Price'] = px_last\n",
    "        datafields['Return'] = (bq.data.day_to_day_tot_return_gross_dvds(start=date_interval,end=as_of_date,per='d',currency='USD')+1).cumprod()-1\n",
    "        datafields['maxmin'] = mxmn.with_additional_parameters(period=20)\n",
    "        request=bql.Request(indx, datafields)\n",
    "        response= bq.execute(request)\n",
    "        #df_indx_px = response[0].df().set_index('DATE')[['Price','4w High','4w Low']].dropna()\n",
    "        def merge(response): return pd.concat([sir.df().set_index('DATE') for sir in response], axis=1)\n",
    "        df_indx_px = merge(response).rename(columns={'MINLINE':'MinLine', 'MAXLINE':'MaxLine'}) #backward capable for BQL return header in capital letters\n",
    "        #df_indx_px = df_indx_px[['Price','MinLine','MaxLine']].dropna()\n",
    "        indx_px_plot = bqv.InteractiveLinePlot(df_indx_px[['Price','MinLine','MaxLine']].dropna(), title='Index Level and 4 weeks High Low- ' +indx, hide_controls=True)\n",
    "        \n",
    "    else:\n",
    "        df_indx_px = df_return[['Overall Universe']]+1\n",
    "        indx_px_plot = bqv.InteractiveLinePlot(df_indx_px[['Overall Universe']], title='Index Level (market cap weighted)', hide_controls=True)\n",
    "        indx = universe_picker.description\n",
    "        \n",
    "    intsel = IndexSelector(scale=indx_px_plot._figure.axes[0].scale, marks=indx_px_plot._figure.marks)\n",
    "    intsel.observe(on_selected_change)\n",
    "    indx_px_plot._figure.interaction=intsel\n",
    "    lst_inactive_intsel = []\n",
    "    def on_grid_select(obj=None):\n",
    "\n",
    "        global selected_sector\n",
    "        #if obj.get('name')=='selected_row_indices':\n",
    "        #selected_sector = grid.data['Sector'][obj.get('new')[0]]\n",
    "        selected_sector = heatmap.get_selected_cells()[0][0]\n",
    "        if selected_sector != 'Overall Universe':\n",
    "            sector_return_chart.push(df_return[['Overall Universe',selected_sector]])\n",
    "        else:\n",
    "            sector_return_chart.push(df_return[[selected_sector]])\n",
    "        sector_return_chart._figure.title = 'Return - ' + selected_sector\n",
    "        sc_y2 = bqp.LinearScale()\n",
    "        ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical',side='right',grid_lines='none')\n",
    "        sector_return_chart.figure.axes=[sector_return_chart.figure.axes[0],sector_return_chart.figure.axes[1],ax_y2]\n",
    "\n",
    "        adv_dec_plot.push(df_adv_dec[['Advanced','Declined']].loc[selected_sector])\n",
    "        adv_dec_plot._figure.title = '% Movers - ' + selected_sector\n",
    "        sc_x = adv_dec_plot.figure.axes[0].scale\n",
    "        sc_y = adv_dec_plot.figure.axes[1].scale\n",
    "        sc_y2 = bqp.LinearScale()\n",
    "        ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical', label='Cum Sum',side='right',grid_lines='none')\n",
    "        intsel = IndexSelector(scale=sc_x, marks=indx_px_plot._figure.marks)\n",
    "        line = Lines(x=df_adv_dec.loc[selected_sector].index, y=df_adv_dec['Cum Sum'].loc[selected_sector],\n",
    "                     scales={'x': sc_x, 'y': sc_y2},colors=['#F39F41','#626262'],title='% Movers - ' + selected_sector)\n",
    "\n",
    "        adv_dec_plot.figure.marks=[adv_dec_plot.figure.marks[0]] + [line]\n",
    "        adv_dec_plot.figure.axes=[adv_dec_plot.figure.axes[0],adv_dec_plot.figure.axes[1],ax_y2]\n",
    "        df_MA = df_main[['>10D Avg','>50D Avg','>250D Avg']]\n",
    "        MA_Line_plot.push(df_MA.loc[selected_sector])\n",
    "        MA_Line_plot._figure.title = '% Above Moving Avg - ' + selected_sector\n",
    "        MA_Line_plot = bqv.LinePlot(df_MA.loc[selected_sector],title='% Above Moving Avg - ' + selected_sector)\n",
    "        sc_y2 = bqp.LinearScale()\n",
    "        ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical',side='right',grid_lines='none')\n",
    "        MA_Line_plot.figure.axes=[MA_Line_plot.figure.axes[0],MA_Line_plot.figure.axes[1],ax_y2]\n",
    "        df_RSI = df_main[['RSI > 70']]\n",
    "        df_RSI['RSI < 30'] = -df_main['RSI < 30']\n",
    "        RSI_Line_plot.push(df_RSI.loc[selected_sector])\n",
    "        RSI_Line_plot._figure.title = '% RSI Overbought vs Oversold - ' + selected_sector\n",
    "        df_RSI['RSI Net'] = df_main['RSI > 70'] - df_main['RSI < 30']\n",
    "        df_RSI['Cum RSI Net']=df_RSI['RSI Net'].groupby(level=[0]).cumsum()\n",
    "        sc_x = RSI_Line_plot.figure.axes[0].scale\n",
    "        sc_y = RSI_Line_plot.figure.axes[1].scale\n",
    "        sc_y2 = bqp.LinearScale()\n",
    "        ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical', label='Cum Sum',side='right')\n",
    "        line = Lines(x=df_RSI.loc[selected_sector].index, y=df_RSI['Cum RSI Net'].loc[selected_sector],\n",
    "                     scales={'x': sc_x, 'y': sc_y2},colors=['#F39F41','#626262'])\n",
    "        RSI_Line_plot.figure.marks=[RSI_Line_plot.figure.marks[0]] + [line]\n",
    "        RSI_Line_plot.figure.axes=[RSI_Line_plot.figure.axes[0],RSI_Line_plot.figure.axes[1],ax_y2]\n",
    "        label_detail.value = apputils._HTML_TITLE.format('Selected group: ' + selected_sector)\n",
    "        \n",
    "    heatmap = heatMap.GenerateHeatMap()\n",
    "    heatmap.generate_heatmaps([{'data': grid_data[['#Company']],'table_mode':True}]+\n",
    "                              [{'data':grid_data[[name]],'reverse_color':True if name in lower_is_better_fields else False,\n",
    "                                'upper_bound':upper_thurshold.get(name,upper_thurshold.get('default',None)),\n",
    "                                'lower_bound':lower_thurshold.get(name,lower_thurshold.get('default',None)),\n",
    "                                'tooltip': 'Highlighted {color} if {indicator} is over {value}. {low_bound_str}'.format(color='red' if name in lower_is_better_fields else 'green',\n",
    "                                                                                        indicator = name,\n",
    "                                                                                        value = upper_thurshold.get(name,upper_thurshold.get('default','NA')),\n",
    "                                                                                        low_bound_str = 'Highlighted {color} if {indicator} is below {value}'.format(\n",
    "                                                                                        color='green' if name in lower_is_better_fields else 'red',\n",
    "                                                                                        indicator = name,\n",
    "                                                                                        value = lower_thurshold.get(name,lower_thurshold.get('default','NA'))\n",
    "                                                                                        ) if lower_thurshold.get(name,lower_thurshold.get('default',None)) is not None else ''\n",
    "                                                                                        )\n",
    "                               } for name in grid_data.columns if name not in ['#Company','Price','Mkt Cap','Return']], \n",
    "                          empty_space_width='1px',button_width='75px', header_height='30px',row_select=True,call_back=on_grid_select, upper_bound=upper_thurshold.get('default',None))\n",
    "    \n",
    "    grid=heatmap.get_widget()\n",
    "    #ui_main = VBox([indx_px_plot.show(),label_asof, grid])\n",
    "    label_indx_plot = HTML(apputils._HTML_STR_GRAY.format('Drag on the price chart to move back in time for the table below') ,layout={'left':'20px'})\n",
    "    label_grid = HTML(apputils._HTML_STR_GRAY.format('Numbers in the table represent % of company in the group have met the technical analysis condition'),layout={'left':'20px'})\n",
    "    ui_main = VBox([label_indx_plot,indx_px_plot.show(),HBox([asof_datepicker],layout={'margin':'0px 50px 0px 0px'}), label_grid, grid], layout={'overflow_x' : 'hidden'})\n",
    "    #grid.observe(on_grid_select)\n",
    "    \n",
    "    selected_sector = df_main.index.levels[0][0]\n",
    "    #df_return[indx]=df_indx_px['Return']#(df_indx_px['Price'].pct_change()+1).cumprod()-1\n",
    "    df_return=df_return.dropna()\n",
    "    \n",
    "    df_adv_dec = df_main[['Advanced']]\n",
    "    df_adv_dec['Declined']=-df_main['Declined']\n",
    "    # Chart - Adv dec chart\n",
    "    adv_dec_plot = bqv.BarPlot(df_adv_dec[['Advanced','Declined']].loc[selected_sector],bar_type='stacked',padding=0.01,\n",
    "                               title='Cumulative # Movers - ' + selected_sector)\n",
    "    adv_dec_plot.figure.animation_duration=1000\n",
    "    sc_x = adv_dec_plot.figure.axes[0].scale\n",
    "    sc_y = adv_dec_plot.figure.axes[1].scale\n",
    "    sc_y2 = bqp.LinearScale()\n",
    "    ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical', label='Cum Sum',side='right')\n",
    "    df_adv_dec['Net'] = df_adv_dec['Advanced'] + df_adv_dec['Declined']\n",
    "    df_adv_dec['5D avg'] = df_adv_dec['Net'].rolling(5).mean()\n",
    "    df_adv_dec['Cum Sum']=df_adv_dec.groupby(level=0)['Net'].cumsum()\n",
    "\n",
    "    line = Lines(x=df_adv_dec.loc[selected_sector].index, y=df_adv_dec['Cum Sum'].loc[selected_sector],\n",
    "                 scales={'x': sc_x, 'y': sc_y2},colors=['#F39F41','#626262'])\n",
    "    adv_dec_plot.figure.marks=[adv_dec_plot.figure.marks[0]] + [line]\n",
    "    adv_dec_plot.figure.axes=[adv_dec_plot.figure.axes[0],adv_dec_plot.figure.axes[1],ax_y2]\n",
    "    \n",
    "    \n",
    "    def _zoom_chart_onclick(btn):\n",
    "        if btn.figure.height =='300px':\n",
    "            btn.figure.height = '700px'\n",
    "        else:\n",
    "            btn.figure.height = '300px'\n",
    "    btn_zoom_adv_dec = apputils.ButtonConfirm(_zoom_chart_onclick, req_confirm=False, icon = 'search', layout={'width':'50px'})\n",
    "    btn_zoom_adv_dec.figure=adv_dec_plot\n",
    "    \n",
    "    df_MA = df_main[['>10D Avg','>50D Avg','>250D Avg']]\n",
    "    MA_Line_plot = bqv.LinePlot(df_MA.loc[selected_sector],title='% Above Moving Avg - ' + selected_sector)\n",
    "    sc_y2 = bqp.LinearScale()\n",
    "    ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical',side='right',grid_lines='none')\n",
    "    MA_Line_plot.figure.axes=[MA_Line_plot.figure.axes[0],MA_Line_plot.figure.axes[1],ax_y2]\n",
    "    btn_zoom_MA_plot = apputils.ButtonConfirm(_zoom_chart_onclick, icon = 'search',req_confirm=False, layout={'width':'50px'})\n",
    "    btn_zoom_MA_plot.figure = MA_Line_plot\n",
    "    \n",
    "    df_RSI = df_main[['RSI > 70']]\n",
    "    df_RSI['RSI < 30'] = -df_main['RSI < 30']\n",
    "    RSI_Line_plot= bqv.BarPlot(df_RSI.loc[selected_sector], bar_type='stacked',padding=0.01,title='% RSI Overbought vs Oversold - ' + selected_sector)\n",
    "    RSI_Line_plot.figure.animation_duration=1000\n",
    "    df_RSI['RSI Net'] = df_main['RSI > 70'] - df_main['RSI < 30']\n",
    "    df_RSI['Cum RSI Net']=df_RSI.groupby(level=[0])['RSI Net'].cumsum()\n",
    "    sc_x = RSI_Line_plot.figure.axes[0].scale\n",
    "    sc_y = RSI_Line_plot.figure.axes[1].scale\n",
    "    sc_y2 = bqp.LinearScale()\n",
    "    ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical', label='Cum Sum',side='right',grid_lines='none')\n",
    "    line = Lines(x=df_RSI.loc[selected_sector].index, y=df_RSI['Cum RSI Net'].loc[selected_sector],\n",
    "                 scales={'x': sc_x, 'y': sc_y2},colors=['#F39F41','#626262'])\n",
    "    RSI_Line_plot.figure.marks=[RSI_Line_plot.figure.marks[0]] + [line]\n",
    "    RSI_Line_plot.figure.axes=[RSI_Line_plot.figure.axes[0],RSI_Line_plot.figure.axes[1],ax_y2]\n",
    "    btn_zoom_RSI_plot = apputils.ButtonConfirm(_zoom_chart_onclick, icon = 'search',req_confirm=False, layout={'width':'50px'})\n",
    "    btn_zoom_RSI_plot.figure = RSI_Line_plot\n",
    "    \n",
    "    sector_return_chart = bqv.LinePlot(df_return[['Overall Universe',selected_sector]],title='Cumulative Return - ' + selected_sector)\n",
    "    sc_y2 = bqp.LinearScale()\n",
    "    ax_y2 = bqp.Axis(scale=sc_y2, orientation='vertical',side='right',grid_lines='none')\n",
    "    sector_return_chart.figure.axes=[sector_return_chart.figure.axes[0],sector_return_chart.figure.axes[1],ax_y2]\n",
    "    btn_zoom_sector_return = apputils.ButtonConfirm(_zoom_chart_onclick,icon = 'search',req_confirm=False, layout={'width':'50px'})\n",
    "    btn_zoom_sector_return.figure = sector_return_chart\n",
    "    \n",
    "    lst_ui_sector_chart = [HBox([btn_zoom_sector_return.show(), sector_return_chart.show()]),\n",
    "                           HBox([btn_zoom_adv_dec.show(), adv_dec_plot.show()]),\n",
    "                            HBox([btn_zoom_MA_plot.show(),MA_Line_plot.show()]),\n",
    "                           HBox([btn_zoom_RSI_plot.show(),RSI_Line_plot.show()]\n",
    "                                   )]\n",
    "    label_sector_chart = Label('Select Group from the above heatmap to chart')\n",
    "        \n",
    "    ui_sector_chart = VBox([label_sector_chart] + lst_ui_sector_chart)\n",
    "    \n",
    "    \n",
    "    label_detail = HTML(apputils._HTML_TITLE.format('Selected group: ' + selected_sector))\n",
    "    btn_get_detail = apputils.ButtonConfirm(_get_sector_details, description = 'Get Details',req_confirm=False).show()\n",
    "    box_heatmap_details = VBox(layout={'min_height':'1000px','top':'20px','bottom':'20px','overflow_y':'scroll'})\n",
    "    box_details_contrils = HBox([label_detail, btn_get_detail])\n",
    "    \n",
    "    # Multi charts\n",
    "    def _on_filter_selection(selection=None):\n",
    "        rsi = df_RSI[['Cum RSI Net']]\n",
    "        rsi = rsi.reset_index()\n",
    "        rsi = rsi.pivot(index='Date',values='Cum RSI Net',columns='Sector')\n",
    "        rsi_chart_multi.push(rsi[selection])\n",
    "\n",
    "        return_chart_multi.push(df_return[selection])\n",
    "\n",
    "        adv_dec = df_adv_dec[['Cum Sum']]\n",
    "        adv_dec = adv_dec.reset_index()\n",
    "        adv_dec = adv_dec.pivot(index='Date',values='Cum Sum',columns='Sector')\n",
    "        adv_dec_chart_multi.push(adv_dec[selection])\n",
    "\n",
    "        ma_short = df_MA[['>10D Avg']]\n",
    "        ma_short = ma_short.reset_index()\n",
    "        ma_short = ma_short.pivot(index='Date',values='>10D Avg',columns='Sector')\n",
    "        ma_short_chart_multi.push(ma_short[selection])\n",
    "\n",
    "        ma_mid = df_MA[['>50D Avg']]\n",
    "        ma_mid  = ma_mid.reset_index()\n",
    "        ma_mid  = ma_mid.pivot(index='Date',values='>50D Avg',columns='Sector')\n",
    "        ma_mid_chart_multi.push(ma_mid[selection])\n",
    "\n",
    "\n",
    "        ma_long = df_MA[['>250D Avg']]\n",
    "        ma_long  = ma_long.reset_index()\n",
    "        ma_long  = ma_long.pivot(index='Date',values='>250D Avg',columns='Sector')\n",
    "        ma_long_chart_multi.push(ma_long[selection])\n",
    "    \n",
    "    rsi = df_RSI[['Cum RSI Net']]\n",
    "    rsi = rsi.reset_index()\n",
    "    rsi = rsi.pivot(index='Date',values='Cum RSI Net',columns='Sector')\n",
    "\n",
    "    rsi_chart_multi = bqv.LinePlot(title='Cumulative %RSI Overbrought/Oversold')\n",
    "    return_chart_multi = bqv.LinePlot(title='Cumulative Return')\n",
    "    adv_dec_chart_multi = bqv.LinePlot(title= 'Cumulative Advance-Decline')\n",
    "    ma_short_chart_multi = bqv.LinePlot(title ='>10days Moving Average')\n",
    "    ma_mid_chart_multi = bqv.LinePlot(title= '>50days Moving Average')\n",
    "    ma_long_chart_multi = bqv.LinePlot(title= '>250days Moving Average')\n",
    "    box_multi_charts = VBox([return_chart_multi.show(), \n",
    "                             adv_dec_chart_multi.show(),\n",
    "                             rsi_chart_multi.show(),\n",
    "                             ma_short_chart_multi.show(),\n",
    "                             ma_mid_chart_multi.show(),\n",
    "                             ma_long_chart_multi.show()])\n",
    "    filter_picker = apputils.FilterPicker(list(rsi.columns), on_change=_on_filter_selection,toggle_all=False)\n",
    "    ui_multi_charts = VBox([filter_picker.show(),box_multi_charts])\n",
    "    \n",
    "    ui_details = VBox([box_details_contrils, box_heatmap_details], layout={'overflow_y':'hidden'})\n",
    "    ui_output = Tab([ui_sector_chart,ui_multi_charts,ui_details],layout={'top':'10px'})\n",
    "    ui_output.set_title(0,'Single Group Charts')\n",
    "    ui_output.set_title(1,'Muti Group Charts')\n",
    "    ui_output.set_title(2,'Detail Table')\n",
    "    ui.children = [ui_control,ui_main,ui_output]\n",
    "    #box_status.children=[]\n",
    "    save_settings()\n",
    "def update_heatmap(grid_data):\n",
    "#     lst_heatmap = [{'data': grid_data[['#Company']],'table_mode':True}]\n",
    "#     for name in grid_data.columns if name not in ['#Company','Price']:\n",
    "        \n",
    "    \n",
    "    heatmap.generate_heatmaps([{'data': grid_data[['#Company']],'table_mode':True}]+\n",
    "                              [{'data': grid_data[[name]],'reverse_color':True if name in lower_is_better_fields else False,\n",
    "                                'upper_bound':upper_thurshold.get(name,upper_thurshold.get('default',None)),\n",
    "                                'lower_bound':lower_thurshold.get(name,lower_thurshold.get('default',None)),\n",
    "                                'tooltip': 'Highlighted {color} if {indicator} is over {value}. {low_bound_str}'.format(color='red' if name in lower_is_better_fields else 'green',\n",
    "                                                                                                        indicator = name,\n",
    "                                                                                                        value = upper_thurshold.get(name,upper_thurshold.get('default','NA')),\n",
    "                                                                                                        low_bound_str = 'Highlighted {color} if {indicator} is Below {value}'.format(\n",
    "                                                                                                        color='green' if name in lower_is_better_fields else 'red',\n",
    "                                                                                                        indicator = name,\n",
    "                                                                                                        value = lower_thurshold.get(name,lower_thurshold.get('default','NA'))\n",
    "                                                                                                        ) if lower_thurshold.get(name,lower_thurshold.get('default',None)) is not None else ''\n",
    "                                                                                                        )\n",
    "                               } for name in grid_data.columns if name not in ['#Company','Price','Mkt Cap','Return']], \n",
    "                          quick_update=True, upper_bound=upper_thurshold.get('default',None))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Market Breadth Technical Analysis\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": true,
    "editable": true,
    "input_collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c8af30141bce4051b5fe885f79f7ac72",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value='<style>.go-btn{font-family:Calibri!important;font-size:14px!important;border-radius:5px!important;…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b63e56e12f3e44e2bd2dd4e75160991f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(VBox(children=(HBox(children=(Accordion(children=(VBox(children=(HBox(children=(VBox(children=(…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "button_run = apputils.ButtonConfirm(procedure=button_run_on_click,description='Run', button_style='info',req_confirm=False).show()\n",
    "univ_accordion = Accordion(children=[universe_picker.show()], layout=Layout(width='40%'))\n",
    "univ_accordion.set_title(0, 'Universe')\n",
    "date_accordion = Accordion(children=[date_picker.show()], layout=Layout(width='40%'))\n",
    "date_accordion.set_title(0, 'Settings')\n",
    "box_status = HBox([],layout=Layout(width='650px'))\n",
    "ui_control=VBox([HBox([univ_accordion,date_accordion]),HBox([button_run,box_status])])\n",
    "ui = VBox([ui_control],layout={'overflow_y':'hidden'})\n",
    "if True:\n",
    "    button_run_on_click()\n",
    "preload_box.children=[]\n",
    "ui"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "10421d0f2ac8476cbb5957bb58c96f98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value='<style>.go-btn{font-family:Calibri!important;font-size:13px!important;border-radius:1px!important;…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ipywidgets as ipw\n",
    "from IPython.display import display\n",
    "btn_css = ('<style>'\n",
    "            '.go-btn{font-family:Calibri!important;'\n",
    "            'font-size:13px!important;'\n",
    "            'border-radius:1px!important;'\n",
    "            'font-weight: bold!important;'\n",
    "            'color:black!important;}'\n",
    "\n",
    "            '.go-btn:active{background-color:transparent!important;}'\n",
    "            '</style>'\n",
    "            )\n",
    "        \n",
    "display(ipw.HTML(btn_css))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.OutputArea.auto_scroll_threshold = 9999\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "IPython.OutputArea.auto_scroll_threshold = 9999"
   ]
  }
 ],
 "metadata": {
  "input_collapsed": false,
  "kernelspec": {
   "display_name": "Python 3 (sandboxed)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}