Interface -unWebable.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import display, clear_output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from PIL import Image\n",
    "import datetime \n",
    "import time\n",
    "from ipywidgets import Button, Layout\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import time\n",
    "from ipywidgets import Button, Layout\n",
    "import base64\n",
    "import mpld3\n",
    "from mpld3 import plugins, utils\n",
    "%matplotlib widget\n",
    "import jinja2\n",
    "import json\n",
    "import asciify\n",
    "from matplotlib import cm\n",
    "from matplotlib.colors import ListedColormap, LinearSegmentedColormap\n",
    "from mpld3 import display_d3\n",
    "from IPython.core.display import display, HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS\n",
      "SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS\n",
      "SSSSSSS%%%%%%%%%%SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS%%%%%%%%SSSSSSSSSSSSS%%%%%%%SSSSSSSSSSSS%%%%%%%SSSSSSSSS\n",
      "SSSS%;,,,........,:+?SSSSSSSS*:::%SSSSSSSSSSS%;::;SSSSSSSSSS%*;,,......,:;?SSSSSSS?+:,.....,:+%SSSSSS?+:,.....,:+%SSSSSS\n",
      "SSSS%:..:***???*+:...;%SSSSSS+..,%SSSSSSSSSSS%:..:SSSSSSSS*:...:+**??*+;,..?SSSS%;..,;**?**;:.*SSSS%;..,;**?**;:.*SSSSSS\n",
      "SSSS%:..;S#SSSSSSS*,..+SSSSSS+..,%SSSSSSSSSSS%:..:SSSSSS%;..,+%SSSSSSSSSS?;?SSSS;..,?SSSSSSSS%%SSSS;..,%SSSSSSSS%%SSSSSS\n",
      "SSSS%:..;SSSSSSSS#%,..;SSSSSS+..,%SSSSSSSSSSS%:..:SSSSS%,..:%SSSSSSSSSSSSSSSSSS%:..:%#SSSSSSSSSSSSS:..:%SSSSSSSSSSSSSSSS\n",
      "SSSS%:..;SSSSSSS%?:..:%SSSSSS+..,%SSSSSSSSSSS%:..:SSSSS;..,%SSSSSSS##########SSS*...,;*%SSSSSSSSSSS*...,;*%SSSSSSSSSSSSS\n",
      "SSSS%:..,::::::,,..,+S#SSSSSS+..,%SSSSSSSSSSS%:..:SSSS%,..;SSSSSSS*++++++++++%SSS*:,....,;*?SSSSSSSS?:,....,;*?SSSSSSSSS\n",
      "SSSS%:..,;;;;;;;:,..,:?SSSSSS+..,%SSSSSSSSSSS%:..:SSSS%,..;SSSSSSS;,,,,,,....*SSSSS%*+:,....,+%SSSSSSS%*+:,....,+%SSSSSS\n",
      "SSSS%:..;SSSSSSSSS%;...*SSSSS+..,%SSSSSSSSSSS%:..;SSSSS;..,%SSSSSSS%SSSSS+...*SSSSSSSSS%?*:...,?SSSSSSSSSS%?*:...,?SSSSS\n",
      "SSSS%:..;SSSSSSSSS#S,..:SSSSS?,..+SSSSSSSSSSS*,..*SSSSS%,..:%SSSSSSSSSSS#+...*SSSSSSSSSSSSS?,..;SSSSSSSSSSSSSS?,..;SSSSS\n",
      "SSSS%:..;S#SSSSSSS%+...*SSSSSS+...;%SSSSSSS%+,..;SSSSSSS%;..,+%SSSSSSSSSS;...*SS+*%SSSSSSSS*,..*SSS+*%SSSSSSSS?,..*SSSSS\n",
      "SSSS%:..,+*****+;:,..:*SSSSSSSS?:...,:;;;:,...:*SSSSSSSSSS*:...:+**??**;,...:?S%:..:;+***;:..,*SSSS:..:;+***;:..,*SSSSSS\n",
      "SSSSS+:::,,.,...,::+?SSSSSSSSSSSS?+;:,,,,,,:+?SSSSSSSSSSSSSS%*;,,......,:;*%SSSS%*;:,,..,,:;?SSSSSS%*+:,,..,,:;*SSSSSSSS\n",
      "SSSSSSSSSS%%%%%%SSSSSSSSSSSSSSSSSSSSSS%%%%SSSSSSSSSSSSSSSSSSSSSS%%%%%%%%SSSSSSSSSSSSS%%%%SSSSSSSSSSSSSSS%%%%SSSSSSSSSSSS\n",
      "SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS\n",
      "SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS\n"
     ]
    }
   ],
   "source": [
    "asciify.asciify('https://raw.githubusercontent.com/24-Tony/BUGSS_Interface/main/BUGSS.PNG',120)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Current-2021-07-28'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "asciify.Version()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nanColumns(dataset,columns):\n",
    "    for c in columns:\n",
    "        dataset[columns] = np.nan\n",
    "    print(type(dataset))\n",
    "    return dataset\n",
    "def fillRows(dataset,fillData,fillData2):\n",
    "    prgrs = 0\n",
    "    dataset2 = dataset\n",
    "    for index, row in fillData.iterrows():\n",
    "        prgrs +=1\n",
    "        #print(row,'--',index)\n",
    "        print(format(prgrs,'5.0f'),end='\\r')\n",
    "        #print(dataset.iloc[index])\n",
    "        dataset.iloc[index] = row\n",
    "        dataset2.iloc[index] = fillData2.iloc[index]\n",
    "    return dataset,dataset2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "clear_output()\n",
    "# load=  widgets.IntProgress(\n",
    "#     value=0,\n",
    "#     min=0,\n",
    "#     max=3,\n",
    "#     step=1,\n",
    "#     description='Loading Data:',\n",
    "#     bar_style='info', # 'success', 'info', 'warning', 'danger' or ''\n",
    "#     orientation='horizontal'\n",
    "# )\n",
    "# ldvbox  = widgets.VBox([load])\n",
    "# loading = widgets.HBox([ldvbox])\n",
    "# display(loading)\n",
    "ES_ = pd.read_pickle('ES.bugssData')\n",
    "EB_ = pd.read_pickle('EB.bugssData')\n",
    "W_ = pd.read_pickle('W.bugssData')\n",
    "IS_ = pd.read_pickle('IS.bugssData')\n",
    "IB_ = pd.read_pickle('IB.bugssData')\n",
    "\n",
    "ES_['datetime']=ES_['DateTime']\n",
    "EB_['datetime']=EB_['DateTime']\n",
    "W_['datetime']=W_['DateTime']\n",
    "IS_['datetime']=IS_['DateTime']\n",
    "IB_['datetime']=IB_['DateTime']\n",
    "\n",
    "\n",
    "\n",
    "ES=ES_.set_index('datetime')\n",
    "EB=EB_.set_index('datetime')\n",
    "W=W_.set_index('datetime')\n",
    "IS=IS_.set_index('datetime')\n",
    "IB=IB_.set_index('datetime')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# !jupyter nbextension enable --py widgetsnbextension --sys-prefix\n",
    "# !jupyter serverextension enable voila --sys-prefix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HighlightLines(plugins.PluginBase):\n",
    "    \"\"\"A plugin to highlight lines on hover\"\"\"\n",
    "\n",
    "    JAVASCRIPT = \"\"\"\n",
    "    mpld3.register_plugin(\"linehighlight\", LineHighlightPlugin);\n",
    "    LineHighlightPlugin.prototype = Object.create(mpld3.Plugin.prototype);\n",
    "    LineHighlightPlugin.prototype.constructor = LineHighlightPlugin;\n",
    "    LineHighlightPlugin.prototype.requiredProps = [\"line_ids\"];\n",
    "    LineHighlightPlugin.prototype.defaultProps = {alpha_bg:0.3, alpha_fg:2}\n",
    "    function LineHighlightPlugin(fig, props){\n",
    "        mpld3.Plugin.call(this, fig, props);\n",
    "    };\n",
    "\n",
    "    LineHighlightPlugin.prototype.draw = function(){\n",
    "      for(var i=0; i<this.props.line_ids.length; i++){\n",
    "         var obj = mpld3.get_element(this.props.line_ids[i], this.fig),\n",
    "             alpha_fg = this.props.alpha_fg;\n",
    "             alpha_bg = this.props.alpha_bg;\n",
    "         obj.elements()\n",
    "             .on(\"mouseover\", function(d, i){\n",
    "                            d3.select(this).transition().duration(50)\n",
    "                              .style(\"stroke-opacity\", alpha_fg); })\n",
    "             .on(\"mouseout\", function(d, i){\n",
    "                            d3.select(this).transition().duration(200)\n",
    "                              .style(\"stroke-opacity\", alpha_bg); });\n",
    "      }\n",
    "    };\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, lines):\n",
    "        self.lines = lines\n",
    "        self.dict_ = {\"type\": \"linehighlight\",\n",
    "                      \"line_ids\": [utils.get_id(line) for line in lines],\n",
    "                      \"alpha_bg\": lines[0].get_alpha(),\n",
    "                      \"alpha_fg\": 1.0}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CleanList(LST,removeCommas,removeMore):\n",
    "    listStr = str(LST)\n",
    "    listStr = listStr.replace(\"'\",'')\n",
    "    if removeCommas==True:\n",
    "        #listStr = listStr.replace(\",,\",',')\n",
    "        listStr = listStr.replace(\",, \",', ')\n",
    "    listStr = listStr.replace('\\\\','')\n",
    "    listStr = listStr.replace('/','')\n",
    "    \n",
    "    String = listStr[1:(len(listStr)-(1+removeMore))]\n",
    "    #print(String)\n",
    "    return(String)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def TrimYR(dataset,year,months,DateColumn,Name):\n",
    "#     m1 = months[0].month\n",
    "#     m2 = months[1].month\n",
    "#     From = str(year)+'-'+str(m1)\n",
    "#     To = str(year)+'-'+str(m2)\n",
    "#     DStrim = dataset.loc[From:To]\n",
    "#     DStrim['Name'] = Name\n",
    "#     return DStrim\n",
    "\n",
    "# def YPlot(datasets,DataPoints,Scale,Years,Months,figx,figy,Style):\n",
    "#     mpld3.enable_notebook()\n",
    "#     Dsets = []\n",
    "#     prg1 = len(datasets)*len(Years)\n",
    "#     prg2 = len(DataPoints)\n",
    "#     prg3 = prg1*prg2+prg1\n",
    "#     prg = 0\n",
    "#     progress.max = prg3+1\n",
    "#     figsize(figx,figy)\n",
    "#     ax = plt.gca()\n",
    "#     plt.style.use(Style)\n",
    "#     if Scale == 2:\n",
    "#         plt.yscale('log')\n",
    "#     for ds in datasets:\n",
    "#         if ds == 'East Surface':\n",
    "#             df=ES\n",
    "#         elif ds == 'East Bottom':\n",
    "#             df=EB\n",
    "#         else:\n",
    "#             df=W\n",
    "#         for yr in Years:\n",
    "#             Dsets.append(TrimYR(df,yr,Months,'DateTime',ds+'-'+yr))\n",
    "#             prg+=1\n",
    "#             progress.value = prg\n",
    "#     for ds in Dsets:\n",
    "#         DF = pd.DataFrame(ds)\n",
    "#         DF['DTime']=DF['DateTime'].dt.strftime('%m-%d %X')\n",
    "#         for dp in DataPoints:\n",
    "#             DF.plot('DTime',dp,ax=ax, label = (DF['Name'][0]+'-'+dp))\n",
    "#             prg+=1\n",
    "#             progress.value = prg\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def TrimYR(dataset,year,months,DateColumn,Name):\n",
    "    m1 = months[0].month\n",
    "    m2 = months[1].month\n",
    "    From = str(year)+'-'+str(m1)\n",
    "    To = str(year)+'-'+str(m2)\n",
    "    DStrim = dataset.loc[From:To]\n",
    "    DStrim['Name'] = Name\n",
    "    return DStrim\n",
    "def prepDatasets(datasets,Years,Months):\n",
    "    Dsets = []\n",
    "    for ds in datasets:\n",
    "        if ds == 'East Surface':\n",
    "            df=ES\n",
    "        elif ds == 'East Bottom':\n",
    "            df=EB\n",
    "        elif ds == 'West':\n",
    "            df=W\n",
    "        elif ds == 'Inversion Surface':\n",
    "            df=IS\n",
    "        elif ds == 'Inversion Bottom':\n",
    "            df=IB\n",
    "        for yr in Years:\n",
    "            Dsets.append(TrimYR(df,yr,Months,'DateTime',ds+'-'+yr))\n",
    "    return(Dsets)\n",
    "\n",
    "def YPlot(datasets,DataPoints,Scale,Years,Months,figx,figy,Style,Transparency,fillb):\n",
    "    margin = .1\n",
    "    mpld3.enable_notebook()\n",
    "    RandYr='2020'#LEAP YEAR TO AVOID DATETIME ERRORS\n",
    "    MaxOpac = .9\n",
    "    prg1 = len(datasets)*len(Years)\n",
    "    prg2 = len(DataPoints)\n",
    "    prg3 = prg1*prg2+prg1\n",
    "    prg4= prg1*(prg2+prg1)+prg1\n",
    "    prg_part = 0\n",
    "    prg = 0\n",
    "    progress.max = prg3+1\n",
    "    plt.style.use(Style)\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.grid(True, alpha=0.3)\n",
    "    #fig.style.use(Style)\n",
    "    fig.set_figwidth(figx)\n",
    "    fig.set_figheight(figy)\n",
    "    \n",
    "    if Scale == 2:\n",
    "        plt.yscale('log')\n",
    "        \n",
    "    Dsets=prepDatasets(datasets,Years,Months)\n",
    "    Lines = []\n",
    "    desc = ''\n",
    "    for ds in Dsets:\n",
    "        DF_ref = pd.DataFrame(ds)\n",
    "        name = DF_ref['Name']\n",
    "        DF=pd.DataFrame({'DateTime':DF_ref.index})\n",
    "        DF_ref['DTime']=DF_ref['DateTime'].dt.strftime('-%m-%d %X')\n",
    "        DF_ref['DTime'] = RandYr+DF_ref['DTime']\n",
    "        DF_ref['DTime'] = pd.to_datetime(DF_ref['DTime'],format='%Y-%m-%d %X')\n",
    "#         DF_ref['DTime']=DF_ref['DateTime'].dt.strftime('%m-%d %X')\n",
    "#         DF_ref['DTime'] = pd.to_datetime(DF_ref['DTime'],format='%m-%d %X')        \n",
    "        DF_ref=DF_ref.set_index('DTime')\n",
    "\n",
    "        DF['DTime']=DF['DateTime']\n",
    "        DF['DTime']=DF['DateTime'].dt.strftime('-%m-%d %X')\n",
    "        DF['DTime'] = RandYr+DF['DTime']\n",
    "        DF['DTime'] = pd.to_datetime(DF['DTime'],format='%Y-%m-%d %X')\n",
    "#         DF['DTime']=DF['DateTime'].dt.strftime('%m-%d %X')\n",
    "#         DF['DTime'] = pd.to_datetime(DF['DTime'],format='%m-%d %X')\n",
    "        DF=DF.set_index('DTime')\n",
    "        df=DF.drop(columns = ['DateTime'])\n",
    "        DF_ref=DF_ref.drop(columns = ['DateTime'])\n",
    "        #print(DF_ref)\n",
    "        for dp in DataPoints:\n",
    "            \n",
    "            #print('\\n\\n',dp,'\\n\\n')\n",
    "            df[dp]=DF_ref[dp]\n",
    "            #print(DF_ref)\n",
    "            prg+=1\n",
    "            progress.value = prg\n",
    "        #    df.plot('DTime',dp)#,ax=ax, label = (DF['Name'][0]+'-'+dp))\n",
    "        Desc = str(name[1])+'\\n'+str(df.describe())+'\\n\\n'\n",
    "        desc= desc + str(Desc)\n",
    "        for key, val in df.iteritems():\n",
    "            prg_part+=1\n",
    "            prg+=1\n",
    "            alp = MaxOpac-(Transparency*(prg_part-1))/prg3\n",
    "            progress.value = prg\n",
    "            l, = ax.plot(val.index, val.values,LineWidth = 1, label=(str(name[0])+' - '+str(key)),alpha=(alp))\n",
    "            Lines.append(l)\n",
    "            ax.fill_between(val.index,\n",
    "                             val.values * 1-margin, val.values * 1+margin, \n",
    "                             color=l.get_color(), alpha=.4*alp*fillb)\n",
    "            #mpld3.show()\n",
    "    ax.legend()\n",
    "    \n",
    "    htmlplot = mpld3.fig_to_html(fig)\n",
    "    return fig, ax, Lines,desc,htmlplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def DPlot(Datasets,DataPoints,Scale,StartDate,EndDate,figx,figy,Style,Transparency,fillb):\n",
    "    margin = .1\n",
    "    mpld3.enable_notebook()\n",
    "    prg1 = len(Datasets)\n",
    "    prg2 = len(DataPoints)\n",
    "    prg3 = prg1*prg2\n",
    "    prg4= prg3*2\n",
    "    prg_part = 0\n",
    "    prg = 0\n",
    "    MaxOpac = .9\n",
    "    progress.max = prg3+1\n",
    "    plt.style.use(Style)\n",
    "    try:\n",
    "        fig.clear\n",
    "    except:\n",
    "        fig, ax = plt.subplots()\n",
    "    ax.grid(True, alpha=0.3)\n",
    "    #fig.style.use(Style)\n",
    "    fig.set_figwidth(figx)\n",
    "    fig.set_figheight(figy)\n",
    "    #fig.figure(figsize= (figx,figy))\n",
    "    #figsize= (figx,figy)\n",
    "    #ure(figsize=(figx,figy))\n",
    "    Lines = []\n",
    "    desc = ''\n",
    "    if Scale == 2:\n",
    "        plt.yscale('log')\n",
    "    for ds in Datasets:\n",
    "        if ds == 'East Surface':\n",
    "            dfref=ES.loc[StartDate:EndDate]\n",
    "        elif ds == 'East Bottom':\n",
    "            dfref=EB.loc[StartDate:EndDate]\n",
    "        elif ds == 'West':\n",
    "            dfref=W.loc[StartDate:EndDate]\n",
    "        elif ds == 'Inversion Surface':\n",
    "            dfref=IS.loc[StartDate:EndDate]\n",
    "        elif ds == 'Inversion Bottom':\n",
    "            dfref=IB.loc[StartDate:EndDate]\n",
    "        df=pd.DataFrame({'DateTime':dfref.index}).set_index('DateTime')\n",
    "        for dp in DataPoints:\n",
    "            df[dp]=dfref[dp]\n",
    "            #df.plot('DateTime',dp,ax=ax, label = (ds, dp))#,alpha=(prg3-prg)/prg3)\n",
    "            prg+=1\n",
    "            progress.value = prg\n",
    "        #print(df)\n",
    "        Desc = str(ds)+'\\n'+str(df.describe())+'\\n\\n'\n",
    "        desc= desc + str(Desc)\n",
    "        for key, val in df.iteritems():\n",
    "            prg_part+=1\n",
    "            prg+=1\n",
    "            alp = MaxOpac-(Transparency*(prg_part-1))/prg3\n",
    "            progress.value = prg\n",
    "            l, = ax.plot(val.index, val.values,LineWidth = 1, label=(str(ds)+' - '+str(key)),alpha=(alp))\n",
    "            Lines.append(l)\n",
    "            ax.fill_between(val.index,\n",
    "                             val.values * 1-margin, val.values * 1+margin, \n",
    "                             color=l.get_color(), alpha=.4*alp*fillb)\n",
    "\n",
    "#     #print(interactive_legend)\n",
    "#     print(ax.get_label())\n",
    "#     fig.legend(ax.get_label)\n",
    "#     mpld3.display()\n",
    "#     print(out)\n",
    "#     plt.savefig(extension)\n",
    "#     img = Image.open(extension)\n",
    "#     #img.show()\n",
    "    #mpld3.show()\n",
    "    ax.legend()\n",
    "    htmlplot = mpld3.fig_to_html(fig)\n",
    "    return fig, ax, Lines, desc, htmlplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepCompare(Dataset,datapoint):\n",
    "    if Dataset == 'East Surface':\n",
    "        Ds=ES[datapoint]\n",
    "    elif Dataset == 'East Bottom':\n",
    "        Ds=EB[datapoint]\n",
    "    elif Dataset == 'West':\n",
    "        Ds=W[datapoint]\n",
    "    elif Dataset == 'Inversion Surface':\n",
    "        Ds=IS[datapoint]\n",
    "    elif Dataset == 'Inversion Bottom':\n",
    "        Ds=IB[datapoint]\n",
    "    NewCol = (str(datapoint)+' - '+str(Dataset))\n",
    "    Ds = Ds.reset_index()\n",
    "    Ds[NewCol]=Ds[datapoint]\n",
    "    Ds=Ds.drop(columns=datapoint)\n",
    "    return(Ds,NewCol)\n",
    "def Compare(Dataset1,Dataset2,DataPoint1,DataPoint2,Colors,Scale,figx,figy,Style,ColorFormat):\n",
    "    #define palette \n",
    "    prg1 = 5\n",
    "    sns.set_palette(sns.color_palette(Colors))\n",
    "    my_pal = sns.color_palette(Colors)\n",
    "    cmap = ListedColormap(Colors)\n",
    "    Ds1, Col1 = prepCompare(Dataset1,DataPoint1)\n",
    "    Ds2, Col2 = prepCompare(Dataset2,DataPoint2)\n",
    "    Ds1 = Ds1[Ds1['datetime'].isin(Ds2['datetime'])]\n",
    "    Ds2 = Ds2[Ds2['datetime'].isin(Ds1['datetime'])]\n",
    "    Data = pd.merge(Ds1, Ds2, on='datetime', how='outer')\n",
    "    plt.style.use(Style)\n",
    "    try:\n",
    "        fig.clear\n",
    "    except:\n",
    "        fig, ax = plt.subplots()\n",
    "    ax.grid(True, alpha=0.3)\n",
    "    #fig.style.use(Style)\n",
    "    isYear=ColorFormat=='Year'\n",
    "    isMonth=ColorFormat=='Month'\n",
    "    fig.set_figwidth(figx)\n",
    "    fig.set_figheight(figy)\n",
    "    margin = .1\n",
    "    mpld3.enable_notebook()\n",
    "    MaxOpac = .9\n",
    "    desc = ''\n",
    "    Lines = []\n",
    "    if Scale == 2:\n",
    "        plt.yscale('log')\n",
    "    Data['Color'] = ((Data['datetime'].dt.year-2015)*isYear)+(Data['datetime'].dt.month*isMonth)\n",
    "    Data['Size'] = ((Data['datetime'].dt.month)*isYear)+((Data['datetime'].dt.year-2015)*3*isMonth)\n",
    "    #Data['Color'] = Colors[Data['Color']]\n",
    "    #print(Data.head())\n",
    "    Desc = str(Data.describe())\n",
    "    desc= desc + str(Desc)\n",
    "    try:\n",
    "        ax.scatter(Data[Col1],Data[Col2],s = Data['Size'],\n",
    "                   c=Data['Color'],cmap = cmap),#alpha=1.0-((Transparency*Data['Color'])/5))\n",
    "    except:\n",
    "        ax.scatter(Data[Col1+'_x'],Data[Col2+'_y'],s = Data['Size'],\n",
    "                   c=Data['Color'],cmap = cmap)#,alpha=1.0-((Transparency*Data['Color'])/5))\n",
    "#     for key, val in Data.iteritems():\n",
    "#             alp = 1\n",
    "#             progress.value = prg\n",
    "#             l, = ax.plot(val.index, val.values,LineWidth = 1, label=key,alpha=(alp))\n",
    "#             Lines.append(l)\n",
    "#             ax.fill_between(val.index,\n",
    "#                              val.values * 1-margin, val.values * 1+margin, \n",
    "#                              color=l.get_color(), alpha=.4*alp*fillb)\n",
    "    xL = Col1\n",
    "    yL = Col2\n",
    "    htmlplot = mpld3.fig_to_html(fig)\n",
    "    return fig, ax,desc,htmlplot,xL,yL\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "envDatapoints = [('Salinity_ppt','Salinity_ppt'),('pH','pH'),\n",
    "              ('DO_mg/L','DO_mg/L'),('Turb_NTU','Turb_NTU'),\n",
    "              ('Chl_ug/L','Chl_ug/L'),('Temp_C','Temp_C')]\n",
    "\n",
    "mpld3.enable_notebook(False)\n",
    "############# GENERAL #####################################################\n",
    "Header = widgets.HTML(value='''<h1>&Dscr;&ascr;&tscr;&ascr;\n",
    "                    &Pscr;&lscr;&oscr;&tscr;&tscr;&iscr;&nscr;&gscr;<h1>''',\n",
    "                      color='lime',font_size=75)\n",
    "figx=widgets.IntSlider(\n",
    "    value=8,\n",
    "    min=2,\n",
    "    max=11,\n",
    "    step=1,\n",
    "    description='X axis size:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='d'\n",
    ")\n",
    "figx.style.handle_color=\"lawngreen\"\n",
    "\n",
    "figy=widgets.IntSlider(\n",
    "    value=5,\n",
    "    min=1,\n",
    "    max=9,\n",
    "    step=-1,\n",
    "    description='Y axis Size:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='Vertical',\n",
    "    readout=True,\n",
    "    readout_format='d'\n",
    ")\n",
    "figy.style.handle_color=\"lawngreen\"\n",
    "\n",
    "Scale = widgets.Dropdown(\n",
    "    options=[('linear', 1), ('logarithmic', 2)],\n",
    "    value=1,\n",
    "    description='Scale',\n",
    ")\n",
    "\n",
    "Style = widgets.Dropdown(\n",
    "    options=[('default', 'default'), ('classic', 'classic'),\n",
    "             ('Solarize_Light2', 'Solarize_Light2'),('_classic_test_patch','_classic_test_patch'),\n",
    "             ('bmh', 'bmh'),('dark_background', 'dark_background'),\n",
    "             ('fast', 'fast'),('fivethirtyeight', 'fivethirtyeight'),\n",
    "             ('ggplot', 'ggplot'),('grayscale', 'grayscale'),\n",
    "             ('seaborn-colorblind', 'seaborn-colorblind'),('seaborn-dark', 'seaborn-dark'),\n",
    "             ('seaborn-dark-palette', 'seaborn-dark-palette'),('seaborn-darkgrid', 'seaborn-darkgrid'),\n",
    "             ('seaborn-deep', 'seaborn-deep'),('seaborn-muted', 'seaborn-muted'),\n",
    "             ('seaborn-notebook', 'seaborn-notebook'),('seaborn-paper', 'seaborn-paper'),\n",
    "             ('seaborn-pastel', 'seaborn-pastel'),('seaborn-poster', 'seaborn-poster'),\n",
    "             ('seaborn-talk', 'seaborn-talk'),('seaborn-white', 'seaborn-white'),\n",
    "             ('seaborn-whitegrid', 'seaborn-whitegrid'),('seaborn-colorblind10', 'seaborn-colorblind10')],\n",
    "    value='default',\n",
    "    description='Style',\n",
    ")\n",
    "\n",
    "DataToInclude = widgets.SelectMultiple(\n",
    "    options=['East Surface', 'East Bottom', 'West','Inversion Surface','Inversion Bottom'],\n",
    "    value=['East Surface'],\n",
    "    description='Datasets',\n",
    "    rows = 3,\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "\n",
    "Transparency = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Gradual Transparency',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "fillb = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Fill Between',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "viewer = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Viewer',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "useSpecial = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Use Special:',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "Special = widgets.ToggleButtons(\n",
    "    options=['Legend', 'Highlight'],\n",
    "    description='Special:',\n",
    "    disabled=True,\n",
    "    button_style = 'success',\n",
    "    tooltips=['Interactive Legend','Highlight'],\n",
    ")\n",
    "\n",
    "Special.style.button_color = 'lawngreen'\n",
    "\n",
    "def specialUpdate(change):\n",
    "    if useSpecial.value == True:\n",
    "        viewer.value = True\n",
    "        Special.disabled = False\n",
    "    else:\n",
    "        Special.disabled = True       \n",
    "def viewerUpdate(change):\n",
    "    if viewer.value == False:\n",
    "        useSpecial.value = False\n",
    "        Special.disabled = True       \n",
    "useSpecial.observe(specialUpdate, names='value')\n",
    "viewer.observe(viewerUpdate, names='value')\n",
    "\n",
    "vbox_General = widgets.VBox([viewer,Transparency,fillb])\n",
    "vbox_Special = widgets.VBox([useSpecial,Special])\n",
    "\n",
    "Fmt = widgets.Tab()\n",
    "Fmt.children = [vbox_General,vbox_Special]\n",
    "Fmt.set_title(0,'General')\n",
    "Fmt.set_title(1,'Special')\n",
    "\n",
    "vbox_g = widgets.VBox([Style,Scale,DataToInclude,Fmt,figx])\n",
    "hbox_g = widgets.HBox([figy,vbox_g])\n",
    "vbox_general = widgets.VBox([Header,hbox_g])\n",
    "############################################################################\n",
    "\n",
    "\n",
    "#################### ENVIRONMENT ###########################################\n",
    "EnvDataPoints = widgets.SelectMultiple(\n",
    "    options=['Salinity_ppt', 'pH', 'DO_mg/L','Turb_NTU','Chl_ug/L','Temp_C'],\n",
    "    value=['pH'],\n",
    "    rows=6,\n",
    "    description='Data',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "StartDate = widgets.DatePicker(description='Start Date')\n",
    "\n",
    "EndDate = widgets.DatePicker(description='End Date')\n",
    "\n",
    "dates = [datetime.date(2018,i,1) for i in range(1,13)]\n",
    "options = [(i.strftime('%b'), i) for i in dates]\n",
    "Months = widgets.SelectionRangeSlider(\n",
    "    options=options,\n",
    "    index=(0,11),\n",
    "    description='Months',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "\n",
    "Years=widgets.SelectMultiple(\n",
    "    options=['2016','2017','2018', '2019', '2020'],\n",
    "    value=['2016','2017','2018', '2019', '2020'],\n",
    "    description='Years',\n",
    "    rows = 5,\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "vbox_dateselecter =  widgets.VBox([StartDate,EndDate])\n",
    "\n",
    "vbox_yearlimiter =  widgets.VBox([Months,Years])\n",
    "\n",
    "DRtab = widgets.Tab()\n",
    "DRtab.children = [vbox_dateselecter,vbox_yearlimiter]\n",
    "DRtab.set_title(0,'Date Range')\n",
    "DRtab.set_title(1,'Years Overlayed')\n",
    "\n",
    "vbox_EnvData = widgets.VBox([EnvDataPoints,DRtab])\n",
    "############################################################################\n",
    "\n",
    "\n",
    "############## SPECIES #####################################################\n",
    "species = ['Amphipod','Barnacle','Clam Worm','Colonial Ciliates','Copepod',\n",
    "             'Dark False Mussel','Dusky Sea Slug','Hydra','Magnification',\n",
    "             'Mud Crab','Oyster Flatworm','Stentor','Tube Bryzoan','Whip Mudworm']\n",
    "SpecDataPoints = widgets.SelectMultiple(\n",
    "    options=species,\n",
    "    value=['Hydra'],\n",
    "    rows=14,\n",
    "    description='Data',\n",
    "    disabled=True\n",
    ")\n",
    "\n",
    "specStartDate = widgets.DatePicker(description='Start Date',disabled = True)\n",
    "\n",
    "specEndDate = widgets.DatePicker(description='End Date',disabled = True)\n",
    "\n",
    "\n",
    "specMonths = widgets.SelectionRangeSlider(\n",
    "    options=options,\n",
    "    index=(0,11),\n",
    "    description='Months',\n",
    "    disabled=True\n",
    ")\n",
    "\n",
    "\n",
    "specYears=widgets.SelectMultiple(\n",
    "    options=['2016','2017','2018', '2019', '2020'],\n",
    "    value=['2016','2017','2018', '2019', '2020'],\n",
    "    description='Years',\n",
    "    rows = 5,\n",
    "    disabled=True\n",
    ")\n",
    "\n",
    "vbox_specdateselecter =  widgets.VBox([specStartDate,specEndDate])\n",
    "\n",
    "vbox_specyearlimiter =  widgets.VBox([specMonths,specYears])\n",
    "\n",
    "specDRtab = widgets.Tab()\n",
    "specDRtab.children = [vbox_specdateselecter,vbox_specyearlimiter]\n",
    "specDRtab.set_title(0,'Date Range')\n",
    "specDRtab.set_title(1,'Years Overlayed')\n",
    "\n",
    "\n",
    "vbox_SpecData =  widgets.VBox([SpecDataPoints,specDRtab])\n",
    "############################################################################\n",
    "\n",
    "\n",
    "############## CORRELATION #################################################\n",
    "cd2Iopt = {'East Surface','East Bottom','West','Inversion Surface','Inversion Bottom'}\n",
    "\n",
    "corrDataToInclude1 = widgets.Dropdown(\n",
    "    options=cd2Iopt,\n",
    "    description='Dataset',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "corrDataToInclude2 = widgets.Dropdown(\n",
    "    options=cd2Iopt,\n",
    "    description='Dataset'\n",
    ")\n",
    "EnvC1DataPoints = widgets.Dropdown(\n",
    "    options=envDatapoints,\n",
    "    value='pH',\n",
    "    description='Data'\n",
    ")\n",
    "\n",
    "EnvC2DataPoints = widgets.Dropdown(\n",
    "    options=envDatapoints,\n",
    "    value='pH',\n",
    "    description='Data'\n",
    ")\n",
    "vbox_corr1 = widgets.VBox([EnvC1DataPoints,corrDataToInclude1])\n",
    "vbox_corr2 = widgets.VBox([EnvC2DataPoints,corrDataToInclude2])\n",
    "accordion = widgets.Accordion(children=[vbox_corr1,vbox_corr2])\n",
    "accordion.set_title(0, 'First Condition')\n",
    "accordion.set_title(1, 'Second Condition')\n",
    "\n",
    "SpecCDataPoints = widgets.Select(\n",
    "    options=species,\n",
    "    description='Data',\n",
    "    orientation='Vertical',\n",
    "    disabled = True\n",
    ")\n",
    "\n",
    "EnvCDataPoints = widgets.SelectMultiple(\n",
    "    options=['Salinity_ppt', 'pH', 'DO_mg/L','Turb_NTU','Chl_ug/L','Temp_C'],\n",
    "    value=['pH'],\n",
    "    rows=6,\n",
    "    description='Correlate to:',\n",
    "    disabled=True,\n",
    "    max = 3\n",
    ")\n",
    "method = widgets.Dropdown(\n",
    "    options={'Top': 0, 'Bottom': 1},\n",
    "    value=0,\n",
    "    description='',\n",
    "    disabled = True,\n",
    "    layout = Layout (width = '25%', height = '100%')\n",
    ")\n",
    "ResultNum=widgets.IntSlider(\n",
    "    value=3,\n",
    "    min=1,\n",
    "    max=len(EnvCDataPoints.value),\n",
    "    step=1,\n",
    "    description='',\n",
    "    disabled=True,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='d'\n",
    ")\n",
    "ResultNum.style.handle_color=\"lawngreen\"\n",
    "\n",
    "Colorform = widgets.Dropdown(\n",
    "    options=['Year','Month','None'],\n",
    "    description='Colorcode by',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "colorconcise = False\n",
    "\n",
    "Color16 = widgets.ColorPicker(\n",
    "    concise=colorconcise,\n",
    "    description='2016 color',\n",
    "    value='#00ffff',\n",
    "    disabled=False\n",
    "    \n",
    ")\n",
    "Color17 = widgets.ColorPicker(\n",
    "    concise=colorconcise,\n",
    "    description='2017 color',\n",
    "    value='#0000ff',\n",
    "    disabled=False\n",
    "    \n",
    ")\n",
    "Color18 = widgets.ColorPicker(\n",
    "    concise=colorconcise,\n",
    "    description='2018 color',\n",
    "    value='#00ff00',\n",
    "    disabled=False\n",
    "    \n",
    ")\n",
    "Color19 = widgets.ColorPicker(\n",
    "    concise=colorconcise,\n",
    "    description='2019 color',\n",
    "    value='#00aa00',\n",
    "    disabled=False\n",
    "    \n",
    ")\n",
    "Color20 = widgets.ColorPicker(\n",
    "    concise=colorconcise,\n",
    "    description='2020 color',\n",
    "    value='#ffff00',\n",
    "    disabled=False\n",
    "    \n",
    ")\n",
    "\n",
    "ColorJun = widgets.ColorPicker(concise=colorconcise, description='June color',\n",
    "                               value='#c8c800', disabled=True)\n",
    "\n",
    "ColorJul = widgets.ColorPicker(concise=colorconcise, description='July color',\n",
    "                               value='#ff9600', disabled=True)\n",
    "\n",
    "ColorAug = widgets.ColorPicker(concise=colorconcise, description='August color',\n",
    "                               value='#966400', disabled=True)\n",
    "\n",
    "ColorSept = widgets.ColorPicker(concise=colorconcise, description='September color',\n",
    "                               value='#ff0000', disabled=True)\n",
    "\n",
    "ColorOct = widgets.ColorPicker(concise=colorconcise, description='October color',\n",
    "                               value='#960000', disabled=True)\n",
    "\n",
    "ColorNov = widgets.ColorPicker(concise=colorconcise, description='November color',\n",
    "                               value='#ff00ff', disabled=True)\n",
    "\n",
    "ColorDec = widgets.ColorPicker(concise=colorconcise, description='December color',\n",
    "                               value='#960096', disabled=True)\n",
    "mColors = [ColorJun,ColorJul,ColorAug,ColorSept,ColorOct,ColorNov,ColorDec]\n",
    "\n",
    "def clrUpdate(event):\n",
    "    if Colorform.value=='Month':\n",
    "        for o in mColors:\n",
    "            o.disabled = False\n",
    "        Color17.disabled = False\n",
    "        Color18.disabled = False\n",
    "        Color19.disabled = False\n",
    "        Color20.disabled = False\n",
    "        Color16.description = 'January color'\n",
    "        Color17.description = 'February color'\n",
    "        Color18.description = 'March color'\n",
    "        Color19.description = 'April color'\n",
    "        Color20.description = 'May color'\n",
    "    elif Colorform.value=='Year':\n",
    "        for o in mColors:\n",
    "            o.disabled = True\n",
    "        Color17.disabled = False\n",
    "        Color18.disabled = False\n",
    "        Color19.disabled = False\n",
    "        Color20.disabled = False\n",
    "        Color16.description = '2016 color'\n",
    "        Color17.description = '2017 color'\n",
    "        Color18.description = '2018 color'\n",
    "        Color19.description = '2019 color'\n",
    "        Color20.description = '2020 color'\n",
    "    else:\n",
    "        for o in mColors:\n",
    "            o.disabled = True\n",
    "        Color16.description = 'Solid color'\n",
    "        Color17.disabled = True\n",
    "        Color18.disabled = True\n",
    "        Color19.disabled = True\n",
    "        Color20.disabled = True\n",
    "Colorform.observe(clrUpdate, names='value')\n",
    "\n",
    "Palette_V=widgets.VBox([Color16,Color17,Color18,Color19,Color20,ColorJun])\n",
    "Palette_V2=widgets.VBox([ColorJul,ColorAug,ColorSept,ColorOct,ColorNov,ColorDec])\n",
    "Palette=widgets.VBox([Palette_V,Palette_V2])\n",
    "\n",
    "def AdjMax(change):\n",
    "    ResultNum.max=len(EnvCDataPoints.value)\n",
    "\n",
    "EnvCDataPoints.observe(AdjMax, names='value')\n",
    "\n",
    "vbox_env_env =  widgets.VBox([accordion,Colorform,Palette])\n",
    "hbox_env_spec_sub = widgets.HBox([method,ResultNum])\n",
    "vbox_env_spec =  widgets.VBox([SpecCDataPoints,EnvCDataPoints,hbox_env_spec_sub])\n",
    "\n",
    "CorrTab = widgets.Tab()\n",
    "\n",
    "CorrTab.children = [vbox_env_env,vbox_env_spec]\n",
    "#CorrTab.disabled = [False,True]\n",
    "CorrTab.set_title(0,'Environmental Correlation')\n",
    "CorrTab.set_title(1,'Species Correlation')\n",
    "\n",
    "vbox_Corr =  widgets.VBox([CorrTab])\n",
    "\n",
    "def updateCorr(event):\n",
    "    if MainTab.selected_index == 2:\n",
    "        DataToInclude.disabled = True\n",
    "    else:\n",
    "        DataToInclude.disabled = False\n",
    "\n",
    "        \n",
    "############################################################################\n",
    "\n",
    "\n",
    "############## MAIN ########################################################\n",
    "\n",
    "MainTab = widgets.Tab()\n",
    "\n",
    "MainTab.children = [vbox_EnvData,vbox_SpecData,vbox_Corr]\n",
    "\n",
    "MainTab.set_title(0,'Environmental')\n",
    "MainTab.set_title(1,'Species')\n",
    "MainTab.set_title(2,'Correlation')\n",
    "MainTab.layout = Layout (width = '400px', height = '100%')\n",
    "vbox_main = widgets.VBox([MainTab])\n",
    "\n",
    "MainTab.observe(updateCorr, names='selected_index')\n",
    "\n",
    "\n",
    "###########################################################################\n",
    "\n",
    "\n",
    "############ DISPLAY ######################################################\n",
    "clear_output()\n",
    "   \n",
    "progress =  widgets.IntProgress(\n",
    "    value=0,\n",
    "    min=0,\n",
    "    max=2,\n",
    "    step=1,\n",
    "    description='plotting:',\n",
    "    style = {'bar_color':'lawngreen'},\n",
    "    orientation='horizontal'\n",
    "    )\n",
    "\n",
    "btn_plt = widgets.Button(\n",
    "    description='''Plot 📈''',\n",
    "    tooltip='Plot',\n",
    "    style={'button_color': 'lawngreen'},\n",
    "    layout = Layout (width = '360px', height = '100%'),\n",
    "    font_size=75\n",
    "    #layout = Layout(width='98%', height='100%')\n",
    ")\n",
    "\n",
    "#Output = widgets.Output()\n",
    "Output = widgets.HTML()\n",
    "\n",
    "def on_button_clicked(event):\n",
    "    mpld3.enable_notebook()\n",
    "    if MainTab.selected_index==0:\n",
    "        if DRtab.selected_index == 0:\n",
    "            fig, ax, l, desc, htmlplot = DPlot(DataToInclude.value,EnvDataPoints.value,\n",
    "                  Scale.value,StartDate.value,EndDate.value,\n",
    "                  figx.value,figy.value,Style.value,Transparency.value,fillb.value)\n",
    "            #myplot=widgets.HTML(value=plot)\n",
    "            #mpld3.display()\n",
    "        else:\n",
    "            fig, ax, l, desc, htmlplot = YPlot(DataToInclude.value,EnvDataPoints.value,\n",
    "                  Scale.value,Years.value,Months.value,\n",
    "                  figx.value,figy.value,Style.value,Transparency.value,fillb.value)\n",
    "    #         YPlot(DataToInclude.value,EnvDataPoints.value,\n",
    "    #               Scale.value,Years.value,Months.value,\n",
    "    #               figx.value,figy.value,Style.value)\n",
    "        ax.set_xlabel('Time')\n",
    "        ax.set_ylabel('Level')\n",
    "\n",
    "    elif MainTab.selected_index==2:\n",
    "        Colors = [Color16.value]\n",
    "        if Colorform.value=='Year':\n",
    "            Colors = [Color16.value,Color17.value,Color18.value,Color19.value,Color20.value]\n",
    "        elif Colorform.value=='Month':\n",
    "            Colors = [Color16.value,Color17.value,Color18.value,Color19.value,Color20.value,ColorJun.value,\n",
    "                  ColorJul.value,ColorAug.value,ColorSept.value,ColorOct.value,ColorNov.value,ColorDec.value]\n",
    "        fig, ax, desc, htmlplot,xL,yL = Compare(corrDataToInclude1.value,corrDataToInclude2.value,EnvC1DataPoints.value,\n",
    "                EnvC2DataPoints.value,Colors,Scale.value,figx.value,figy.value,Style.value,Colorform.value)\n",
    "        ax.set_xlabel(xL)\n",
    "        ax.set_ylabel(yL)\n",
    "        \n",
    "        \n",
    "    \n",
    "    if useSpecial.value == True:\n",
    "        if Special.value == 'Legend':\n",
    "            # define interactive legend\n",
    "            handles, labels = ax.get_legend_handles_labels() # return lines and labels\n",
    "            interactive_legend = plugins.InteractiveLegendPlugin(zip(handles,\n",
    "                                                                     ax.collections),\n",
    "                                                                 labels,\n",
    "                                                                 alpha_unsel=0.2,\n",
    "                                                                 alpha_over=1.5, \n",
    "                                                                 start_visible=True)\n",
    "            plugins.connect(fig, interactive_legend)\n",
    "        else:\n",
    "            #tooltip = mpld3.plugins.PointLabelTooltip(ax, labels=labels)\n",
    "            #plugins.connect(fig, tooltip)\n",
    "            mpld3.plugins.connect(fig, HighlightLines(l))\n",
    "    \n",
    "    ax.set_title('Plot', size=20)\n",
    "    #display(fig)\n",
    "    Plot = HTML(htmlplot)\n",
    "    #display(Plot)\n",
    "    if viewer.value == True:\n",
    "        mpld3.display()\n",
    "    else:\n",
    "        pass\n",
    "    #Output.value = str(desc)\n",
    "    print(desc)\n",
    "    progress.value = progress.max\n",
    "    time.sleep(.1)\n",
    "    progress.value = 0\n",
    "    \n",
    "    #img\n",
    "    #imgbx.value=  img\n",
    "    #format='png',\n",
    "    #width=300,\n",
    "    #height=400,\n",
    "#imgbx = widgets.Image()\n",
    "btn_plt.on_click(on_button_clicked)\n",
    "#myplot=widgets.HTML()\n",
    "#ax = plt.gca()\n",
    "#mt = pd.DataFrame({'a':[4],'b':[3]})\n",
    "\n",
    "# file = open(\"\", \"rb\")\n",
    "#image = file.read()\n",
    "\n",
    "\n",
    "Plot = HTML('')\n",
    "vbox_result = widgets.VBox([progress,btn_plt])\n",
    "vbox_Setup = widgets.VBox([vbox_general,vbox_result])\n",
    "hbox_Setup = widgets.HBox([vbox_Setup,vbox_main])\n",
    "vbox_Final = widgets.VBox([hbox_Setup,Output])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9bee0ab779094d238e1a158fd10f185b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(VBox(children=(VBox(children=(HTML(value='<h1>&Dscr;&ascr;&tscr;&ascr;\\n        …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "32323e23687740ff87828bae8f34e953",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       DO_mg/L - Inversion Surface  pH - Inversion Surface          Color  \\\n",
      "count                 55641.000000            55641.000000  158372.000000   \n",
      "mean                      7.455167                7.582336       3.155432   \n",
      "std                       3.572092                0.360824       1.347895   \n",
      "min                       0.050000                6.850000       1.000000   \n",
      "25%                       4.660000                7.270000       2.000000   \n",
      "50%                       7.470000                7.520000       3.000000   \n",
      "75%                      10.190000                7.850000       4.000000   \n",
      "max                      17.860000                9.000000       5.000000   \n",
      "\n",
      "                Size  \n",
      "count  158372.000000  \n",
      "mean        6.908797  \n",
      "std         3.366328  \n",
      "min         1.000000  \n",
      "25%         4.000000  \n",
      "50%         7.000000  \n",
      "75%        10.000000  \n",
      "max        12.000000  \n"
     ]
    }
   ],
   "source": [
    "#page = widgets.HBox([vbox_Setup])\n",
    "mpld3.enable_notebook()\n",
    "page = vbox_Final\n",
    "display(page)\n",
    "#display(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import matplotlib.pyplot as plt\n",
    "# import numpy as np\n",
    "# import pandas as pd\n",
    "# import mpld3\n",
    "# from mpld3 import plugins\n",
    "# np.random.seed(9999)\n",
    "# np.random.seed(np.random.randint(1,9999))\n",
    "\n",
    "\n",
    "# # generate df\n",
    "# N = 20\n",
    "# df = pd.DataFrame((.1 * (np.random.random((N, 5)) - .5)).cumsum(0),\n",
    "#                   columns=['a', 'b', 'c', 'd', 'e'],)\n",
    "\n",
    "# # plot line + confidence interval\n",
    "# fig, ax = plt.subplots()\n",
    "# ax.grid(True, alpha=0.3)\n",
    "\n",
    "# for key, val in df.iteritems():\n",
    "#     l, = ax.plot(val.index, val.values, label=key)\n",
    "#     ax.fill_between(val.index,\n",
    "#                      val.values * .5, val.values * 1.5,\n",
    "#                      color=l.get_color(), alpha=.4)\n",
    "\n",
    "# # define interactive legend\n",
    "\n",
    "# handles, labels = ax.get_legend_handles_labels() # return lines and labels\n",
    "# interactive_legend = plugins.InteractiveLegendPlugin(zip(handles,\n",
    "#                                                          ax.collections),\n",
    "#                                                      labels,\n",
    "#                                                      alpha_unsel=0.5,\n",
    "#                                                      alpha_over=1.5, \n",
    "#                                                      start_visible=True)\n",
    "# plugins.connect(fig, interactive_legend)\n",
    "\n",
    "# ax.set_xlabel('x')\n",
    "# ax.set_ylabel('y')\n",
    "# ax.set_title('Interactive legend', size=20)\n",
    "\n",
    "# mpld3.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def __Version__():\n",
    "    return('1.5.0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "88.25369863013698"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ES)/(365*5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}