forecasting_dashboard.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run all the below for the dashboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from datetime import datetime, timedelta\n",
    "import math \n",
    "import os\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "\n",
    "import dash\n",
    "import dash_table\n",
    "import dash_core_components as dcc\n",
    "import dash_html_components as html \n",
    "import dash_bootstrap_components as dbc\n",
    "from dash.dependencies import Input, Output\n",
    "\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.optimize import fsolve\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "from geopy.geocoders import Nominatim\n",
    "from geopy.exc import GeocoderTimedOut"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# pull the latest john hopkins time series dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if os.path.isdir('./COVID-19'):\n",
    "    print(\"checkout fresh version\")\n",
    "    path = r\"./COVID-19\"\n",
    "    pull = \"git checkout master .\" \n",
    "\n",
    "    #os.system(\"sshpass -p your_password ssh user_name@your_localhost\")\n",
    "    os.chdir(path) # Specifying the path where the cloned project needs to be copied\n",
    "    os.system(pull) # pulling\n",
    "else:\n",
    "    print(\"clone the john hopkins data\")\n",
    "    github_path  = \"https://github.com/CSSEGISandData/COVID-19.git\" \n",
    "    pull = \"git clone\" \n",
    "    os.system(pull + \" \" + github_path) # pulling\n",
    "    path = r\"./COVID-19\"\n",
    "    os.chdir(path) # Specifying the path where the cloned project needs to be copied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "url = 'https://data.humdata.org/hxlproxy/api/data-preview.csv?url=https%3A%2F%2Fraw.githubusercontent.com%2FCSSEGISandData%2FCOVID-19%2Fmaster%2Fcsse_covid_19_data%2Fcsse_covid_19_time_series%2Ftime_series_covid19_confirmed_global.csv&filename=time_series_covid19_confirmed_global.csv'\n",
    "time_series_data_confirmed = pd.read_csv(url)\n",
    "url = 'https://data.humdata.org/hxlproxy/api/data-preview.csv?url=https%3A%2F%2Fraw.githubusercontent.com%2FCSSEGISandData%2FCOVID-19%2Fmaster%2Fcsse_covid_19_data%2Fcsse_covid_19_time_series%2Ftime_series_covid19_deaths_global.csv&filename=time_series_covid19_deaths_global.csv'\n",
    "time_series_data_deaths = pd.read_csv(url)\n",
    "url = 'https://data.humdata.org/hxlproxy/api/data-preview.csv?url=https%3A%2F%2Fraw.githubusercontent.com%2FCSSEGISandData%2FCOVID-19%2Fmaster%2Fcsse_covid_19_data%2Fcsse_covid_19_time_series%2Ftime_series_covid19_recovered_global.csv&filename=time_series_covid19_recovered_global.csv'\n",
    "time_series_data_recovered = pd.read_csv(url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "time_series_data_confirmed[time_series_data_confirmed['Country/Region']=='United Kingdom'][[time_series_data_confirmed.columns[0], time_series_data_confirmed.columns[1], time_series_data_confirmed.columns[-1]]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "time_series_data_confirmed.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def df_for_lineplot_diff(dfs, CaseType):\n",
    "    '''This is the function for construct df for line plot'''\n",
    "    \n",
    "    assert type(CaseType) is str, \"CaseType must be one of the following three strings Confirmed/Recovered/Deaths\"\n",
    "    \n",
    "    \n",
    "    # Construct confirmed cases dataframe for line plot\n",
    "    DateList = []\n",
    "    ChinaList =[]\n",
    "    OtherList = []\n",
    "\n",
    "    for key, df in dfs.items():\n",
    "        dfTpm = df.groupby(['Country/Region'])[CaseType].agg(np.sum)\n",
    "        dfTpm = pd.DataFrame({'Region':dfTpm.index, CaseType:dfTpm.values})\n",
    "        #dfTpm = dfTpm.sort_values(by=CaseType, ascending=False).reset_index(drop=True)\n",
    "        DateList.append(df['Date_last_updated_AEDT'][0])\n",
    "        #DateList.append(df['Last Update'][0])\n",
    "        \n",
    "        ChinaList.append(dfTpm.loc[dfTpm['Region'] == 'China', CaseType].iloc[0])\n",
    "        OtherList.append(dfTpm.loc[dfTpm['Region'] != 'China', CaseType].sum())\n",
    "\n",
    "    df = pd.DataFrame({'Date':DateList,\n",
    "                       'Mainland China':ChinaList,\n",
    "                       'Other locations':OtherList})\n",
    "    df['Total']=df['Mainland China']+df['Other locations']\n",
    "\n",
    "    # Calculate differenec in a 24-hour window\n",
    "    for index, _ in df.iterrows():\n",
    "        # Calculate the time differnece in hour\n",
    "        diff=(df['Date'][0] - df['Date'][index]).total_seconds()/3600\n",
    "        # find out the latest time after 24-hour\n",
    "        if diff >= 24:\n",
    "            break\n",
    "    plusNum = df['Total'][0] - df['Total'][1]\n",
    "    plusPercentNum = (df['Total'][0] - df['Total'][1])/df['Total'][1]\n",
    "\n",
    "    # Select the latest data from a given date\n",
    "    df['date_day']=[d.date() for d in df['Date']]\n",
    "    df=df.groupby(by=df['date_day'], sort=False).transform(max).drop_duplicates(['Date'])\n",
    "    \n",
    "    df['plusNum'] = plusNum\n",
    "    df['plusPercentNum'] = plusPercentNum\n",
    "    \n",
    "    df=df.reset_index(drop=True)\n",
    "    \n",
    "    return df, plusNum, plusPercentNum "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "################################################################################\n",
    "#### Data processing\n",
    "################################################################################\n",
    "# Method #1\n",
    "# Import csv file and store each csv in to a df list\n",
    "\n",
    "filename = os.listdir('./csse_covid_19_data/csse_covid_19_daily_reports/')\n",
    "sheet_name = [i.replace('.csv', '') for i in filename if 'data' not in i and i.endswith('.csv')]\n",
    "sheet_name.sort(reverse=True)\n",
    "\n",
    "dfs = {sheet_name: pd.read_csv('./csse_covid_19_data/csse_covid_19_daily_reports/{}.csv'.format(sheet_name))\n",
    "          for sheet_name in sheet_name}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Data from each sheet can be accessed via key\n",
    "keyList = list(dfs.keys())\n",
    "# Data cleansing\n",
    "for key, df in dfs.items():\n",
    "    dfs[key]=dfs[key].rename(columns={'Last_Update': 'Last Update', \"Province_State\":\"Province/State\", \"Country_Region\":\"Country/Region\", \"Lat\":\"lat\", \"Long_\":\"lon\", \"Latitude\":\"lat\", \"Longitude\":\"lon\"})\n",
    "    dfs[key].loc[:,'Confirmed'].fillna(value=0, inplace=True)\n",
    "    dfs[key].loc[:,'Deaths'].fillna(value=0, inplace=True)\n",
    "    dfs[key].loc[:,'Recovered'].fillna(value=0, inplace=True)\n",
    "    dfs[key]=dfs[key].astype({'Confirmed':'int64', 'Deaths':'int64', 'Recovered':'int64'})\n",
    "    # Change as China for coordinate search\n",
    "    dfs[key]=dfs[key].replace({'Country/Region':'Mainland China'}, 'China')\n",
    "    # Add a zero to the date so can be convert by datetime.strptime as 0-padded date\n",
    "    dfs[key]['Last Update'] = '0' + dfs[key]['Last Update']\n",
    "    # Convert time as Australian eastern daylight time\n",
    "    ### Try to sort out the crazy variety of formatting of dates in the John Hopkins Data\n",
    "    dates_append = []\n",
    "    for d in dfs[key]['Last Update']:\n",
    "        d = str(d)\n",
    "        d = d.replace(\"T\",\" \")\n",
    "        if \"-\" in d:\n",
    "            dates_append.append(datetime.strptime(d[-19:], '%Y-%m-%d %H:%M:%S'))\n",
    "            #dfs[key]['Date_last_updated_AEDT'] = [datetime.strptime(d, '%Y/%m/%d %H:%M:%S') for d in dfs[key]['Last Update']]\n",
    "        elif d == 'nan':\n",
    "            dates_append.append('')\n",
    "        else:\n",
    "            try:\n",
    "                dates_append.append(datetime.strptime(d[-14:], '%m/%d/%Y %H:%M'))\n",
    "            except:\n",
    "                try:\n",
    "                    dates_append.append(datetime.strptime(d[-14:], '%m/%d/%y %H:%M'))\n",
    "                except:\n",
    "                    try:\n",
    "                        dates_append.append(datetime.strptime(d[-13:], '%m/%d/%y %H:%M'))\n",
    "                    except:\n",
    "                        try:\n",
    "                            dates_append.append(datetime.strptime(d, '%m/%d/%Y %H:%M'))\n",
    "                        except:\n",
    "                            try:\n",
    "                                dates_append.append(datetime.strptime(d[-16:], '%m/%d/%Y %H:%M'))\n",
    "                            except:\n",
    "                                try:\n",
    "                                    dates_append.append(datetime.strptime(d[-16:], '%m/%d/%Y %H:%M'))\n",
    "                                except:\n",
    "                                    try:\n",
    "                                        dates_append.append(datetime.strptime(d[-12:], '%m/%d/%y %H:%M'))\n",
    "                                    except:\n",
    "                                        print('Error could not parse date: ', d)\n",
    "                                        dates_append.append('')\n",
    "                #dfs[key]['Date_last_updated_AEDT'] = [datetime.strptime(d, '%m/%d/%Y %H:%M') for d in dfs[key]['Last Update']]\n",
    "    dfs[key]['Date_last_updated_AEDT'] = dates_append\n",
    "    dfs[key]['Date_last_updated_AEDT'] = dfs[key]['Date_last_updated_AEDT'] + timedelta(hours=16)\n",
    "    dfs[key]['Remaining'] = dfs[key]['Confirmed'] - dfs[key]['Recovered'] - dfs[key]['Deaths']\n",
    "    dfs[key] = dfs[key].fillna('')\n",
    "    #print(key)\n",
    "    #print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Add coordinates for each area in the list for the latest table sheet\n",
    "# To save time, coordinates calling was done seperately\n",
    "# Import the data with coordinates\n",
    "data_sheet_df = pd.read_csv(r'../2020-03-24-06-00_data.csv'.format(keyList[0]))\n",
    "print(data_sheet_df)\n",
    "dfs[keyList[0]]=dfs[keyList[0]].astype({'Date_last_updated_AEDT':'datetime64'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#merged_df = left_df.merge(right_df, how='inner', left_on=[\"A\", \"B\"], right_on=[\"A2\",\"B2\"])\n",
    "merged_df = dfs[keyList[0]].merge(time_series_data_confirmed[[\"Province/State\", \"Country/Region\", \"3/30/20\"]], how='outer', left_on=[\"Province/State\", \"Country/Region\"], right_on=[\"Province/State\", \"Country/Region\"])\n",
    "merged_df['Confirmed'] = merged_df['3/30/20']\n",
    "del merged_df['3/30/20']\n",
    "merged_df = merged_df.merge(time_series_data_deaths[[\"Province/State\", \"Country/Region\", \"3/30/20\"]], how='outer', left_on=[\"Province/State\", \"Country/Region\"], right_on=[\"Province/State\", \"Country/Region\"])\n",
    "merged_df['Deaths'] = merged_df['3/30/20']\n",
    "del merged_df['3/30/20']\n",
    "merged_df = merged_df.merge(time_series_data_recovered[[\"Province/State\", \"Country/Region\", \"3/30/20\"]], how='outer', left_on=[\"Province/State\", \"Country/Region\"], right_on=[\"Province/State\", \"Country/Region\"])\n",
    "merged_df['Recovered'] = merged_df['3/30/20']\n",
    "del merged_df['3/30/20']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "merged_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "baseURL = \"https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/\"\n",
    "def loadData(fileName, columnName):\n",
    "    data = pd.read_csv(baseURL + fileName) \\\n",
    "             .drop(['Lat', 'Long'], axis=1) \\\n",
    "             .melt(id_vars=['Province/State', 'Country/Region'], \n",
    "                 var_name='date', value_name=columnName) \\\n",
    "             .astype({'date':'datetime64[ns]', columnName:'Int64'}, \n",
    "                 errors='ignore')\n",
    "    data['Province/State'].fillna('<all>', inplace=True)\n",
    "    data[columnName].fillna(0, inplace=True)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def make_country_table(countryName):\n",
    "    '''This is the function for building df for Province/State of a given country'''\n",
    "    countryTable = dfs[keyList[0]].loc[dfs[keyList[0]]['Country/Region'] == countryName]\n",
    "    # Suppress SettingWithCopyWarning\n",
    "    pd.options.mode.chained_assignment = None\n",
    "    countryTable['Remaining'] = countryTable['Confirmed'] - countryTable['Recovered'] - countryTable['Deaths']\n",
    "    countryTable = countryTable[['Province/State','Remaining','Confirmed','Recovered','Deaths','lat','lon']]\n",
    "    countryTable = countryTable.sort_values(by=['Remaining', 'Confirmed'], ascending=False).reset_index(drop=True)\n",
    "    # Set row ids pass to selected_row_ids\n",
    "    countryTable['id'] = countryTable['Province/State']\n",
    "    countryTable.set_index('id', inplace=True, drop=False)\n",
    "    # Turn on SettingWithCopyWarning\n",
    "    pd.options.mode.chained_assignment = 'warn'\n",
    "    return countryTable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "CNTable = make_country_table('China')\n",
    "AUSTable = make_country_table('Australia')\n",
    "USTable = make_country_table('US')\n",
    "CANTable = make_country_table('Canada')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "CANTable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Work on the UK as a special case where we try to forecast the number of free beds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1: Build the UK COVID-19 forecase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def build_df_region(Region):\n",
    "    if Region == 'UK':\n",
    "        Region = 'United Kingdom'\n",
    "    df_region = pd.DataFrame(time_series_data_confirmed[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:])\n",
    "    if len(df_region.columns) > 1:\n",
    "        s = df_region.sum().sort_values(ascending=False, inplace=False)\n",
    "        df_region = pd.DataFrame(df_region[s[:1].index[0]].astype(int))\n",
    "        df_region.columns = ['Confirmed']\n",
    "        df_region_recovered = pd.DataFrame(time_series_data_recovered[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:])\n",
    "        s = df_region_recovered.sum().sort_values(ascending=False, inplace=False)\n",
    "        df_region_recovered = pd.DataFrame(df_region_recovered[s[:1].index[0]].astype(int))\n",
    "        df_region['Recovered'] = df_region_recovered\n",
    "        df_region_deaths = pd.DataFrame(time_series_data_deaths[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:])\n",
    "        s = df_region_deaths.sum().sort_values(ascending=False, inplace=False)\n",
    "        df_region_deaths = pd.DataFrame(df_region_deaths[s[:1].index[0]].astype(int))\n",
    "        df_region['Deaths'] = df_region_deaths\n",
    "    else:\n",
    "        df_region.columns = ['Confirmed']\n",
    "        df_region['Recovered'] = time_series_data_recovered[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:]\n",
    "        df_region['Deaths'] = time_series_data_deaths[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:]\n",
    "    df_region['New'] = df_region['Confirmed'].astype(int).diff().fillna(0)\n",
    "    list_days = []\n",
    "    for i in range(1,len(df_region['Confirmed'])+1):\n",
    "        list_days.append(df_region['Confirmed'][:i].astype(bool).sum(axis=0))\n",
    "    df_region['DayElapsed'] = list_days\n",
    "    df_region['date_day'] = df_region.index\n",
    "    date_list = []\n",
    "    for date_str in df_region['date_day']:\n",
    "        date_list.append(datetime.strptime(date_str, '%m/%d/%y'))\n",
    "    df_region['Date_last_updated_AEDT'] = date_list\n",
    "    df_region['Date_last_updated_AEDT'] = df_region['Date_last_updated_AEDT'] + timedelta(hours=16)\n",
    "    df_region=df_region.astype({'Date_last_updated_AEDT':'datetime64', 'date_day':'datetime64'})\n",
    "    return df_region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "Region = 'United Kingdom'\n",
    "df_region = build_df_region(Region)\n",
    "\n",
    "#df_region = pd.read_csv('C:/Users/jmckinnell/Documents/Personal/COVID-19-research/data_pull/data-visualisation-scripts/dash-2019-coronavirus/cumulative_data/{}.csv'.format(Region))\n",
    "#df_region=df_region.astype({'Date_last_updated_AEDT':'datetime64', 'date_day':'datetime64'})\n",
    "\n",
    "df = df_region.loc[:,['date_day','Confirmed']]\n",
    "df.index = df['date_day']\n",
    "df = df.sort_index()\n",
    "FMT = '%Y-%m-%d %H:%M:%S'\n",
    "date = df['date_day']\n",
    "df['data'] = date.map(lambda x : (datetime.strptime(str(x), FMT) - datetime.strptime(\"2020-01-01 00:00:00\", FMT)).days  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#The logistic model\n",
    "def logistic_model(x,a,b,c):\n",
    "    return c/(1+np.exp(-(x-b)/a))\n",
    "\n",
    "#We can use the curve_fit function of scipy library to estimate the parameter values and errors starting from the original data.\n",
    "\n",
    "x = list(df['data'])\n",
    "y = list(df['Confirmed'])\n",
    "\n",
    "fit = curve_fit(logistic_model,x,y,p0=[2,100,20000])\n",
    "a = fit[0][0]\n",
    "b = fit[0][1]\n",
    "c = fit[0][2]\n",
    "errors = [np.sqrt(fit[1][i][i]) for i in [0,1,2]]\n",
    "sol = int(fsolve(lambda x : logistic_model(x,a,b,c) - int(c),b))\n",
    "\n",
    "#Exponential model\n",
    "def exponential_model(x,a,b,c):\n",
    "    return a*np.exp(b*(x-c))\n",
    "\n",
    "\n",
    "exp_fit = curve_fit(exponential_model,x,y,p0=[1,1,1],maxfev=2000)\n",
    "base = datetime.strptime(str(date[-1:].values[0]).replace(\"T\",\" \")[:19],\"%Y-%m-%d %H:%M:%S\")\n",
    "dates = []\n",
    "\n",
    "for i_date in date:\n",
    "    dates.append(datetime.strptime(str(i_date).replace(\"T\",\" \")[:19],\"%Y-%m-%d %H:%M:%S\"))\n",
    "\n",
    "date_list_pred = [base + timedelta(days=i_x) for i_x in range(1,sol)]\n",
    "date_list = []\n",
    "for i_date in dates:\n",
    "    date_list.append(i_date)\n",
    "\n",
    "for i_date in date_list_pred:\n",
    "    date_list.append(i_date)\n",
    "\n",
    "fig = plt.figure(figsize=(20,10))\n",
    "\n",
    "pred_x = list(range(max(x),sol))\n",
    "plt.rcParams['figure.figsize'] = [7, 7]\n",
    "plt.rc('font', size=14)\n",
    "# Real data\n",
    "plt.scatter(dates,y,label=\"Real data\",color=\"red\")\n",
    "# Predicted logistic curve\n",
    "plt.plot(date_list, [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in range(0+min(x),len(date_list)+min(x))], label=\"Logistic model\" )\n",
    "# Predicted exponential curve\n",
    "plt.plot(date_list, [exponential_model(i,exp_fit[0][0],exp_fit[0][1],exp_fit[0][2]) for i in range(0+min(x),len(date_list)+min(x))], label=\"Exponential model\" )\n",
    "plt.legend()\n",
    "plt.xlabel(\"Days slogistic_modelince 1 January 2020\")\n",
    "plt.ylabel(\"Total number of infected people\")\n",
    "plt.ylim((min(y)*0.9,c*1.1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 2: Download the NHS England free beds hisorical data for a baseline of free beds at different NHS Trusts in England"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lm_predicted = [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in range(0+min(x),len(date_list)+min(x))]\n",
    "from datetime import date, datetime\n",
    "\n",
    "today = date.today()\n",
    "\n",
    "today_with_time = datetime(\n",
    "    year=today.year, \n",
    "    month=today.month,\n",
    "    day=today.day,\n",
    "    hour=0,\n",
    "    minute=0\n",
    ")\n",
    "\n",
    "try:\n",
    "    location = date_list.index(today_with_time)\n",
    "    print(today, \" was found in the list.\") \n",
    "\n",
    "except:\n",
    "    print(today, \" was not found in the list.\") \n",
    "\n",
    "total_cases_predicted_in_a_week = lm_predicted[location+7]\n",
    "current_cases = lm_predicted[location]\n",
    "growth_factor_in_a_week = total_cases_predicted_in_a_week / current_cases\n",
    "print(growth_factor_in_a_week)\n",
    "\n",
    "#Read in the beds data: Using the beds data for England in Q1 2019 as a baseline (current Quarter in 2020) before the COVID-19 cases\n",
    "\n",
    "### Using Q1 beds data from 2019 as a baseline\n",
    "df_england_beds = pd.read_excel('https://www.england.nhs.uk/statistics/wp-content/uploads/sites/2/2020/02/Beds-Timeseries-2010-11-onwards-Q3-2019-20-ADJ-for-missings-j8hyu.xls', header=13)\n",
    "df_england_beds[['Year','Total ', 'General & Acute']].plot()\n",
    "df_england_beds[['Year','Total .1', 'General & Acute.1']].plot()\n",
    "df_england_beds[['Year','Total .2', 'General & Acute.2']].plot()\n",
    "\n",
    "#read in the free beds via hospital\n",
    "df_england_beds_region = pd.read_excel(\"https://www.england.nhs.uk/statistics/wp-content/uploads/sites/2/2019/11/Beds-Open-Overnight-Web_File-Final-Q1-201920.xlsx\", header=14)\n",
    "df_england_beds_region['Free General & Acute'] = df_england_beds_region['General & Acute'] - df_england_beds_region['General & Acute.1']\n",
    "df_england_beds_region.index = df_england_beds_region['Org Name']\n",
    "df_england_beds_region['Free General & Acute'][2:].plot(figsize=(50,5), kind='bar', ylim=(0,300))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get the England regions COVID-19 data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#read in the latest UK COVID-19 data for England regions\n",
    "# download UK regional cases\n",
    "url = \"https://www.arcgis.com/sharing/rest/content/items/b684319181f94875a6879bbc833ca3a6/data\"\n",
    "excel_url = 'https://fingertips.phe.org.uk/documents/Historic%20COVID-19%20Dashboard%20Data.xlsx'\n",
    "new_csv = 'https://raw.githubusercontent.com/tomwhite/covid-19-uk-data/master/data/covid-19-cases-uk.csv'\n",
    "excel_sheet_name = 'UTLAs'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_UK_tmp = pd.read_csv(new_csv, error_bad_lines=False)\n",
    "latest_date = max(df_UK_tmp['Date'])\n",
    "print(str(datetime.strptime(latest_date,'%Y-%m-%d') - timedelta(days=1))[0:10])\n",
    "df_UK_latest = df_UK_tmp[df_UK_tmp['Date']== str(datetime.strptime(latest_date,'%Y-%m-%d') - timedelta(days=1))[0:10]]\n",
    "df_UK = df_UK_latest[['Area', 'TotalCases']]\n",
    "df_UK.columns = ['GSS_NM', 'TotalCases']\n",
    "df_UK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_UK_lat_lon = pd.read_csv('../df_UK_lat_lon_all.csv')\n",
    "del df_UK_lat_lon['Unnamed: 0']\n",
    "df_UK_lat_lon = df_UK_lat_lon.dropna()\n",
    "df_UK = df_UK.merge(df_UK_lat_lon, how='outer', left_on=[\"GSS_NM\"], right_on=[\"GSS_NM\"])\n",
    "df_UK = df_UK.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "from geopy.geocoders import Nominatim\n",
    "from geopy.exc import GeocoderTimedOut\n",
    "geolocator = Nominatim(user_agent=\"covid_shahinrostami.com\")\n",
    "\n",
    "for index, row in df_UK.iterrows():\n",
    "    print(row)\n",
    "    try:\n",
    "        location = geolocator.geocode(f\"{row.GSS_NM}, UK\",timeout=100)\n",
    "    except GeocoderTimedOut:\n",
    "        try:\n",
    "            location = geolocator.geocode(f\"{row.GSS_NM}, UK\",timeout=100)\n",
    "        except:\n",
    "            location = geolocator.geocode(f\"{row.GSS_NM}, UK\",timeout=100)\n",
    "    try:\n",
    "        df_UK.loc[index,'lat'] = location.latitude \n",
    "        df_UK.loc[index,'lon'] = location.longitude\n",
    "    except:\n",
    "        df_UK.loc[index,'lat'] = np.nan \n",
    "        df_UK.loc[index,'lon'] = np.nan\n",
    "    \n",
    "\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#df_UK[['GSS_NM','lat','lon']].to_csv('../df_UK_lat_lon_all.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_UK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tmp_total_cases = []\n",
    "# eunsure we have total cases as floats and remove commas to do so\n",
    "for item in df_UK['TotalCases']:\n",
    "    if isinstance(item, str):\n",
    "        tmp_total_cases.append(float(item.replace(',','')))\n",
    "    elif isinstance(item, int):\n",
    "        tmp_total_cases.append(float(item))\n",
    "    elif isinstance(item, float):\n",
    "        tmp_total_cases.append(float(item))\n",
    "    else:\n",
    "        tmp_total_cases.append(0)\n",
    "        print('item type error: ', item)\n",
    "df_UK['TotalCases'] = tmp_total_cases\n",
    "\n",
    "df_UK_tmp = df_UK.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Match the UK local data to the NHS beds data for England NHS trusts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pgeocode\n",
    "#match the local data to the beds regions\n",
    "df_nhs_trusts = pd.read_csv('https://nhsenglandfilestore.s3.amazonaws.com/ods/etr.csv', header=None)\n",
    "matches = []\n",
    "### scotland beds data\n",
    "## https://beta.isdscotland.org/media/3443/20200225_beds_by_health_board_of_treatment_and_specialty.csv\n",
    "for org_name in df_england_beds_region['Org Name']: \n",
    "    for trust in df_nhs_trusts[1]:\n",
    "        if trust == org_name:\n",
    "            print(trust, ' matches ', org_name)\n",
    "            matches.append(trust + ' matches ' + org_name)\n",
    "\n",
    "df_england_beds_region.reset_index(drop=True)\n",
    "\n",
    "merged_df = df_england_beds_region.reset_index(drop=True).merge(df_nhs_trusts[[1,9]], how='outer', left_on=[\"Org Name\"], right_on=[1])\n",
    "\n",
    "nomi = pgeocode.Nominatim('gb')\n",
    "\n",
    "lat_list = []\n",
    "lon_list = []\n",
    "for item in merged_df[9]:\n",
    "    item = str(item)\n",
    "    if item == \"NaN\" or item == \"nan\":\n",
    "        lat_list.append(0)\n",
    "        lon_list.append(0)\n",
    "    else:\n",
    "        lat = nomi.query_postal_code(item).latitude\n",
    "        lon = nomi.query_postal_code(item).longitude\n",
    "        lat_list.append(float(lat.item()))\n",
    "        lon_list.append(float(lon.item()))\n",
    "merged_df['lat'] = lat_list\n",
    "merged_df['lon'] = lon_list\n",
    "\n",
    "#find the closest lat and lon to that trust from the geospatial data and join the datasets to the beds dataset\n",
    "\n",
    "from math import cos, asin, sqrt\n",
    "\n",
    "def distance(lat1, lon1, lat2, lon2):\n",
    "    p = 0.017453292519943295\n",
    "    a = 0.5 - cos((lat2-lat1)*p)/2 + cos(lat1*p)*cos(lat2*p) * (1-cos((lon2-lon1)*p)) / 2\n",
    "    return 12742 * asin(sqrt(a))\n",
    "\n",
    "def closest(data, v):\n",
    "    #for item in data:\n",
    "    #    print(distance(v['lat'],v['lon'],item['lat'],item['lon']))\n",
    "    return min(data, key=lambda p: distance(v['lat'],v['lon'],p['lat'],p['lon']))\n",
    "\n",
    "hospital_lat = []\n",
    "hospital_lon = []\n",
    "\n",
    "for index, row in df_UK.iterrows():\n",
    "    v = {'lat': row['lat'], 'lon': row['lon']}\n",
    "    match = closest(list(merged_df[['lat','lon']].T.to_dict().values()),v)\n",
    "    print(distance(v['lat'],v['lon'],match['lat'],match['lon']))\n",
    "    if distance(v['lat'],v['lon'],match['lat'],match['lon']) < 50: #ensures the match is sensible\n",
    "        hospital_lat.append(match['lat'])\n",
    "        hospital_lon.append(match['lon'])\n",
    "    else:\n",
    "        hospital_lat.append(np.nan)\n",
    "        hospital_lon.append(np.nan)\n",
    "\n",
    "df_UK['hospital_lat'] = hospital_lat\n",
    "df_UK['hospital_lon'] = hospital_lon\n",
    "\n",
    "df_UK_merged = df_UK.merge(merged_df[[\"Org Name\", \"Total \", \"General & Acute\",  \"Total .1\", \"General & Acute.1\",\"lat\",\"lon\"]], how='inner', left_on=[\"hospital_lon\", \"hospital_lat\"], right_on=[\"lon\",\"lat\"])\n",
    "df_UK_merged['Free Beds Without COVID-19'] = df_UK_merged['Total '] - df_UK_merged['Total .1']\n",
    "\n",
    "Free_Beds_INCLUDING_COVID = []\n",
    "counts_list = df_UK_merged.groupby(by=['GSS_NM'])['GSS_NM'].count()\n",
    "\n",
    "for item in df_UK_merged['GSS_NM']:\n",
    "    Free_Beds_INCLUDING_COVID.append(counts_list[item])\n",
    "\n",
    "df_UK_merged['count'] = Free_Beds_INCLUDING_COVID\n",
    "percentage_cases_open = 1-(277643/1044167)\n",
    "\n",
    "#8.2% of patients require hospitalisation according to Imperial College study\n",
    "\n",
    "percentage_hospital = percentage_cases_open * 0.082 \n",
    "percentage_serious = percentage_cases_open * 0.05 \n",
    "\n",
    "print(percentage_cases_open, percentage_serious, percentage_hospital)\n",
    "    \n",
    "df_UK_merged['Free Beds INCLUDING COVID-19'] = df_UK_merged['Free Beds Without COVID-19'] - (percentage_hospital * df_UK_merged['TotalCases']/df_UK_merged['count'].astype(float))\n",
    "df_UK_merged.index = df_UK_merged['Org Name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print out and plot the expectation for current free beds in the NHS trusts in England"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "minimum = min(df_UK_merged['Free Beds INCLUDING COVID-19'][2:].fillna(0))\n",
    "maximum = max(df_UK_merged['Free Beds INCLUDING COVID-19'][2:].fillna(0))\n",
    "\n",
    "#Plot a chart representing the current hospital bed vacancy by trust by incrementing over and above 2019 Q1 total free beds with COVID-19 estimated current cases requiring hospitalisation in the UK\n",
    "df_UK_merged.sort_values(by=['Free Beds INCLUDING COVID-19'])['Free Beds INCLUDING COVID-19'].dropna()[2:].plot(figsize=(100,50), kind='bar', ylim=(minimum,maximum),color=(df_UK_merged.sort_values(by=['Free Beds INCLUDING COVID-19'])['Free Beds INCLUDING COVID-19'][2:].dropna() > 0).map({True: 'g',False: 'r'}),title=\"Estimated current number of free beds after COVID-19 by hospital trust in the UK\",fontsize = 30)\n",
    "df_UK_merged.sort_values(by=['Free Beds INCLUDING COVID-19'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print out and plot the forecasted free beds in 1 WEEK for NHS Enland Trusts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Plot a chart representing the NEXT WEEKS hospital bed vacancy by trust by incrementing over and above 2019 Q1 total free beds with COVID-19 estimated cases 1 WEEK FROM TODAY requiring hospitalisation in the UK\n",
    "df_UK_merged['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK'] = df_UK_merged['Free Beds Without COVID-19'] - (percentage_hospital * growth_factor_in_a_week * df_UK_merged['TotalCases']/df_UK_merged['count'])\n",
    "\n",
    "minimum = min(df_UK_merged['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK'][2:].fillna(0))\n",
    "maximum = max(df_UK_merged['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK'][2:].fillna(0))\n",
    "\n",
    "df_UK_merged.sort_values(by=['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK'])['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK'].dropna()[2:].plot(figsize=(100,50), kind='bar', ylim=(minimum,maximum),color=(df_UK_merged.sort_values(by=['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK'])['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK'][2:].dropna() > 0).map({True: 'g',False: 'r'}),title=\"Estimated current number of free beds after COVID-19 by hospital trust in the UK\",fontsize = 30)\n",
    "df_UK_merged.sort_values(by=['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK']).dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Go back to building the UK regions data for the dashboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df_UK = df_UK_tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "df_UK = pd.read_csv('df_UK.csv')\n",
    "del df_UK['Unnamed: 0']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_UK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "df_UK.to_csv('df_UK.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "UKTable= pd.DataFrame(columns=CANTable.columns)\n",
    "UKTable['Province/State'] = df_UK['GSS_NM']\n",
    "UKTable['Confirmed'] = df_UK['TotalCases']\n",
    "UKTable['lat'] = df_UK['lat']\n",
    "UKTable['lon'] = df_UK['lon']\n",
    "UKTable['id'] = df_UK['GSS_NM']\n",
    "UKTable.index = UKTable['id']\n",
    "UKTable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "UKTable_append = UKTable.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "UKTable_append['Country/Region']='UK'\n",
    "UKTable_append['Last Update'] = '2020-03-24 22:00:00'\n",
    "UKTable_append['Date_last_updated_AEDT'] = '2020-03-24 22:00:00'\n",
    "UKTable_append['Recovered'] = 0\n",
    "UKTable_append['Deaths'] = 0\n",
    "UKTable_append['Remaining'] = 0\n",
    "del UKTable_append['id']\n",
    "UKTable_append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dfs[keyList[0]].columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# Save numbers into variables to use in the app\n",
    "confirmedCases=int(dfs[keyList[0]]['Confirmed'].sum())\n",
    "deathsCases=int(dfs[keyList[0]]['Deaths'].sum())\n",
    "recoveredCases=int(dfs[keyList[0]]['Recovered'].sum())\n",
    "\n",
    "# Construct confirmed cases dataframe for line plot and 24-hour window case difference\n",
    "df_confirmed, plusConfirmedNum, plusPercentNum1 = df_for_lineplot_diff(dfs, 'Confirmed')\n",
    "\n",
    "\n",
    "# Construct recovered cases dataframe for line plot and 24-hour window case difference\n",
    "df_recovered, plusRecoveredNum, plusPercentNum2 = df_for_lineplot_diff(dfs, 'Recovered')\n",
    "\n",
    "\n",
    "# Construct death case dataframe for line plot and 24-hour window case difference\n",
    "df_deaths, plusDeathNum, plusPercentNum3 = df_for_lineplot_diff(dfs, 'Deaths')\n",
    "\n",
    "# Construct remaining case dataframe for line plot and 24-hour window case difference\n",
    "df_remaining, plusRemainNum, plusRemainNum3 = df_for_lineplot_diff(dfs, 'Remaining')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "confirmedCases=dfs[keyList[0]]['Confirmed'].sum()\n",
    "confirmedCases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create data table to show in app\n",
    "# Generate sum values for Country/Region level\n",
    "dfCase = dfs[keyList[0]].groupby(by='Country/Region', sort=False).sum().reset_index()\n",
    "dfCase = dfCase.sort_values(by=['Confirmed'], ascending=False).reset_index(drop=True)\n",
    "# As lat and lon also underwent sum(), which is not desired, remove from this table.\n",
    "#dfCase = dfCase.drop(columns=['lat','lon'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dfs[keyList[0]].sort_values('Confirmed',ascending=False).groupby(by=['Country/Region']).first().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Grep lat and lon by the first instance to represent its Country/Region\n",
    "#dfGPS = dfs[keyList[0]].groupby(by=['Country/Region'], sort=True).first().reset_index()\n",
    "dfGPS = dfs[keyList[0]].sort_values('Confirmed',ascending=False).groupby(by=['Country/Region']).first().reset_index()\n",
    "dfGPS = dfGPS[['Country/Region','lat','lon']]\n",
    "\n",
    "# Merge two dataframes\n",
    "dfSum = pd.merge(dfCase, dfGPS, how='inner', on='Country/Region')\n",
    "dfSum = dfSum.replace({'Country/Region':'China'}, 'Mainland China')\n",
    "dfSum['Remaining'] = dfSum['Confirmed'] - dfSum['Recovered'] - dfSum['Deaths']\n",
    "# Rearrange columns to correspond to the number plate order\n",
    "dfSum = dfSum[['Country/Region','Remaining','Confirmed','Recovered','Deaths','lat','lon']]\n",
    "# Sort value based on Remaining cases and then Confirmed cases\n",
    "dfSum = dfSum.sort_values(by=['Remaining', 'Confirmed'], ascending=False).reset_index(drop=True)\n",
    "# Set row ids pass to selected_row_ids\n",
    "dfSum['id'] = dfSum['Country/Region']\n",
    "dfSum.set_index('id', inplace=True, drop=False)\n",
    "\n",
    "# Save numbers into variables to use in the app\n",
    "latestDate=datetime.strftime(df_confirmed['Date'][0], '%b %d, %Y %H:%M AEDT')\n",
    "secondLastDate=datetime.strftime(df_confirmed['Date'][1], '%b %d')\n",
    "daysOutbreak=(df_confirmed['Date'][0] - datetime.strptime('12/31/2019', '%m/%d/%Y')).days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#############################################################################################\n",
    "#### Start to make plots\n",
    "#############################################################################################\n",
    "# Line plot for confirmed cases\n",
    "# Set up tick scale based on confirmed case number\n",
    "tickList = list(np.arange(0, df_confirmed['Other locations'].max()+1000, 100000))\n",
    "\n",
    "# Create empty figure canvas\n",
    "fig_confirmed = go.Figure()\n",
    "# Add trace to the figure\n",
    "fig_confirmed.add_trace(go.Scatter(x=df_confirmed['Date'].fillna(''), y=df_confirmed['Mainland China'],\n",
    "                                   mode='lines+markers',\n",
    "                                   line_shape='spline',\n",
    "                                   name='Mainland China',\n",
    "                                   line=dict(color='#921113', width=4),\n",
    "                                   marker=dict(size=4, color='#f4f4f2',\n",
    "                                               line=dict(width=1,color='#921113')),\n",
    "                                   text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_confirmed['Date'].fillna(pd.Timestamp('20200101'))],\n",
    "                                   hovertext=['Mainland China confirmed<br>{:,d} cases<br>'.format(int(i)) for i in df_confirmed['Mainland China'].fillna(0)],\n",
    "                                   hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                 '%{hovertext}'+\n",
    "                                                 '<extra></extra>'))\n",
    "fig_confirmed.add_trace(go.Scatter(x=df_confirmed['Date'].fillna(''), y=df_confirmed['Other locations'],\n",
    "                                   mode='lines+markers',\n",
    "                                   line_shape='spline',\n",
    "                                   name='Other Region',\n",
    "                                   line=dict(color='#eb5254', width=4),\n",
    "                                   marker=dict(size=4, color='#f4f4f2',\n",
    "                                               line=dict(width=1,color='#eb5254')),\n",
    "                                   text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_confirmed['Date'].fillna(pd.Timestamp('20200101'))],\n",
    "                                   hovertext=['Other region confirmed<br>{:,d} cases<br>'.format(int(i)) for i in df_confirmed['Other locations'].fillna(0)],\n",
    "                                   hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                 '%{hovertext}'+\n",
    "                                                 '<extra></extra>'))\n",
    "# Customise layout\n",
    "fig_confirmed.update_layout(\n",
    "#    title=dict(\n",
    "#    text=\"<b>Confirmed Cases Timeline<b>\",\n",
    "#    y=0.96, x=0.5, xanchor='center', yanchor='top',\n",
    "#    font=dict(size=20, color=\"#292929\", family=\"Playfair Display\")\n",
    "#   ),\n",
    "    margin=go.layout.Margin(\n",
    "        l=10,\n",
    "        r=10,\n",
    "        b=10,\n",
    "        t=5,\n",
    "        pad=0\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        showline=False, linecolor='#272e3e',\n",
    "        zeroline=False,\n",
    "        #showgrid=False,\n",
    "        gridcolor='rgba(203, 210, 211,.3)',\n",
    "        gridwidth = .1,\n",
    "        tickmode='array',\n",
    "        # Set tick range based on the maximum number\n",
    "        tickvals=tickList,\n",
    "        # Set tick label accordingly\n",
    "        ticktext=[\"{:.0f}k\".format(i/1000) for i in tickList]\n",
    "    ),\n",
    "#    yaxis_title=\"Total Confirmed Case Number\",\n",
    "    xaxis=dict(\n",
    "        showline=False, linecolor='#272e3e',\n",
    "        showgrid=False,\n",
    "        gridcolor='rgba(203, 210, 211,.3)',\n",
    "        gridwidth = .1,\n",
    "        zeroline=False\n",
    "    ),\n",
    "    xaxis_tickformat='%b %d',\n",
    "    hovermode = 'x',\n",
    "    legend_orientation=\"h\",\n",
    "#    legend=dict(x=.35, y=-.05),\n",
    "    plot_bgcolor='#f4f4f2',\n",
    "    paper_bgcolor='#cbd2d3',\n",
    "    font=dict(color='#292929')\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "UKTable_append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dfs[keyList[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dfs[keyList[0]]=dfs[keyList[0]].append(UKTable_append, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "UKTable_append[UKTable_append['Country/Region']=='UK']['Confirmed'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# Line plot for combine cases\n",
    "# Set up tick scale based on confirmed case number\n",
    "tickList = list(np.arange(0, df_remaining['Total'].max()+2000, 100000))\n",
    "\n",
    "# Create empty figure canvas\n",
    "fig_combine = go.Figure()\n",
    "# Add trace to the figure\n",
    "fig_combine.add_trace(go.Scatter(x=df_recovered['Date'], y=df_recovered['Total'],\n",
    "                                   mode='lines+markers',\n",
    "                                   line_shape='spline',\n",
    "                                   name='Total Recovered Cases',\n",
    "                                   line=dict(color='#168038', width=4),\n",
    "                                   marker=dict(size=4, color='#f4f4f2',\n",
    "                                               line=dict(width=1,color='#168038')),\n",
    "                                   text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_recovered['Date'].fillna(pd.Timestamp('20200101'))],\n",
    "                                   hovertext=['Total recovered<br>{:,d} cases<br>'.format(int(i)) for i in df_recovered['Total'].fillna(0)],\n",
    "                                   hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                 '%{hovertext}'+\n",
    "                                                 '<extra></extra>'))\n",
    "fig_combine.add_trace(go.Scatter(x=df_deaths['Date'].fillna(pd.Timestamp('20200101')), y=df_deaths['Total'].fillna(0),\n",
    "                                mode='lines+markers',\n",
    "                                line_shape='spline',\n",
    "                                name='Total Death Cases',\n",
    "                                line=dict(color='#626262', width=4),\n",
    "                                marker=dict(size=4, color='#f4f4f2',\n",
    "                                            line=dict(width=1,color='#626262')),\n",
    "                                text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_deaths['Date'].fillna(pd.Timestamp('20200101'))],\n",
    "                                hovertext=['Total death<br>{:,d} cases<br>'.format(int(i)) for i in df_deaths['Total'].fillna(0)],\n",
    "                                hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                              '%{hovertext}'+\n",
    "                                              '<extra></extra>'))\n",
    "fig_combine.add_trace(go.Scatter(x=df_remaining['Date'].fillna(pd.Timestamp('20200101')), y=df_remaining['Total'].fillna(0),\n",
    "                                mode='lines+markers',\n",
    "                                line_shape='spline',\n",
    "                                name='Total Remaining Cases',\n",
    "                                line=dict(color='#e36209', width=4),\n",
    "                                marker=dict(size=4, color='#f4f4f2',\n",
    "                                            line=dict(width=1,color='#e36209')),\n",
    "                                text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_deaths['Date'].fillna(pd.Timestamp('20200101'))],\n",
    "                                hovertext=['Total remaining<br>{:,d} cases<br>'.format(int(i)) for i in df_remaining['Total'].fillna(0)],\n",
    "                                hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                              '%{hovertext}'+\n",
    "                                              '<extra></extra>'))\n",
    "\n",
    "# Customise layout\n",
    "fig_combine.update_layout(\n",
    "#    title=dict(\n",
    "#    text=\"<b>Confirmed Cases Timeline<b>\",\n",
    "#    y=0.96, x=0.5, xanchor='center', yanchor='top',\n",
    "#    font=dict(size=20, color=\"#292929\", family=\"Playfair Display\")\n",
    "#   ),\n",
    "    margin=go.layout.Margin(\n",
    "        l=10,\n",
    "        r=10,\n",
    "        b=10,\n",
    "        t=5,\n",
    "        pad=0\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        showline=False, linecolor='#272e3e',\n",
    "        zeroline=False,\n",
    "        #showgrid=False,\n",
    "        gridcolor='rgba(203, 210, 211,.3)',\n",
    "        gridwidth = .1,\n",
    "        tickmode='array',\n",
    "        # Set tick range based on the maximum number\n",
    "        tickvals=tickList,\n",
    "        # Set tick label accordingly\n",
    "        ticktext=[\"{:.0f}k\".format(i/1000) for i in tickList]\n",
    "    ),\n",
    "#    yaxis_title=\"Total Confirmed Case Number\",\n",
    "    xaxis=dict(\n",
    "        showline=False, linecolor='#272e3e',\n",
    "        showgrid=False,\n",
    "        gridcolor='rgba(203, 210, 211,.3)',\n",
    "        gridwidth = .1,\n",
    "        zeroline=False\n",
    "    ),\n",
    "    xaxis_tickformat='%b %d',\n",
    "    hovermode = 'x',\n",
    "    legend_orientation=\"h\",\n",
    "#    legend=dict(x=.35, y=-.05),\n",
    "    plot_bgcolor='#f4f4f2',\n",
    "    paper_bgcolor='#cbd2d3',\n",
    "    font=dict(color='#292929')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "# Line plot for death rate cases\n",
    "# Set up tick scale based on confirmed case number\n",
    "tickList = list(np.arange(0, (df_deaths['Other locations']/df_confirmed['Other locations']*100).max(), 0.5))\n",
    "\n",
    "# Create empty figure canvas\n",
    "fig_rate = go.Figure()\n",
    "# Add trace to the figure\n",
    "fig_rate.add_trace(go.Scatter(x=df_deaths['Date'], y=df_deaths['Mainland China']/df_confirmed['Mainland China']*100,\n",
    "                                mode='lines+markers',\n",
    "                                line_shape='spline',\n",
    "                                name='Mainland China',\n",
    "                                line=dict(color='#626262', width=4),\n",
    "                                marker=dict(size=4, color='#f4f4f2',\n",
    "                                            line=dict(width=1,color='#626262')),\n",
    "                                text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_deaths['Date'].fillna(pd.Timestamp('20200101'))],\n",
    "                                hovertext=['Mainland China death rate<br>{:.2f}%'.format(int(i)) for i in (df_deaths['Mainland China']/df_confirmed['Mainland China']).fillna(0)*100],\n",
    "                                hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                              '%{hovertext}'+\n",
    "                                              '<extra></extra>'))\n",
    "fig_rate.add_trace(go.Scatter(x=df_deaths['Date'], y=df_deaths['Other locations']/df_confirmed['Other locations']*100,\n",
    "                                mode='lines+markers',\n",
    "                                line_shape='spline',\n",
    "                                name='Other Region',\n",
    "                                line=dict(color='#a7a7a7', width=4),\n",
    "                                marker=dict(size=4, color='#f4f4f2',\n",
    "                                            line=dict(width=1,color='#a7a7a7')),\n",
    "                                text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_deaths['Date'].fillna(pd.Timestamp('20200101'))],\n",
    "                                hovertext=['Other region death rate<br>{:.2f}%'.format(int(i)) for i in (df_deaths['Other locations']/df_confirmed['Other locations']).fillna(0)*100],\n",
    "                                hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                              '%{hovertext}'+\n",
    "                                              '<extra></extra>'))\n",
    "\n",
    "# Customise layout\n",
    "fig_rate.update_layout(\n",
    "    margin=go.layout.Margin(\n",
    "        l=10,\n",
    "        r=10,\n",
    "        b=10,\n",
    "        t=5,\n",
    "        pad=0\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        showline=False, linecolor='#272e3e',\n",
    "        zeroline=False,\n",
    "        #showgrid=False,\n",
    "        gridcolor='rgba(203, 210, 211,.3)',\n",
    "        gridwidth = .1,\n",
    "        tickmode='array',\n",
    "        # Set tick range based on the maximum number\n",
    "        tickvals=tickList,\n",
    "        # Set tick label accordingly\n",
    "        ticktext=['{:.1f}'.format(i) for i in tickList]\n",
    "    ),\n",
    "#    yaxis_title=\"Total Confirmed Case Number\",\n",
    "    xaxis=dict(\n",
    "        showline=False, linecolor='#272e3e',\n",
    "        showgrid=False,\n",
    "        gridcolor='rgba(203, 210, 211,.3)',\n",
    "        gridwidth = .1,\n",
    "        zeroline=False\n",
    "    ),\n",
    "    xaxis_tickformat='%b %d',\n",
    "    hovermode = 'x',\n",
    "    legend_orientation=\"h\",\n",
    "#    legend=dict(x=.35, y=-.05),\n",
    "    plot_bgcolor='#f4f4f2',\n",
    "    paper_bgcolor='#cbd2d3',\n",
    "    font=dict(color='#292929')\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read in the beds data to join into the UK table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### TODO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_UK[:]['TotalCases'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "time_series_data_confirmed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Region = 'United Kingdom'\n",
    "df_region = pd.DataFrame(time_series_data_confirmed[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def build_df_region_UK(Locality):\n",
    "    Region = 'United Kingdom'\n",
    "    #if Locality == 'United Kingdom':\n",
    "    #    Locality = 'Derby'\n",
    "    df_region = pd.DataFrame(time_series_data_confirmed[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:])\n",
    "    if len(df_region.columns) > 1:\n",
    "        s = df_region.sum().sort_values(ascending=False, inplace=False)\n",
    "        df_region = pd.DataFrame(df_region[s[:1].index[0]].astype(int))\n",
    "        df_region.columns = ['Confirmed']\n",
    "        df_region_recovered = pd.DataFrame(time_series_data_recovered[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:])\n",
    "        s = df_region_recovered.sum().sort_values(ascending=False, inplace=False)\n",
    "        df_region_recovered = pd.DataFrame(df_region_recovered[s[:1].index[0]].astype(int))\n",
    "        df_region['Recovered'] = df_region_recovered\n",
    "        df_region_deaths = pd.DataFrame(time_series_data_deaths[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:])\n",
    "        s = df_region_deaths.sum().sort_values(ascending=False, inplace=False)\n",
    "        df_region_deaths = pd.DataFrame(df_region_deaths[s[:1].index[0]].astype(int))\n",
    "        df_region['Deaths'] = df_region_deaths\n",
    "    else:\n",
    "        df_region.columns = ['Confirmed']\n",
    "        df_region['Recovered'] = time_series_data_recovered[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:]\n",
    "        df_region['Deaths'] = time_series_data_deaths[time_series_data_confirmed['Country/Region'] == Region].transpose()[4:]\n",
    "    df_region['New'] = df_region['Confirmed'].astype(int).diff().fillna(0)\n",
    "    \n",
    "    list_days = []\n",
    "    for i in range(1,len(df_region['Confirmed'])+1):\n",
    "        list_days.append(df_region['Confirmed'][:i].astype(bool).sum(axis=0))\n",
    "    df_region['DayElapsed'] = list_days\n",
    "    df_region['date_day'] = df_region.index\n",
    "    date_list = []\n",
    "    for date_str in df_region['date_day']:\n",
    "        date_list.append(datetime.strptime(date_str, '%m/%d/%y'))\n",
    "    df_region['Date_last_updated_AEDT'] = date_list\n",
    "    df_region['Date_last_updated_AEDT'] = df_region['Date_last_updated_AEDT'] + timedelta(hours=16)\n",
    "    df_region=df_region.astype({'Date_last_updated_AEDT':'datetime64', 'date_day':'datetime64'})\n",
    "    \n",
    "    if Locality != 'United Kingdom':\n",
    "        percentage_locality = df_UK[df_UK['GSS_NM']==Locality]['TotalCases']/df_UK[:]['TotalCases'].sum()\n",
    "        df_region[['Confirmed','Recovered','Deaths','New']] = (float(percentage_locality) * df_region[['Confirmed','Recovered','Deaths','New']])[['Confirmed','Recovered','Deaths','New']].astype(int)\n",
    "    # only allow real data values\n",
    "    count = 0\n",
    "    for bool_val in df_region['Confirmed']>0:\n",
    "        if bool_val == True:\n",
    "            break\n",
    "        count = count + 1\n",
    "    local_df = df_region[count:]\n",
    "    return local_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Locality = 'United Kingdom'\n",
    "local_df = build_df_region_UK(Locality)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "local_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "today = datetime.today().date()\n",
    "count = 0\n",
    "for datestr in df_region.index:\n",
    "    date = datetime.strptime(datestr,\"%m/%d/%y\").date()\n",
    "    #print((date - today).days)\n",
    "    if (date - today).days == 0:\n",
    "        print(date)\n",
    "        print(today)\n",
    "        break\n",
    "    count = count + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#local_df.ne(0).idxmax()['Confirmed']\n",
    "count = 0\n",
    "for bool_val in local_df.index==local_df.ne(0).idxmax()['Confirmed']:\n",
    "    if bool_val == True:\n",
    "        break\n",
    "    count = count + 1\n",
    "local_df[count:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Region = 'UK'\n",
    "if Region == 'UK':\n",
    "    Region = 'United Kingdom'\n",
    "CaseType = ['Confirmed', 'Recovered', 'Deaths']\n",
    "\n",
    "df_region = build_df_region(Region)\n",
    "df_region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_UK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Locality = 'Derby'\n",
    "if Locality != 'United Kingdom':\n",
    "    percentage_locality = df_UK[df_UK['GSS_NM']==Locality]['TotalCases']/df_UK[:]['TotalCases'].sum()\n",
    "    print(percentage_locality)\n",
    "    #print(df_region[['Confirmed','Recovered','Deaths','New']])\n",
    "    df_region[['Confirmed','Recovered','Deaths','New']] = (float(percentage_locality) * df_region[['Confirmed','Recovered','Deaths','New']])[['Confirmed','Recovered','Deaths','New']].astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "UKTable = df_UK_merged[['GSS_NM','Org Name', 'TotalCases', 'Free Beds INCLUDING COVID-19', 'Predicted Free Beds INCLUDING COVID-19 in 1 WEEK','Free Beds Without COVID-19','count','lat_x', 'lon_x',]].sort_values(by=['Predicted Free Beds INCLUDING COVID-19 in 1 WEEK']).copy()\n",
    "UKTable[['Free Beds INCLUDING COVID-19', 'Predicted Free Beds INCLUDING COVID-19 in 1 WEEK','Free Beds Without COVID-19']] = UKTable[['Free Beds INCLUDING COVID-19', 'Predicted Free Beds INCLUDING COVID-19 in 1 WEEK','Free Beds Without COVID-19']].fillna(0).astype(int)\n",
    "UKTable.rename(columns={\"Free Beds Without COVID-19\" : \"Q1 2019 Free Beds\",\"Free Beds INCLUDING COVID-19\" : \"Q1 2019 Free Bed data with COVID-19 active cases applied at 8.2% Hospitalisation\", \"Predicted Free Beds INCLUDING COVID-19 in 1 WEEK\":\"Predicted Free Beds from Q1 2019 data with forecasted COVID-19 in One Week applied at 8.2% Hospitalisation\", \"lat_x\": \"lat\", \"lon_x\": \"lon\", \"count\": \"Number of Trusts in Region\",\"GSS_NM\": \"Country/Region\",\"Org Name\": \"Trust Name\"}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Set row ids pass to selected_row_ids\n",
    "UKTable['id'] = UKTable['Country/Region']\n",
    "UKTable.set_index('id', inplace=True, drop=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "UKTable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df_UK_merged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "UKTable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# Function for generating cumulative line plot for each Country/Region\n",
    "\n",
    "# Read cumulative data of a given region from ./cumulative_data folder\n",
    "Region = 'UK'\n",
    "CaseType = ['Confirmed', 'Recovered', 'Deaths']\n",
    "\n",
    "df_region = build_df_region(Region)\n",
    "\n",
    "#df_region = pd.read_csv('./cumulative_data/{}.csv'.format(Region))\n",
    "#df_region=df_region.astype({'Date_last_updated_AEDT':'datetime64', 'date_day':'datetime64'})\n",
    "\n",
    "# Line plot for confirmed cases\n",
    "# Set up tick scale based on confirmed case number\n",
    "#tickList = list(np.arange(0, df_confirmed['Mainland China'].max()+1000, 10000))\n",
    "\n",
    "# Create empty figure canvas\n",
    "fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n",
    "#fig = go.Figure()\n",
    "#fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n",
    "# Add trace to the figure\n",
    "fig.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                         y=df_region['Confirmed'],\n",
    "                         mode='lines+markers',\n",
    "                         #line_shape='spline',\n",
    "                         name='Confirmed case',\n",
    "                         line=dict(color='#d7191c', width=2),\n",
    "                         #marker=dict(size=4, color='#f4f4f2',\n",
    "                         #            line=dict(width=1,color='#921113')),\n",
    "                         text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                         hovertext=['{} confirmed<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Confirmed']],\n",
    "                         hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                 '%{hovertext}'+\n",
    "                                                 '<extra></extra>'),\n",
    "                         secondary_y=False,\n",
    "             )\n",
    "fig.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                         y=df_region['Recovered'],\n",
    "                         mode='lines+markers',\n",
    "                         #line_shape='spline',\n",
    "                         name='Recovered case',\n",
    "                         line=dict(color='#1a9622', width=2),                         \n",
    "                         #marker=dict(size=4, color='#f4f4f2',\n",
    "                         #            line=dict(width=1,color='#168038')),\n",
    "                         text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                         hovertext=['{} Recovered<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Recovered']],\n",
    "                         hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                 '%{hovertext}'+\n",
    "                                                 '<extra></extra>'),\n",
    "                         secondary_y=False,\n",
    "             )\n",
    "fig.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                         y=df_region['Deaths'],\n",
    "                         mode='lines+markers',\n",
    "                         #line_shape='spline',\n",
    "                         name='Death case',\n",
    "                         line=dict(color='#626262', width=2),\n",
    "                         #marker=dict(size=4, color='#f4f4f2',\n",
    "                         #            line=dict(width=1,color='#626262')),\n",
    "                         text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                         hovertext=['{} Deaths<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Deaths']],\n",
    "                         hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                 '%{hovertext}'+\n",
    "                                                 '<extra></extra>'),\n",
    "                         secondary_y=False,\n",
    "             )\n",
    "\n",
    "fig.add_trace(go.Bar(x=df_region['date_day'], \n",
    "                     y=df_region['New'],\n",
    "                         #mode='lines+markers',\n",
    "                         #line_shape='spline',\n",
    "                     name='Daily New Cases',\n",
    "                     marker_color='#626262',\n",
    "                     opacity = .3,\n",
    "                         #marker=dict(size=4, color='#f4f4f2',\n",
    "                         #            line=dict(width=1,color='#626262')),\n",
    "                     text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                     hovertext=['{} New<br>{} cases<br>'.format(Region, i) for i in df_region['New']],\n",
    "                     hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                              '%{hovertext}'+\n",
    "                                              '<extra></extra>'\n",
    "                    ),\n",
    "                     secondary_y=True,\n",
    "             )\n",
    "\n",
    "# Customise layout\n",
    "fig.update_layout(\n",
    "    #title=dict(\n",
    "    #    text=\"<b>Confirmed Cases Timeline<b>\",\n",
    "    #    y=0.96, x=0.5, xanchor='center', yanchor='top',\n",
    "    #    font=dict(size=20, color=\"#292929\", family=\"Playfair Display\")\n",
    "    #),\n",
    "    margin=go.layout.Margin(\n",
    "            l=0,\n",
    "            r=10,\n",
    "            b=0,\n",
    "            t=10,\n",
    "            pad=0\n",
    "        ),\n",
    "    annotations=[\n",
    "        dict(x=.5,\n",
    "             y=.4,\n",
    "             xref=\"paper\",\n",
    "             yref=\"paper\",\n",
    "             text=Region,\n",
    "             opacity=0.5,\n",
    "             font=dict(family='Arial, sans-serif',\n",
    "                       size=60,\n",
    "                       color=\"grey\"),\n",
    "        )\n",
    "    ],\n",
    "    yaxis=dict(showline=False, linecolor='#272e3e',\n",
    "               zeroline=False,\n",
    "               rangemode=\"tozero\",\n",
    "               #automargin=True,\n",
    "               #showgrid=False,\n",
    "               gridcolor='rgba(203, 210, 211,.3)',\n",
    "               gridwidth = .1,\n",
    "               mirror=True,\n",
    "               #tickmode='array',\n",
    "               # Set tick range based on the maximum number\n",
    "               #tickvals=tickList,\n",
    "               # Set tick label accordingly\n",
    "               #ticktext=[\"{:.0f}k\".format(i/1000) for i in tickList]\n",
    "    ),\n",
    "    yaxis2=dict(showline=False, linecolor='#272e3e',\n",
    "                zeroline=False,\n",
    "                #showgrid=False,\n",
    "                #automargin=True,\n",
    "                #range=[-1, max(df_region['New'])+100],\n",
    "                #fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n",
    "                rangemode=\"tozero\",\n",
    "                mirror=True,\n",
    "                gridcolor='rgba(203, 210, 211,.3)',\n",
    "                gridwidth = .1,\n",
    "                #tickmode='array',\n",
    "                #anchor=\"free\",\n",
    "                #overlaying=\"y\",\n",
    "                #side=\"right\",\n",
    "                #position=0.15\n",
    "    ),\n",
    "    xaxis_title=\"Cumulative Cases (Select Country/Region From Table)\",\n",
    "    xaxis=dict(showline=False, linecolor='#272e3e',\n",
    "               showgrid=False,\n",
    "               gridcolor='rgba(203, 210, 211,.3)',\n",
    "               gridwidth = .1,\n",
    "               zeroline=False,\n",
    "               automargin=True,\n",
    "    ),\n",
    "    xaxis_tickformat='%b %d',\n",
    "    #transition = {'duration':500},\n",
    "    hovermode = 'x',\n",
    "    legend_orientation=\"v\",\n",
    "    legend=dict(x=.02, y=.95, bgcolor=\"rgba(0,0,0,0)\",),\n",
    "    plot_bgcolor='#f4f4f2',\n",
    "    paper_bgcolor='#cbd2d3',\n",
    "    font=dict(color='#292929')\n",
    "    )\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def logistic_model(x,a,b,c):\n",
    "    return c/(1+np.exp(-(x-b)/a))\n",
    "\n",
    "def exponential_model(x,a,b,c):\n",
    "    return a*np.exp(b*(x-c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "derived_virtual_selected_rows = ['United Kingdom']\n",
    "selected_row_ids = [6]\n",
    "\n",
    "dff = dfSum\n",
    "\n",
    "mapbox_access_token = \"pk.eyJ1IjoicGxvdGx5bWFwYm94IiwiYSI6ImNqdnBvNDMyaTAxYzkzeW5ubWdpZ2VjbmMifQ.TXcBE-xg9BFdV2ocecc_7g\"\n",
    "\n",
    "# Generate a list for hover text display\n",
    "textList=[]\n",
    "for area, region in zip(dfs[keyList[0]]['Province/State'], dfs[keyList[0]]['Country/Region']):\n",
    "    region = str(region)\n",
    "    if type(area) is str:\n",
    "        if region == \"Hong Kong\" or region == \"Macau\" or region == \"Taiwan\":\n",
    "            textList.append(area)\n",
    "        else:\n",
    "            #print(region)\n",
    "            textList.append(area+', '+region)\n",
    "    else:\n",
    "        textList.append(region)\n",
    "# Generate a list for color gradient display\n",
    "colorList=[]\n",
    "\n",
    "for confirmed, recovered, deaths in zip(dfs[keyList[0]]['Confirmed'],dfs[keyList[0]]['Recovered'],dfs[keyList[0]]['Deaths']):\n",
    "    remaining = confirmed - deaths - recovered\n",
    "    colorList.append(remaining)\n",
    "\n",
    "\n",
    "fig2 = go.Figure(go.Scattermapbox(\n",
    "    lat=dfs[keyList[0]]['lat'],\n",
    "    lon=dfs[keyList[0]]['lon'],\n",
    "    mode='markers',\n",
    "    marker=go.scattermapbox.Marker(\n",
    "        color=['#d7191c' if i > 0 else '#1a9622' for i in colorList],\n",
    "        size=[i**(1/3) for i in dfs[keyList[0]]['Confirmed']], \n",
    "        sizemin=1,\n",
    "        sizemode='area',\n",
    "        sizeref=2.*max([math.sqrt(i) for i in dfs[keyList[0]]['Confirmed']])/(100.**2),\n",
    "    ),\n",
    "    text=textList,\n",
    "    hovertext=['Confirmed: {}<br>Recovered: {}<br>Death: {}'.format(i, j, k) for i, j, k in zip(dfs[keyList[0]]['Confirmed'],\n",
    "                                                                                                dfs[keyList[0]]['Recovered'],\n",
    "                                                                                                dfs[keyList[0]]['Deaths'])],\n",
    "    hovertemplate = \"<b>%{text}</b><br><br>\" +\n",
    "                    \"%{hovertext}<br>\" +\n",
    "                    \"<extra></extra>\")\n",
    ")\n",
    "fig2.update_layout(\n",
    "    plot_bgcolor='#151920',\n",
    "    paper_bgcolor='#cbd2d3',\n",
    "    margin=go.layout.Margin(l=10,r=10,b=10,t=0,pad=40),\n",
    "    hovermode='closest',\n",
    "    transition = {'duration':50},\n",
    "    annotations=[\n",
    "    dict(\n",
    "        x=.5,\n",
    "        y=-.01,\n",
    "        align='center',\n",
    "        showarrow=False,\n",
    "        text=\"Points are placed based on data geolocation levels.<br><b>Province/State level<b> - China, Australia, United States, and Canada; <b>Country level<b> - other countries.\",\n",
    "        xref=\"paper\",\n",
    "        yref=\"paper\",\n",
    "        font=dict(size=10, color='#292929'),\n",
    "    )],\n",
    "    mapbox=go.layout.Mapbox(\n",
    "        accesstoken=mapbox_access_token,\n",
    "        style=\"light\",\n",
    "        # The direction you're facing, measured clockwise as an angle from true north on a compass\n",
    "        bearing=0,\n",
    "        center=go.layout.mapbox.Center(\n",
    "            lat=14.056159 if len(derived_virtual_selected_rows)==0 else dff.iloc[selected_row_ids[0]].lat, \n",
    "            lon=22.920039 if len(derived_virtual_selected_rows)==0 else dff.iloc[selected_row_ids[0]].lon\n",
    "        ),\n",
    "        pitch=0,\n",
    "        zoom=1.03 if len(derived_virtual_selected_rows)==0 else 4\n",
    "    )\n",
    ")\n",
    "fig2.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##################################################################################################\n",
    "#### Start dash app\n",
    "##################################################################################################\n",
    "\n",
    "app = dash.Dash(__name__, \n",
    "                assets_folder='../assets/',\n",
    "                meta_tags=[\n",
    "                    {\"name\": \"author\", \"content\": \"Jonathan McKinnell and Jun Ye\"},\n",
    "                    {\"name\": \"description\", \"content\": \"The coronavirus COVID-19 monitor provides up-to-date data for the global spread of coronavirus.\"},\n",
    "                    {\"property\": \"og:title\", \"content\": \"Coronavirus COVID-19 Outbreak Global Cases Monitor\"},\n",
    "                    {\"name\": \"viewport\", \"content\": \"width=device-width, height=device-height, initial-scale=1.0\"}\n",
    "                ]\n",
    "      )\n",
    "\n",
    "app.title = 'Coronavirus COVID-19 Global Monitor'\n",
    "server = app.server\n",
    "\n",
    "app.layout = html.Div(style={'backgroundColor':'#f4f4f2'},\n",
    "    children=[\n",
    "        html.Div(\n",
    "            id=\"header\",\n",
    "            children=[                          \n",
    "                html.H4(children=\"Coronavirus (COVID-19) Outbreak Global Cases Monitor\"),\n",
    "                html.P(\n",
    "                    id=\"description\",\n",
    "                    children=\"On Dec 31, 2019, the World Health Organization (WHO) was informed of \\\n",
    "                    an outbreak of “pneumonia of unknown cause” detected in Wuhan City, Hubei Province, China – the \\\n",
    "                    seventh-largest city in China with 11 million residents. As of {}, there are over {:,d} cases \\\n",
    "                    of COVID-19 confirmed globally. This dash board is developed to visualise and track the recent reported \\\n",
    "                    cases on an hourly timescale. New feature added - click on UK tab in Cases by Country and you can see the Free Bed forecasting for NHS Trusts in England. \\\n",
    "                    For the UK free bed forecasting NHS Q1 2019 data was used as a baseline before forecasting the number of COVID-19 cases from the current data in the UK \\\n",
    "                    then trying to predict the current number of free beds in England NHS trusts \\\n",
    "                    and then forecast the current number of beds in 1 week based on an Imperial College study of an estimated 8.2% hospitalisation rate. \\\n",
    "                    Important note: Please note that the case forecasting model and the bed forecasting model is experimental and not yet validated (as cases have not yet arrived since the model is being developed as the pandemic unfolds). The model is only as good as its assumptions and starting data both of which are likely to have limitations, especially this early in the pandemic and therefore it should not be used for clinical decision making. \\\n",
    "                    Open Source code available in python: https://github.com/jonathanmckinnell/COVID-19-forecasting-dashboard\".format(latestDate, int(confirmedCases)),\n",
    "                ),\n",
    "                html.P(\n",
    "                  id='time-stamp',\n",
    "                       children=\"🔴 Last updated on {}. (Sorry, the app server may experince short period of interruption while updating data)\".format(latestDate))\n",
    "                    ]        \n",
    "                ),\n",
    "        html.Div(\n",
    "            id=\"number-plate\",\n",
    "            style={'marginLeft':'1.5%','marginRight':'1.5%','marginBottom':'.5%'},\n",
    "                 children=[\n",
    "                     html.Div(\n",
    "                         style={'width':'24.4%','backgroundColor':'#cbd2d3','display':'inline-block',\n",
    "                                'marginRight':'.8%','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H3(style={'textAlign':'center',\n",
    "                                                 'fontWeight':'bold','color':'#2674f6'},\n",
    "                                               children=[\n",
    "                                                   html.P(style={'color':'#cbd2d3','padding':'.5rem'},\n",
    "                                                              children='xxxx xx xxx xxxx xxx xxxxx'),\n",
    "                                                   '{}'.format(daysOutbreak),\n",
    "                                               ]),\n",
    "                                  html.H5(style={'textAlign':'center','color':'#2674f6','padding':'.1rem'},\n",
    "                                               children=\"Days Since Outbreak\")                                        \n",
    "                                       ]),\n",
    "                     html.Div(\n",
    "                         style={'width':'24.4%','backgroundColor':'#cbd2d3','display':'inline-block',\n",
    "                                'marginRight':'.8%','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H3(style={'textAlign':'center',\n",
    "                                                 'fontWeight':'bold','color':'#d7191c'},\n",
    "                                                children=[\n",
    "                                                    html.P(style={'padding':'.5rem'},\n",
    "                                                              children='+ {:,d} in the past 24h ({:.1%})'.format(int(plusConfirmedNum), plusPercentNum1)),\n",
    "                                                    '{:,d}'.format(int(confirmedCases))\n",
    "                                                         ]),\n",
    "                                  html.H5(style={'textAlign':'center','color':'#d7191c','padding':'.1rem'},\n",
    "                                               children=\"Confirmed Cases\")                                        \n",
    "                                       ]),\n",
    "                     html.Div(\n",
    "                         style={'width':'24.4%','backgroundColor':'#cbd2d3','display':'inline-block',\n",
    "                                'marginRight':'.8%','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H3(style={'textAlign':'center',\n",
    "                                                       'fontWeight':'bold','color':'#1a9622'},\n",
    "                                               children=[\n",
    "                                                   html.P(style={'padding':'.5rem'},\n",
    "                                                              children='+ {:,d} in the past 24h ({:.1%})'.format(plusRecoveredNum, plusPercentNum2)),\n",
    "                                                   '{:,d}'.format(int(recoveredCases)),\n",
    "                                               ]),\n",
    "                                  html.H5(style={'textAlign':'center','color':'#1a9622','padding':'.1rem'},\n",
    "                                               children=\"Recovered Cases\")                                        \n",
    "                                       ]),\n",
    "                     html.Div(\n",
    "                         style={'width':'24.4%','backgroundColor':'#cbd2d3','display':'inline-block',\n",
    "                                'verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H3(style={'textAlign':'center',\n",
    "                                                       'fontWeight':'bold','color':'#6c6c6c'},\n",
    "                                                children=[\n",
    "                                                    html.P(style={'padding':'.5rem'},\n",
    "                                                              children='+ {:,d} in the past 24h ({:.1%})'.format(plusDeathNum, plusPercentNum3)),\n",
    "                                                    '{:,d}'.format(int(deathsCases))\n",
    "                                                ]),\n",
    "                                  html.H5(style={'textAlign':'center','color':'#6c6c6c','padding':'.1rem'},\n",
    "                                               children=\"Death Cases\")                                        \n",
    "                                       ])\n",
    "                          ]),\n",
    "        html.Div(\n",
    "            id='dcc-plot',\n",
    "            style={'marginLeft':'1.5%','marginRight':'1.5%','marginBottom':'.35%','marginTop':'.5%'},\n",
    "                 children=[\n",
    "                     html.Div(\n",
    "                         style={'width':'32.79%','display':'inline-block','marginRight':'.8%','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H5(style={'textAlign':'center','backgroundColor':'#cbd2d3',\n",
    "                                                 'color':'#292929','padding':'1rem','marginBottom':'0'},\n",
    "                                               children='Confirmed Case Timeline'),\n",
    "                                  dcc.Graph(style={'height':'300px'},figure=fig_confirmed)]),\n",
    "                     html.Div(\n",
    "                         style={'width':'32.79%','display':'inline-block','marginRight':'.8%','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H5(style={'textAlign':'center','backgroundColor':'#cbd2d3',\n",
    "                                                 'color':'#292929','padding':'1rem','marginBottom':'0'},\n",
    "                                               children='Recovered/Death Case Timeline'),\n",
    "                                  dcc.Graph(style={'height':'300px'},figure=fig_combine)]),\n",
    "                     html.Div(\n",
    "                         style={'width':'32.79%','display':'inline-block','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H5(style={'textAlign':'center','backgroundColor':'#cbd2d3',\n",
    "                                                 'color':'#292929','padding':'1rem','marginBottom':'0'},\n",
    "                                               children='Death Rate (%) Timeline'),\n",
    "                                  dcc.Graph(style={'height':'300px'},figure=fig_rate)])]),\n",
    "        html.Div(\n",
    "            id='dcc-map',\n",
    "            style={'marginLeft':'1.5%','marginRight':'1.5%','marginBottom':'.5%'},\n",
    "                 children=[\n",
    "                     html.Div(style={'width':'66.41%','marginRight':'.8%','display':'inline-block','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H5(style={'textAlign':'center','backgroundColor':'#cbd2d3',\n",
    "                                                 'color':'#292929','padding':'1rem','marginBottom':'0'},\n",
    "                                               children='Latest Coronavirus Outbreak Map'),\n",
    "                                  dcc.Graph(\n",
    "                                      id='datatable-interact-map',\n",
    "                                      style={'height':'500px'},),\n",
    "                                  dcc.Graph(\n",
    "                                      id='datatable-interact-lineplot',\n",
    "                                      style={'height':'300px'},),\n",
    "                                  dcc.Graph(\n",
    "                                      id='datatable-interact-lineplot-uk',\n",
    "                                      style={'height':'300px'},),\n",
    "                              ]),\n",
    "                     html.Div(style={'width':'32.79%','display':'inline-block','verticalAlign':'top'},\n",
    "                              children=[\n",
    "                                  html.H5(style={'textAlign':'center','backgroundColor':'#cbd2d3',\n",
    "                                                 'color':'#292929','padding':'1rem','marginBottom':'0'},\n",
    "                                               children='Cases by Country/Region'),\n",
    "                                  dcc.Tabs(\n",
    "                                        value='tab-1',\n",
    "                                        parent_className='custom-tabs',\n",
    "                                        className='custom-tabs-container',\n",
    "                                        children=[\n",
    "                                            dcc.Tab(label='The World',\n",
    "                                                    value='tab-1',\n",
    "                                                className='custom-tab',\n",
    "                                                selected_className='custom-tab--selected',\n",
    "                                                children=[                                                    \n",
    "                                                    dash_table.DataTable(\n",
    "                                                        id='datatable-interact-location',\n",
    "                                                        # Don't show coordinates\n",
    "                                                        columns=[{\"name\": i, \"id\": i} for i in dfSum.columns[0:5]],\n",
    "                                                        # But still store coordinates in the table for interactivity\n",
    "                                                        data=dfSum.to_dict(\"rows\"),\n",
    "                                                        row_selectable=\"single\",\n",
    "                                                        sort_action=\"native\",\n",
    "                                                        style_as_list_view=True,\n",
    "                                                        style_cell={'font_family':'Arial',\n",
    "                                                                    'font_size':'1.2rem',\n",
    "                                                                    'padding':'.1rem',\n",
    "                                                                    'backgroundColor':'#f4f4f2',},\n",
    "                                                        fixed_rows={'headers':True,'data':0},\n",
    "                                                        style_table={'minHeight': '1050px', \n",
    "                                                                     'height': '1050px', \n",
    "                                                                     'maxHeight': '1050px'\n",
    "                                                                    #'Height':'300px',\n",
    "                                                                    #'overflowY':'scroll',\n",
    "                                                                    #'overflowX':'scroll',\n",
    "                                                                    },\n",
    "                                                        style_header={'backgroundColor':'#f4f4f2',\n",
    "                                                                      'fontWeight':'bold'},\n",
    "                                                        style_cell_conditional=[{'if': {'column_id':'Country/Regions'},'width':'28%'},\n",
    "                                                                                {'if': {'column_id':'Remaining'},'width':'18%'},\n",
    "                                                                                {'if': {'column_id':'Confirmed'},'width':'18%'},\n",
    "                                                                                {'if': {'column_id':'Recovered'},'width':'18%'},\n",
    "                                                                                {'if': {'column_id':'Deaths'},'width':'18%'},\n",
    "                                                                                {'if': {'column_id':'Confirmed'},'color':'#d7191c'},\n",
    "                                                                                {'if': {'column_id':'Recovered'},'color':'#1a9622'},\n",
    "                                                                                {'if': {'column_id':'Deaths'},'color':'#6c6c6c'},\n",
    "                                                                                {'textAlign': 'center'}],\n",
    "                                                    )\n",
    "                                        ]),\n",
    "                                        dcc.Tab(label='Australia',\n",
    "                                                className='custom-tab',\n",
    "                                                selected_className='custom-tab--selected',\n",
    "                                                children=[\n",
    "                                            dash_table.DataTable(\n",
    "                                                #id='datatable-interact-location-aus',\n",
    "                                                # Don't show coordinates\n",
    "                                                columns=[{\"name\": i, \"id\": i} for i in AUSTable.columns[0:5]],\n",
    "                                                # But still store coordinates in the table for interactivity\n",
    "                                                data=AUSTable.to_dict(\"rows\"),\n",
    "                                                #row_selectable=\"single\",\n",
    "                                                sort_action=\"native\",\n",
    "                                                style_as_list_view=True,\n",
    "                                                style_cell={'font_family':'Arial',\n",
    "                                                            'font_size':'1.2rem',\n",
    "                                                            'padding':'.1rem',\n",
    "                                                            'backgroundColor':'#f4f4f2',},\n",
    "                                                fixed_rows={'headers':True,'data':0},\n",
    "                                                style_table={'minHeight': '1050px', \n",
    "                                                             'height': '1050px', \n",
    "                                                             'maxHeight': '1050px'\n",
    "                                                            #'Height':'300px',\n",
    "                                                            #'overflowY':'scroll',\n",
    "                                                            #'overflowX':'scroll',\n",
    "                                                            },\n",
    "                                                style_header={'backgroundColor':'#f4f4f2',\n",
    "                                                              'fontWeight':'bold'},\n",
    "                                                style_cell_conditional=[{'if': {'column_id':'Province/State'},'width':'28%'},\n",
    "                                                                        {'if': {'column_id':'Remaining'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'color':'#d7191c'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'color':'#1a9622'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'color':'#6c6c6c'},\n",
    "                                                                        {'textAlign': 'center'}],\n",
    "                                            )\n",
    "                                        ]),\n",
    "                                        dcc.Tab(label='UK', \n",
    "                                                className='custom-tab',\n",
    "                                                #value='tab-2',\n",
    "                                                selected_className='custom-tab--selected',\n",
    "                                                children=[\n",
    "                                            dash_table.DataTable(\n",
    "                                                id='datatable-interact-location-uk',\n",
    "                                                # Don't show coordinates\n",
    "                                                columns=[{\"name\": i, \"id\": i} for i in UKTable.columns[:-3]],\n",
    "                                                # But still store coordinates in the table for interactivity\n",
    "                                                data=UKTable.to_dict(\"rows\"),\n",
    "                                                row_selectable=\"single\",\n",
    "                                                sort_action=\"native\",\n",
    "                                                style_as_list_view=True,\n",
    "                                                style_cell={'height': 'auto',\n",
    "                                                            # all three widths are needed\n",
    "                                                            'minWidth': '40px', 'width': '120px', 'maxWidth': '180px',\n",
    "                                                            'whiteSpace': 'normal',\n",
    "                                                            'font_family':'Arial',\n",
    "                                                            'font_size':'1.2rem',\n",
    "                                                            'padding':'.1rem',\n",
    "                                                            'backgroundColor':'#f4f4f2',},\n",
    "                                                fixed_rows={'headers':True,'data':0},\n",
    "                                                style_table={'minHeight': '1050px', \n",
    "                                                             'height': '1050px', \n",
    "                                                             'maxHeight': '1050px',\n",
    "                                                             #'width':'500px',\n",
    "                                                             #'minWidth': '100px',\n",
    "                                                            #'overflowY':'scroll',\n",
    "                                                             'overflowX':'scroll'\n",
    "                                                            },\n",
    "                                                style_header={'backgroundColor':'#f4f4f2',\n",
    "                                                              'fontWeight':'bold'},\n",
    "                                                style_cell_conditional=[{'if': {'column_id':'Province/State'},'width':'28%'},\n",
    "                                                                        {'if': {'column_id':'Remaining'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'color':'#d7191c'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'color':'#1a9622'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'color':'#6c6c6c'},\n",
    "                                                                        {'textAlign': 'center'}],\n",
    "                                            )\n",
    "                                        ]),\n",
    "                                        dcc.Tab(label='Canada', \n",
    "                                                className='custom-tab',\n",
    "                                                selected_className='custom-tab--selected',\n",
    "                                                children=[\n",
    "                                            dash_table.DataTable(\n",
    "                                                \n",
    "                                                # Don't show coordinates\n",
    "                                                columns=[{\"name\": i, \"id\": i} for i in CANTable.columns[0:5]],\n",
    "                                                # But still store coordinates in the table for interactivity\n",
    "                                                data=CANTable.to_dict(\"rows\"),\n",
    "                                                #row_selectable=\"single\",\n",
    "                                                sort_action=\"native\",\n",
    "                                                style_as_list_view=True,\n",
    "                                                style_cell={'font_family':'Arial',\n",
    "                                                            'font_size':'1.2rem',\n",
    "                                                            'padding':'.1rem',\n",
    "                                                            'backgroundColor':'#f4f4f2',},\n",
    "                                                fixed_rows={'headers':True,'data':0},\n",
    "                                                style_table={'minHeight': '1050px', \n",
    "                                                             'height': '1050px', \n",
    "                                                             'maxHeight': '1050px'\n",
    "                                                            #'Height':'300px',\n",
    "                                                            #'overflowY':'scroll',\n",
    "                                                            #'overflowX':'scroll',\n",
    "                                                            },\n",
    "                                                style_header={'backgroundColor':'#f4f4f2',\n",
    "                                                              'fontWeight':'bold'},\n",
    "                                                style_cell_conditional=[{'if': {'column_id':'Province/State'},'width':'28%'},\n",
    "                                                                        {'if': {'column_id':'Remaining'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'color':'#d7191c'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'color':'#1a9622'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'color':'#6c6c6c'},\n",
    "                                                                        {'textAlign': 'center'}],\n",
    "                                            )\n",
    "                                        ]),\n",
    "                                      dcc.Tab(label='Mainland China', \n",
    "                                              className='custom-tab',\n",
    "                                              selected_className='custom-tab--selected',\n",
    "                                              children=[\n",
    "                                              dash_table.DataTable(\n",
    "                                                \n",
    "                                                # Don't show coordinates\n",
    "                                                columns=[{\"name\": i, \"id\": i} for i in CNTable.columns[0:5]],\n",
    "                                                # But still store coordinates in the table for interactivity\n",
    "                                                data=CNTable.to_dict(\"rows\"),\n",
    "                                                #row_selectable=\"single\",\n",
    "                                                sort_action=\"native\",\n",
    "                                                style_as_list_view=True,\n",
    "                                                style_cell={'font_family':'Arial',\n",
    "                                                            'font_size':'1.2rem',\n",
    "                                                            'padding':'.1rem',\n",
    "                                                            'backgroundColor':'#f4f4f2',},\n",
    "                                                fixed_rows={'headers':True,'data':0},\n",
    "                                                style_table={'minHeight': '1050px', \n",
    "                                                             'height': '1050px', \n",
    "                                                             'maxHeight': '1050px'\n",
    "                                                            #'Height':'300px',\n",
    "                                                            #'overflowY':'scroll',\n",
    "                                                            #'overflowX':'scroll',\n",
    "                                                            },\n",
    "                                                style_header={'backgroundColor':'#f4f4f2',\n",
    "                                                              'fontWeight':'bold'},\n",
    "                                                style_cell_conditional=[{'if': {'column_id':'Province/State'},'width':'28%'},\n",
    "                                                                        {'if': {'column_id':'Remaining'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'color':'#d7191c'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'color':'#1a9622'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'color':'#6c6c6c'},\n",
    "                                                                        {'textAlign': 'center'}],\n",
    "                                            )\n",
    "                                        ]),\n",
    "                                      dcc.Tab(label='United States', \n",
    "                                              className='custom-tab',\n",
    "                                              selected_className='custom-tab--selected',\n",
    "                                              children=[\n",
    "                                              dash_table.DataTable(\n",
    "                                                \n",
    "                                                # Don't show coordinates\n",
    "                                                columns=[{\"name\": i, \"id\": i} for i in USTable.columns[0:5]],\n",
    "                                                # But still store coordinates in the table for interactivity\n",
    "                                                data=USTable.to_dict(\"rows\"),\n",
    "                                                #row_selectable=\"single\",\n",
    "                                                sort_action=\"native\",\n",
    "                                                style_as_list_view=True,\n",
    "                                                style_cell={'font_family':'Arial',\n",
    "                                                            'font_size':'1.2rem',\n",
    "                                                            'padding':'.1rem',\n",
    "                                                            'backgroundColor':'#f4f4f2',},\n",
    "                                                fixed_rows={'headers':True,'data':0},\n",
    "                                                style_table={'minHeight': '1050px', \n",
    "                                                             'height': '1050px', \n",
    "                                                             'maxHeight': '1050px'\n",
    "                                                            #'Height':'300px',\n",
    "                                                            #'overflowY':'scroll',\n",
    "                                                            #'overflowX':'scroll',\n",
    "                                                            },\n",
    "                                                style_header={'backgroundColor':'#f4f4f2',\n",
    "                                                              'fontWeight':'bold'},\n",
    "                                                style_cell_conditional=[{'if': {'column_id':'Province/State'},'width':'28%'},\n",
    "                                                                        {'if': {'column_id':'Remaining'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'width':'18%'},\n",
    "                                                                        {'if': {'column_id':'Confirmed'},'color':'#d7191c'},\n",
    "                                                                        {'if': {'column_id':'Recovered'},'color':'#1a9622'},\n",
    "                                                                        {'if': {'column_id':'Deaths'},'color':'#6c6c6c'},\n",
    "                                                                        {'textAlign': 'center'}],\n",
    "                                            )\n",
    "                                        ]),]\n",
    "                                    )\n",
    "                              ])\n",
    "                 ]),\n",
    "        html.Div(\n",
    "          id='my-footer',\n",
    "          style={'marginLeft':'1.5%','marginRight':'1.5%'},\n",
    "                 children=[\n",
    "                     html.P(style={'textAlign':'center','margin':'auto'},\n",
    "                            children=[\" Case forecasting by Jonathan McKinnell in the UK |\",\n",
    "                                      \" Dashboard developed by \",html.A('Jun', href='https://junye0798.com/'),\" in Sydney\"])]),\n",
    "        ])\n",
    "\n",
    "@app.callback(\n",
    "    Output('datatable-interact-map', 'figure'),\n",
    "    [Input('datatable-interact-location', 'derived_virtual_selected_rows'),\n",
    "     Input('datatable-interact-location', 'selected_row_ids')]\n",
    ")\n",
    "\n",
    "def update_figures(derived_virtual_selected_rows, selected_row_ids):\n",
    "    print(selected_row_ids)\n",
    "    print(derived_virtual_selected_rows)\n",
    "    # When the table is first rendered, `derived_virtual_data` and\n",
    "    # `derived_virtual_selected_rows` will be `None`. This is due to an\n",
    "    # idiosyncracy in Dash (unsupplied properties are always None and Dash\n",
    "    # calls the dependent callbacks when the component is first rendered).\n",
    "    # So, if `rows` is `None`, then the component was just rendered\n",
    "    # and its value will be the same as the component's dataframe.\n",
    "    # Instead of setting `None` in here, you could also set\n",
    "    # `derived_virtual_data=df.to_rows('dict')` when you initialize\n",
    "    # the component.\n",
    "        \n",
    "    if derived_virtual_selected_rows is None:\n",
    "        derived_virtual_selected_rows = []\n",
    "        \n",
    "    dff = dfSum\n",
    "        \n",
    "    mapbox_access_token = \"pk.eyJ1IjoicGxvdGx5bWFwYm94IiwiYSI6ImNqdnBvNDMyaTAxYzkzeW5ubWdpZ2VjbmMifQ.TXcBE-xg9BFdV2ocecc_7g\"\n",
    "\n",
    "    # Generate a list for hover text display\n",
    "    textList=[]\n",
    "    for area, region in zip(dfs[keyList[0]]['Province/State'], dfs[keyList[0]]['Country/Region']):\n",
    "        region = str(region)\n",
    "        if type(area) is str:\n",
    "            if region == \"Hong Kong\" or region == \"Macau\" or region == \"Taiwan\":\n",
    "                textList.append(area)\n",
    "            else:\n",
    "                #print(region)\n",
    "                textList.append(area+', '+region)\n",
    "        else:\n",
    "            textList.append(region)\n",
    "            \n",
    "    # Generate a list for color gradient display\n",
    "    colorList=[]\n",
    "\n",
    "    for comfirmed, recovered, deaths in zip(dfs[keyList[0]]['Confirmed'],dfs[keyList[0]]['Recovered'],dfs[keyList[0]]['Deaths']):\n",
    "        remaining = comfirmed - deaths - recovered\n",
    "        colorList.append(remaining)\n",
    "\n",
    "    fig2 = go.Figure(go.Scattermapbox(\n",
    "        lat=dfs[keyList[0]]['lat'],\n",
    "        lon=dfs[keyList[0]]['lon'],\n",
    "        mode='markers',\n",
    "        marker=go.scattermapbox.Marker(\n",
    "            color=['#d7191c' if i > 0 else '#1a9622' for i in colorList],\n",
    "            size=[i**(1/3) for i in dfs[keyList[0]]['Confirmed']], \n",
    "            sizemin=1,\n",
    "            sizemode='area',\n",
    "            sizeref=2.*max([math.sqrt(i) for i in dfs[keyList[0]]['Confirmed']])/(100.**2),\n",
    "        ),\n",
    "        text=textList,\n",
    "        hovertext=['Confirmed: {}<br>Recovered: {}<br>Death: {}'.format(i, j, k) for i, j, k in zip(dfs[keyList[0]]['Confirmed'],\n",
    "                                                                                                    dfs[keyList[0]]['Recovered'],\n",
    "                                                                                                    dfs[keyList[0]]['Deaths'])],\n",
    "        hovertemplate = \"<b>%{text}</b><br><br>\" +\n",
    "                        \"%{hovertext}<br>\" +\n",
    "                        \"<extra></extra>\")\n",
    "    )\n",
    "    fig2.update_layout(\n",
    "        plot_bgcolor='#151920',\n",
    "        paper_bgcolor='#cbd2d3',\n",
    "        margin=go.layout.Margin(l=10,r=10,b=10,t=0,pad=40),\n",
    "        hovermode='closest',\n",
    "        transition = {'duration':50},\n",
    "        annotations=[\n",
    "        dict(\n",
    "            x=.5,\n",
    "            y=-.01,\n",
    "            align='center',\n",
    "            showarrow=False,\n",
    "            text=\"Points are placed based on data geolocation levels.<br><b>Province/State level<b> - China, Australia, United States, and Canada; <b>Country level<b> - other countries.\",\n",
    "            xref=\"paper\",\n",
    "            yref=\"paper\",\n",
    "            font=dict(size=10, color='#292929'),\n",
    "        )],\n",
    "        mapbox=go.layout.Mapbox(\n",
    "            accesstoken=mapbox_access_token,\n",
    "            style=\"light\",\n",
    "            # The direction you're facing, measured clockwise as an angle from true north on a compass\n",
    "            bearing=0,\n",
    "            center=go.layout.mapbox.Center(\n",
    "                lat=14.056159 if len(derived_virtual_selected_rows)==0 else dff.loc[selected_row_ids[0]].lat, \n",
    "                lon=22.920039 if len(derived_virtual_selected_rows)==0 else dff.loc[selected_row_ids[0]].lon\n",
    "            ),\n",
    "            pitch=0,\n",
    "            zoom=1.03 if len(derived_virtual_selected_rows)==0 else 4\n",
    "        )\n",
    "    )\n",
    "\n",
    "    return fig2\n",
    "\n",
    "@app.callback(\n",
    "    Output('datatable-interact-lineplot', 'figure'),\n",
    "    [Input('datatable-interact-location', 'derived_virtual_selected_rows'),\n",
    "     Input('datatable-interact-location', 'selected_row_ids')]\n",
    ")\n",
    "\n",
    "def update_lineplot(derived_virtual_selected_rows, selected_row_ids):\n",
    "    print(\"inside update_lineplot\", derived_virtual_selected_rows, selected_row_ids)\n",
    "    if derived_virtual_selected_rows is None:\n",
    "        derived_virtual_selected_rows = []\n",
    "        \n",
    "    dff = dfSum\n",
    "    \n",
    "    if selected_row_ids:\n",
    "        if dff.loc[selected_row_ids[0]]['Country/Region'] == 'Mainland China':\n",
    "            Region = 'China'\n",
    "        else:\n",
    "            Region = dff.loc[selected_row_ids[0]]['Country/Region']\n",
    "    else:\n",
    "        Region = 'UK'\n",
    "        \n",
    "    if Region == \"UK\": Region = 'United Kingdom'\n",
    "    # Read cumulative data of a given region from ./cumulative_data folder\n",
    "\n",
    "    df_region = build_df_region(Region)\n",
    "\n",
    "    #df_region = pd.read_csv('C:/Users/jmckinnell/Documents/Personal/COVID-19-research/data_pull/data-visualisation-scripts/dash-2019-coronavirus/cumulative_data/{}.csv'.format(Region))\n",
    "    #df_region=df_region.astype({'Date_last_updated_AEDT':'datetime64', 'date_day':'datetime64'})\n",
    "\n",
    "    df = df_region.loc[:,['date_day','Confirmed']]\n",
    "    df.index = df['date_day']\n",
    "    df = df.sort_index()\n",
    "    FMT = '%Y-%m-%d %H:%M:%S'\n",
    "    date = df['date_day']\n",
    "    df['data'] = date.map(lambda x : (datetime.strptime(str(x), FMT) - datetime.strptime(\"2020-01-01 00:00:00\", FMT)).days  )\n",
    "    #We can use the curve_fit function of scipy library to estimate the parameter values and errors starting from the original data.\n",
    "    x = df['data']\n",
    "    y = df['Confirmed']\n",
    "    fit = curve_fit(logistic_model,x,y,p0=[2,100,20000], maxfev = 20000)\n",
    "\n",
    "    a = fit[0][0]\n",
    "    b = fit[0][1]\n",
    "    c = fit[0][2]\n",
    "\n",
    "    sol = int(fsolve(lambda x : logistic_model(x,a,b,c) - int(c),b))\n",
    "\n",
    "    dates = []\n",
    "    for i_date in date:\n",
    "        dates.append(i_date)\n",
    "\n",
    "    base = pd.to_datetime(date[-1:].values[0])\n",
    "    date_list_pred = [base + timedelta(days=i_x) for i_x in range(1,sol)]\n",
    "    date_list = []\n",
    "    for i_date in dates:\n",
    "        date_list.append(i_date)\n",
    "    for i_date in date_list_pred:\n",
    "        date_list.append(i_date)\n",
    "    y_logistic = [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in range(0+min(x),len(date_list)+min(x))]\n",
    "    #y_exp = [date_list, [exponential_model(i,exp_fit[0][0],exp_fit[0][1],exp_fit[0][2]) for i in range(0+min(x),len(date_list)+min(x))]]\n",
    "    y_logistic = list(map(int, y_logistic))\n",
    "    # Create empty figure canvas\n",
    "    fig3 = make_subplots(specs=[[{\"secondary_y\": True}]])\n",
    "    #fig3 = go.Figure()\n",
    "\n",
    "    # Add trace to the figure\n",
    "    fig3.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                             y=df_region['Confirmed'],\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='Confirmed case',\n",
    "                             line=dict(color='#d7191c', width=4),\n",
    "                             marker=dict(size=4, color='#d7191c',\n",
    "                                         line=dict(width=4,color='#d7191c')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                             hovertext=['{} confirmed<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Confirmed']],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "\n",
    "    # Add forecast trace to the figure\n",
    "    fig3.add_trace(go.Scatter(x=date_list, \n",
    "                             y=y_logistic,\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='Predicted Cases',\n",
    "                             #line=dict(color='#272e3e', width=1),\n",
    "                             marker=dict(size=2, color='#272e3e',\n",
    "                                 line=dict(width=1,color='#272e3e')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in date_list],\n",
    "                             hovertext=['{} Predicted<br>{:,d} cases<br>'.format(Region, i) for i in y_logistic],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "\n",
    "    fig3.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                             y=df_region['Recovered'],\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='Recovered case',\n",
    "                             line=dict(color='#1a9622', width=2),                         \n",
    "                             #marker=dict(size=4, color='#f4f4f2',\n",
    "                             #            line=dict(width=1,color='#168038')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                             hovertext=['{} Recovered<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Recovered']],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "    fig3.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                             y=df_region['Deaths'],\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='Death case',\n",
    "                             line=dict(color='#626262', width=2),\n",
    "                             #marker=dict(size=4, color='#f4f4f2',\n",
    "                             #            line=dict(width=1,color='#626262')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                             hovertext=['{} Deaths<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Deaths']],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "\n",
    "    fig3.add_trace(go.Bar(x=df_region['date_day'], \n",
    "                         y=df_region['New'],\n",
    "                             #mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                         name='Daily New Cases',\n",
    "                         marker_color='#626262',\n",
    "                         opacity = .3,\n",
    "                             #marker=dict(size=4, color='#f4f4f2',\n",
    "                             #            line=dict(width=1,color='#626262')),\n",
    "                         text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                         hovertext=['{} New<br>{} cases<br>'.format(Region, i) for i in df_region['New']],\n",
    "                         hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                  '%{hovertext}'+\n",
    "                                                  '<extra></extra>'\n",
    "                        ),\n",
    "                         secondary_y=True,\n",
    "                 )\n",
    "\n",
    "    # Customise layout\n",
    "    fig3.update_layout(\n",
    "        #title=dict(\n",
    "        #    text=\"<b>Confirmed Cases Timeline<b>\",\n",
    "        #    y=0.96, x=0.5, xanchor='center', yanchor='top',\n",
    "        #    font=dict(size=20, color=\"#292929\", family=\"Playfair Display\")\n",
    "        #),\n",
    "        margin=go.layout.Margin(\n",
    "                l=0,\n",
    "                r=10,\n",
    "                b=0,\n",
    "                t=10,\n",
    "                pad=0\n",
    "            ),\n",
    "        annotations=[\n",
    "            dict(x=.5,\n",
    "                 y=.4,\n",
    "                 xref=\"paper\",\n",
    "                 yref=\"paper\",\n",
    "                 text=Region,\n",
    "                 opacity=0.5,\n",
    "                 font=dict(family='Arial, sans-serif',\n",
    "                           size=60,\n",
    "                           color=\"grey\"),\n",
    "            )\n",
    "        ],\n",
    "        yaxis=dict(showline=False, linecolor='#272e3e',\n",
    "                   zeroline=False,\n",
    "                   rangemode=\"tozero\",\n",
    "                   #automargin=True,\n",
    "                   #showgrid=False,\n",
    "                   gridcolor='rgba(203, 210, 211,.3)',\n",
    "                   gridwidth = .1,\n",
    "                   mirror=True,\n",
    "                   #tickmode='array',\n",
    "                   # Set tick range based on the maximum number\n",
    "                   #tickvals=tickList,\n",
    "                   # Set tick label accordingly\n",
    "                   #ticktext=[\"{:.0f}k\".format(i/1000) for i in tickList]\n",
    "        ),\n",
    "        yaxis2=dict(showline=False, linecolor='#272e3e',\n",
    "                    zeroline=False,\n",
    "                    showgrid=False,\n",
    "                    #automargin=True,\n",
    "                    #range=[-1, max(df_region['New'])+100]\n",
    "                    rangemode=\"tozero\",\n",
    "                    #mirror='ticks',\n",
    "                    #gridcolor='rgba(203, 210, 211,.3)',\n",
    "                    #gridwidth = .1,\n",
    "                    #tickmode='array',\n",
    "                    #anchor=\"free\",\n",
    "                    #overlaying=\"y\",\n",
    "                    #side=\"right\",\n",
    "                    #position=0.15\n",
    "        ),\n",
    "        xaxis_title=\"Cumulative Cases (Select Country/Region From Table)\",\n",
    "        xaxis=dict(showline=False, linecolor='#272e3e',\n",
    "                   showgrid=False,\n",
    "                   gridcolor='rgba(203, 210, 211,.3)',\n",
    "                   gridwidth = .1,\n",
    "                   zeroline=False,\n",
    "                   automargin=True,\n",
    "        ),\n",
    "        xaxis_tickformat='%b %d',\n",
    "        #transition = {'duration':500},\n",
    "        hovermode = 'x',\n",
    "        legend_orientation=\"v\",\n",
    "        legend=dict(x=.02, y=.95, bgcolor=\"rgba(0,0,0,0)\",),\n",
    "        plot_bgcolor='#f4f4f2',\n",
    "        paper_bgcolor='#cbd2d3',\n",
    "        font=dict(color='#292929')\n",
    "        )\n",
    "\n",
    "    return fig3\n",
    "\n",
    "@app.callback(\n",
    "    Output('datatable-interact-lineplot-uk', 'figure'),\n",
    "    [Input('datatable-interact-location-uk', 'derived_virtual_selected_rows'),\n",
    "     Input('datatable-interact-location-uk', 'selected_row_ids')]\n",
    ")\n",
    "\n",
    "def update_lineplot_uk(derived_virtual_selected_rows, selected_row_ids):\n",
    "    print('Inside update_lineplot_uk ', derived_virtual_selected_rows, selected_row_ids)\n",
    "    #if derived_virtual_selected_rows is None:\n",
    "    #    derived_virtual_selected_rows = []\n",
    "\n",
    "    if selected_row_ids is None:\n",
    "        selected_row_ids = []\n",
    "\n",
    "        if derived_virtual_selected_rows != None:\n",
    "            if len(derived_virtual_selected_rows) > 0:\n",
    "                print(derived_virtual_selected_rows)\n",
    "                if derived_virtual_selected_rows[0] != None:\n",
    "                    Region = UKTable.iloc[derived_virtual_selected_rows[0]]['Country/Region']\n",
    "                    print(Region)\n",
    "                else:\n",
    "                    Region = 'UK'\n",
    "                    print('default')\n",
    "            else:\n",
    "                Region = 'UK'\n",
    "                print('default')\n",
    "\n",
    "        else:\n",
    "            Region = 'UK'\n",
    "            print('default')\n",
    "    else:\n",
    "        Region = selected_row_ids[0]\n",
    "    \n",
    "    if Region == \"UK\": Region = 'United Kingdom'\n",
    "    # Read cumulative data of a given region from ./cumulative_data folder\n",
    "    print(Region)\n",
    "    df_region = build_df_region_UK(Region)\n",
    "\n",
    "    df = df_region.loc[:,['date_day','Confirmed']]\n",
    "    df.index = df['date_day']\n",
    "    df = df.sort_index()\n",
    "    FMT = '%Y-%m-%d %H:%M:%S'\n",
    "    date = df['date_day']\n",
    "    df['data'] = date.map(lambda x : (datetime.strptime(str(x), FMT) - datetime.strptime(\"2020-01-01 00:00:00\", FMT)).days  )\n",
    "    #We can use the curve_fit function of scipy library to estimate the parameter values and errors starting from the original data.\n",
    "    x = df['data']\n",
    "    y = df['Confirmed']\n",
    "    fit = curve_fit(logistic_model,x,y,p0=[2,100,20000], maxfev = 20000)\n",
    "\n",
    "    a = fit[0][0]\n",
    "    b = fit[0][1]\n",
    "    c = fit[0][2]\n",
    "\n",
    "    sol = int(fsolve(lambda x : logistic_model(x,a,b,c) - int(c),b))\n",
    "\n",
    "    dates = []\n",
    "    for i_date in date:\n",
    "        dates.append(i_date)\n",
    "\n",
    "    base = pd.to_datetime(date[-1:].values[0])\n",
    "    date_list_pred = [base + timedelta(days=i_x) for i_x in range(1,sol)]\n",
    "    date_list = []\n",
    "    for i_date in dates:\n",
    "        date_list.append(i_date)\n",
    "    for i_date in date_list_pred:\n",
    "        date_list.append(i_date)\n",
    "    y_logistic = [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in range(0+min(x),len(date_list)+min(x))]\n",
    "    #y_exp = [date_list, [exponential_model(i,exp_fit[0][0],exp_fit[0][1],exp_fit[0][2]) for i in range(0+min(x),len(date_list)+min(x))]]\n",
    "    y_logistic = list(map(int, y_logistic))\n",
    "    # Create empty figure canvas\n",
    "    fig3 = make_subplots(specs=[[{\"secondary_y\": True}]])\n",
    "    #fig3 = go.Figure()\n",
    "\n",
    "    # Add trace to the figure\n",
    "    fig3.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                             y=df_region['Confirmed'],\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='UK Confirmed cases scaled to region',\n",
    "                             line=dict(color='#d7191c', width=4),\n",
    "                             marker=dict(size=4, color='#d7191c',\n",
    "                                         line=dict(width=4,color='#d7191c')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                             hovertext=['{} confirmed<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Confirmed']],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "\n",
    "    # Add forecast trace to the figure\n",
    "    fig3.add_trace(go.Scatter(x=date_list, \n",
    "                             y=y_logistic,\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='UK Predicted Cases scaled to region',\n",
    "                             #line=dict(color='#272e3e', width=1),\n",
    "                             marker=dict(size=2, color='#272e3e',\n",
    "                                 line=dict(width=1,color='#272e3e')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in date_list],\n",
    "                             hovertext=['{} Predicted<br>{:,d} cases<br>'.format(Region, i) for i in y_logistic],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "\n",
    "    fig3.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                             y=df_region['Recovered'],\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='UK Recovered cases scaled to region',\n",
    "                             line=dict(color='#1a9622', width=2),                         \n",
    "                             #marker=dict(size=4, color='#f4f4f2',\n",
    "                             #            line=dict(width=1,color='#168038')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                             hovertext=['{} Recovered<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Recovered']],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "    fig3.add_trace(go.Scatter(x=df_region['date_day'], \n",
    "                             y=df_region['Deaths'],\n",
    "                             mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                             name='UK Death cases scaled to region',\n",
    "                             line=dict(color='#626262', width=2),\n",
    "                             #marker=dict(size=4, color='#f4f4f2',\n",
    "                             #            line=dict(width=1,color='#626262')),\n",
    "                             text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                             hovertext=['{} Deaths<br>{:,d} cases<br>'.format(Region, i) for i in df_region['Deaths']],\n",
    "                             hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                     '%{hovertext}'+\n",
    "                                                     '<extra></extra>'),\n",
    "                             secondary_y=False,\n",
    "                 )\n",
    "\n",
    "    fig3.add_trace(go.Bar(x=df_region['date_day'], \n",
    "                         y=df_region['New'],\n",
    "                             #mode='lines+markers',\n",
    "                             #line_shape='spline',\n",
    "                         name='UK Daily New Cases scaled to region',\n",
    "                         marker_color='#626262',\n",
    "                         opacity = .3,\n",
    "                             #marker=dict(size=4, color='#f4f4f2',\n",
    "                             #            line=dict(width=1,color='#626262')),\n",
    "                         text=[datetime.strftime(d, '%b %d %Y AEDT') for d in df_region['date_day']],\n",
    "                         hovertext=['{} New<br>{} cases<br>'.format(Region, i) for i in df_region['New']],\n",
    "                         hovertemplate='<b>%{text}</b><br></br>'+\n",
    "                                                  '%{hovertext}'+\n",
    "                                                  '<extra></extra>'\n",
    "                        ),\n",
    "                         secondary_y=True,\n",
    "                 )\n",
    "\n",
    "    # Customise layout\n",
    "    fig3.update_layout(\n",
    "        #title=dict(\n",
    "        #    text=\"<b>Confirmed Cases Timeline<b>\",\n",
    "        #    y=0.96, x=0.5, xanchor='center', yanchor='top',\n",
    "        #    font=dict(size=20, color=\"#292929\", family=\"Playfair Display\")\n",
    "        #),\n",
    "        margin=go.layout.Margin(\n",
    "                l=0,\n",
    "                r=10,\n",
    "                b=0,\n",
    "                t=10,\n",
    "                pad=0\n",
    "            ),\n",
    "        annotations=[\n",
    "            dict(x=.5,\n",
    "                 y=.4,\n",
    "                 xref=\"paper\",\n",
    "                 yref=\"paper\",\n",
    "                 text=Region,\n",
    "                 opacity=0.5,\n",
    "                 font=dict(family='Arial, sans-serif',\n",
    "                           size=60,\n",
    "                           color=\"grey\"),\n",
    "            )\n",
    "        ],\n",
    "        yaxis=dict(showline=False, linecolor='#272e3e',\n",
    "                   zeroline=False,\n",
    "                   rangemode=\"tozero\",\n",
    "                   #automargin=True,\n",
    "                   #showgrid=False,\n",
    "                   gridcolor='rgba(203, 210, 211,.3)',\n",
    "                   gridwidth = .1,\n",
    "                   mirror=True,\n",
    "                   #tickmode='array',\n",
    "                   # Set tick range based on the maximum number\n",
    "                   #tickvals=tickList,\n",
    "                   # Set tick label accordingly\n",
    "                   #ticktext=[\"{:.0f}k\".format(i/1000) for i in tickList]\n",
    "        ),\n",
    "        yaxis2=dict(showline=False, linecolor='#272e3e',\n",
    "                    zeroline=False,\n",
    "                    showgrid=False,\n",
    "                    #automargin=True,\n",
    "                    #range=[-1, max(df_region['New'])+100]\n",
    "                    rangemode=\"tozero\",\n",
    "                    #mirror='ticks',\n",
    "                    #gridcolor='rgba(203, 210, 211,.3)',\n",
    "                    #gridwidth = .1,\n",
    "                    #tickmode='array',\n",
    "                    #anchor=\"free\",\n",
    "                    #overlaying=\"y\",\n",
    "                    #side=\"right\",\n",
    "                    #position=0.15\n",
    "        ),\n",
    "        xaxis_title=\"Cumulative Cases (Select Country/Region From Table)\",\n",
    "        xaxis=dict(showline=False, linecolor='#272e3e',\n",
    "                   showgrid=False,\n",
    "                   gridcolor='rgba(203, 210, 211,.3)',\n",
    "                   gridwidth = .1,\n",
    "                   zeroline=False,\n",
    "                   automargin=True,\n",
    "        ),\n",
    "        xaxis_tickformat='%b %d',\n",
    "        #transition = {'duration':500},\n",
    "        hovermode = 'x',\n",
    "        legend_orientation=\"v\",\n",
    "        legend=dict(x=.02, y=.95, bgcolor=\"rgba(0,0,0,0)\",),\n",
    "        plot_bgcolor='#f4f4f2',\n",
    "        paper_bgcolor='#cbd2d3',\n",
    "        font=dict(color='#292929')\n",
    "        )\n",
    "\n",
    "    return fig3\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app.run_server(port=8882)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"here\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}