COVID19 Visualizations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  COVID-19: DATA SCIENCE AND MACHINE LEARNING VISUALIZATIONS\n",
    "\n",
    "I am currently using the [NYTimes](https://github.com/nytimes/covid-19-data) and [JHU CSSE](https://github.com/CSSEGISandData/COVID-19) database in this notebook. NYTimes is for USA data and JHU CSSE is for international data. Conveniently, they are all written in `.csv` files which Pandas can take great advantage of.\n",
    "\n",
    "If you are planning to run the notebook on your own computer, please make sure you have all the dependencies installed! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import geopandas\n",
    "import pycountry\n",
    "import plotly\n",
    "import plotly.express as px\n",
    "import plotly.figure_factory as ff\n",
    "import time\n",
    "from datetime import datetime\n",
    "import json\n",
    "import os\n",
    "from urllib.request import urlopen\n",
    "from selenium import webdriver\n",
    "from webdriver_manager.chrome import ChromeDriverManager\n",
    "from pathlib import Path\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "with urlopen('https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json') as response:\n",
    "        counties = json.load(response)\n",
    "\n",
    "plotly.io.orca.config.executable = '/path/to/orca'\n",
    "plotly.io.orca.config.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pulling the Databases\n",
    "For cloning the repository that contain the databases, I used `.gitignore` to prevent pushing large files to this repository. I do not modify the directories that contain the databases and I leave them as is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Please run this cell if databases directory is empty!\n",
    "!git clone https://github.com/CSSEGISandData/COVID-19 databases/jhucsse\n",
    "!git clone https://github.com/nytimes/covid-19-data databases/nytimes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the cells below to get the most recent databases!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C databases/jhucsse pull origin master\n",
    "!ls databases/jhucsse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C databases/nytimes pull origin master\n",
    "!ls databases/nytimes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load `.csv` Files into Pandas DataFrames\n",
    "All the recent databases are pulled from GitHub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COVID19_confirmed = pd.read_csv(\"databases/jhucsse/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv\")\n",
    "COVID19_deaths = pd.read_csv(\"databases/jhucsse/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv\")\n",
    "COVID19_recovered = pd.read_csv(\"databases/jhucsse/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_recovered_global.csv\")\n",
    "\n",
    "#Global variables\n",
    "databases = [COVID19_confirmed, COVID19_deaths, COVID19_recovered]\n",
    "dataset = [(COVID19_confirmed, \"confirmed\"), (COVID19_deaths, \"deaths\"), (COVID19_recovered, \"recovered\")]\n",
    "\n",
    "all_countries = list(COVID19_confirmed['Country/Region'])\n",
    "all_countries = list(dict.fromkeys(all_countries))\n",
    "\n",
    "dates = list(COVID19_confirmed.columns)\n",
    "dates.remove('Country/Region')\n",
    "dates.remove('Province/State')\n",
    "dates.remove('Lat')\n",
    "dates.remove('Long')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COVID19_US = pd.read_csv(\"databases/nytimes/us.csv\") #Already provided with the JHU CSSE\n",
    "COVID19_US_states = pd.read_csv(\"databases/nytimes/us-states.csv\")\n",
    "COVID19_US_counties = pd.read_csv(\"databases/nytimes/us-counties.csv\", dtype={\"fips\": str})\n",
    "\n",
    "COVID19_US_states = COVID19_US_states.sort_values(by=['date'])\n",
    "\n",
    "states = list(set(COVID19_US_states['state'].tolist()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Cleaning\n",
    "Cleaning unnecessary data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_clean(data):\n",
    "    data = data.drop(['Province/State', 'Lat', 'Long'], axis=1)\n",
    "    data = data.groupby(['Country/Region'])[dates].sum()\n",
    "    data.columns = pd.to_datetime(data.columns)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COVID19_confirmed = data_clean(COVID19_confirmed)\n",
    "COVID19_deaths = data_clean(COVID19_deaths)\n",
    "COVID19_recovered = data_clean(COVID19_recovered)\n",
    "dataset = [(COVID19_confirmed, \"confirmed\"), (COVID19_deaths, \"deaths\"), (COVID19_recovered, \"recovered\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Charts with Worldwide Data\n",
    "Functions to compile graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cases_country(country_name, data, label=None):\n",
    "    country_plot = data.loc[country_name]\n",
    "    country_plot = country_plot.sort_index().plot(label=label)\n",
    "    \n",
    "    if data.equals(COVID19_confirmed):\n",
    "        data_label = \"Confirmed Cases\"\n",
    "    elif data.equals(COVID19_recovered):\n",
    "        data_label = \"Recovered\"\n",
    "    else:\n",
    "        data_label = \"Deaths\"\n",
    "    \n",
    "    #Labelings\n",
    "    country_plot.set_ylabel(\"Number of \" + data_label)\n",
    "    country_plot.set_xlabel(\"Day\")\n",
    "    country_plot.set_title(data_label + \" in \" + country_name)\n",
    "    return country_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_all_cases_country_individual():\n",
    "    for country in all_countries:\n",
    "        for data in dataset:\n",
    "            cases_country(country, data[0])\n",
    "            plt.savefig(\"cases_country_individual/\" + country + \"_\" + data[1] + \".png\")\n",
    "            plt.tight_layout()\n",
    "            plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_cases_country(country_name):\n",
    "    for data in dataset:\n",
    "        plt = cases_country(country_name, data[0], label=data[1])\n",
    "    \n",
    "    #Labelings\n",
    "    plt.set_ylabel(\"Number of Cases\")\n",
    "    plt.set_xlabel(\"Day\")\n",
    "    plt.set_title(\"COVID-19 in \" + country_name)\n",
    "    plt.legend()\n",
    "    return plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_all_cases_country():\n",
    "    for country in all_countries:\n",
    "        all_cases_country(country)\n",
    "        plt.savefig(\"cases_country/\" + country + \"_all.png\")\n",
    "        plt.tight_layout()\n",
    "        plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def worldwide_cases():\n",
    "    world = COVID19_confirmed.sum().plot(label=\"confirmed\")\n",
    "    world = COVID19_deaths.sum().plot(label=\"deaths\")\n",
    "    world = COVID19_recovered.sum().plot(label=\"recovered\")\n",
    "\n",
    "    #Labelings\n",
    "    world.set_ylabel(\"Number of Cases\")\n",
    "    world.set_xlabel(\"Day\")\n",
    "    world.set_title(\"COVID-19 Worldwide\")\n",
    "    world.legend()\n",
    "    plt.savefig(\"COVID19_worldwide\")\n",
    "    return world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cases_country_active(country_name):\n",
    "    \"\"\"\n",
    "    active = confirmed - deaths - recovered\n",
    "    \"\"\"\n",
    "    confirmed = COVID19_confirmed.loc[country_name]\n",
    "    deaths = COVID19_deaths.loc[country_name]\n",
    "    recovered = COVID19_recovered.loc[country_name]\n",
    "    \n",
    "    active = confirmed - deaths - recovered\n",
    "\n",
    "    active = active.plot()\n",
    "    active.set_ylabel(\"Number of Active Cases\")\n",
    "    active.set_xlabel(\"Day\")\n",
    "    active.set_title(\"Active COVID-19 Cases in \" + country_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_all_cases_country_active():    \n",
    "    for country in all_countries:\n",
    "        cases_country_active(country)\n",
    "        plt.savefig(\"cases_country_active/\" + country + \"_active_cases.png\")\n",
    "        plt.tight_layout()\n",
    "        plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def worldwide_active():\n",
    "    confirmed = COVID19_confirmed.sum()\n",
    "    deaths = COVID19_deaths.sum()\n",
    "    recovered = COVID19_recovered.sum()\n",
    "    \n",
    "    active = confirmed - deaths - recovered\n",
    "    active = active.plot()\n",
    "\n",
    "    #Labelings\n",
    "    active.set_ylabel(\"Number of Active Cases\")\n",
    "    active.set_xlabel(\"Day\")\n",
    "    active.set_title(\"COVID-19 Active Cases Worldwide\")\n",
    "    \n",
    "    plt.savefig(\"COVID19_worldwide_active.png\")\n",
    "    return active"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Still testing and experimenting\n",
    "def compare_countries(list_countries):    \n",
    "    for country in list_countries:\n",
    "        for data in dataset:\n",
    "            country_data = data[0]\n",
    "            country_data = country_data.loc[country]\n",
    "            country_data = country_data.plot(label=data[1] + \" in \" + str(country))\n",
    "\n",
    "    country_data.set_ylabel(\"Number of Cases\")\n",
    "    country_data.set_xlabel(\"Day\")\n",
    "    country_data.set_title(\"COVID-19 in \" + str(list(list_countries)))\n",
    "    country_data.legend()\n",
    "    \n",
    "    #plt.savefig(str(list_countries) + \".png\")\n",
    "    \n",
    "compare_countries(['US'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "update_all_cases_country_individual()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "update_all_cases_country()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "worldwide_cases()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "update_all_cases_country_active()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "worldwide_active()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data with US Data\n",
    "Functions that chart US data, from the NYTimes database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cases_by_state(state):\n",
    "    df = COVID19_US_states.loc[COVID19_US_states['state'] == state].drop(['fips'], axis=1)\n",
    "    pd.to_datetime(df['date'])\n",
    "    \n",
    "    df = df.set_index(df['date']).drop(['date'], axis=1)\n",
    "    df = df.sort_values(by=['date'])\n",
    "\n",
    "    #return df\n",
    "    return df.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_states():\n",
    "    for state in states:\n",
    "        us_cases = cases_by_state(state)\n",
    "        \n",
    "        us_cases.set_ylabel(\"Cases\")\n",
    "        us_cases.set_xlabel(\"Day\")\n",
    "        us_cases.set_title(\"COVID-19 Cases in \" + str(state))\n",
    "        \n",
    "        plt.savefig(\"cases_us_states/\" + str(state) + \".png\")\n",
    "        plt.clf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cases_by_state('Washington')\n",
    "update_states()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizations with Global Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COVID19_geo_confirmed = dataset[0][0]\n",
    "COVID19_geo_deaths = dataset[1][0]\n",
    "COVID19_geo_recovered = dataset[2][0]\n",
    "\n",
    "COVID19_geo_confirmed.reset_index(level=0, inplace=True)\n",
    "COVID19_geo_deaths.reset_index(level=0, inplace=True)\n",
    "COVID19_geo_recovered.reset_index(level=0, inplace=True)\n",
    "\n",
    "COVID19_geo_confirmed = COVID19_geo_confirmed.rename(columns={\"Country/Region\" : \"name\"})\n",
    "COVID19_geo_deaths = COVID19_geo_deaths.rename(columns={\"Country/Region\" : \"name\"})\n",
    "COVID19_geo_recovered = COVID19_geo_recovered.rename(columns={\"Country/Region\" : \"name\"})\n",
    "\n",
    "COVID19_geo_confirmed = COVID19_geo_confirmed.replace({'Taiwan*': 'Taiwan', 'Korea, South': 'South Korea', 'US' : 'United States of America'})\n",
    "COVID19_geo_deaths = COVID19_geo_deaths.replace({'Taiwan*': 'Taiwan', 'Korea, South': 'South Korea', 'US' : 'United States of America'})\n",
    "COVID19_geo_recovered = COVID19_geo_recovered.replace({'Taiwan*': 'Taiwan', 'Korea, South': 'South Korea', 'US' : 'United States of America'})\n",
    "\n",
    "#Delete any islands and Antartica\n",
    "world_confirmed = world.merge(COVID19_geo_confirmed, how = 'inner', on = 'name')\n",
    "world_confirmed = world_confirmed[(world_confirmed.pop_est>0) & (world_confirmed.name!=\"Antarctica\")]\n",
    "\n",
    "world_deaths = world.merge(COVID19_geo_deaths, how = 'inner', on = 'name')\n",
    "world_deaths = world_deaths[(world_deaths.pop_est>0) & (world_deaths.name!=\"Antarctica\")]\n",
    "\n",
    "world_recovered = world.merge(COVID19_geo_recovered, how = 'inner', on = 'name')\n",
    "world_recovered = world_recovered[(world_recovered.pop_est>0) & (world_recovered.name!=\"Antarctica\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = list(COVID19_geo_confirmed)\n",
    "dates.remove('name')\n",
    "dates.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geo_confirmed_corona(data):    \n",
    "    for i in range(len(dates)):\n",
    "        fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "        world_confirmed.plot(column=dates[i],\n",
    "                   cmap='Reds',\n",
    "                   ax=ax,\n",
    "                   legend=True,\n",
    "                   legend_kwds={'label': \"Population by Country\",\n",
    "                                'orientation': \"horizontal\"})\n",
    "\n",
    "        #Save the figure\n",
    "        fig = matplotlib.pyplot.gcf()\n",
    "        fig.set_size_inches(20, 10)\n",
    "        fig.savefig('geo/geo_confirmed_normalized/' + str(i).zfill(3) + '.png', dpi=100)\n",
    "        plt.close(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geo_deaths_corona(data):\n",
    "    for i in range(len(dates)):\n",
    "        fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "        world_deaths.plot(column=dates[i],\n",
    "                   cmap='Greys',\n",
    "                   ax=ax,\n",
    "                   legend=True,\n",
    "                   legend_kwds={'label': \"Population by Country\",'orientation': \"horizontal\"})\n",
    "\n",
    "        #Save the figure\n",
    "        fig = matplotlib.pyplot.gcf()\n",
    "        fig.set_size_inches(20, 10)\n",
    "        fig.savefig('geo/geo_deaths_normalized/' + str(i).zfill(3) + '.png', dpi=100)\n",
    "        plt.close(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geo_recovered_corona(data):\n",
    "    for i in range(len(dates)):\n",
    "        fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "        world_recovered.plot(column=dates[i],\n",
    "                   cmap='Greens',\n",
    "                   ax=ax,\n",
    "                   legend=True,\n",
    "                   legend_kwds={'label': \"Population by Country\",'orientation': \"horizontal\"})\n",
    "\n",
    "        #Save the figure\n",
    "        fig = matplotlib.pyplot.gcf()\n",
    "        fig.set_size_inches(20, 10)\n",
    "        fig.savefig('geo/geo_recovered_normalized/' + str(i).zfill(3) + '.png', dpi=100)\n",
    "        plt.close(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "geo_confirmed_corona(COVID19_geo_confirmed)\n",
    "geo_deaths_corona(COVID19_geo_deaths)\n",
    "geo_recovered_corona(COVID19_geo_recovered)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#New color theme to display color gradients\n",
    "Solarcorona = ['rgb(252, 222, 156)', 'rgb(250, 164, 118)', 'rgb(240, 116, 110)', 'rgb(227, 79, 111)', 'rgb(220, 57, 119)', 'rgb(185, 37, 122)', 'rgb(124, 29, 111)', '#1b0c41', '#000004']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#SCRAP PREVIOUS\n",
    "#New dataframes\n",
    "mapping = {country.name: country.alpha_3 for country in pycountry.countries}\n",
    "geo_confirmed = COVID19_confirmed.rename(index={'Korea, South': 'Korea, Republic of', 'US' :'United States', 'Taiwan*' :'Taiwan, Province of China', 'Vietnam':'Viet Nam', 'Russia': 'Russian Federation', 'Iran': 'Iran, Islamic Republic of', 'Tanzania': 'Tanzania, United Republic of', 'Laos': \"Lao People's Democratic Republic\", 'Syria': 'Syrian Arab Republic', 'Brunei': 'Brunei Darussalam', 'Venezuela': 'Venezuela, Bolivarian Republic of', 'Bolivia':  'Bolivia, Plurinational State of', 'Moldova': 'Moldova, Republic of'}).rename(index = lambda name: mapping.get(name))\n",
    "geo_deaths = COVID19_deaths.rename(index={'Korea, South': 'Korea, Republic of', 'US' :'United States', 'Taiwan*' :'Taiwan, Province of China', 'Vietnam':'Viet Nam', 'Russia': 'Russian Federation', 'Iran': 'Iran, Islamic Republic of', 'Tanzania': 'Tanzania, United Republic of', 'Laos': \"Lao People's Democratic Republic\", 'Syria': 'Syrian Arab Republic', 'Brunei': 'Brunei Darussalam', 'Venezuela': 'Venezuela, Bolivarian Republic of', 'Bolivia':  'Bolivia, Plurinational State of', 'Moldova': 'Moldova, Republic of'}).rename(index = lambda name: mapping.get(name))\n",
    "geo_recovered = COVID19_recovered.rename(index={'Korea, South': 'Korea, Republic of', 'US' :'United States', 'Taiwan*' :'Taiwan, Province of China', 'Vietnam':'Viet Nam', 'Russia': 'Russian Federation', 'Iran': 'Iran, Islamic Republic of', 'Tanzania': 'Tanzania, United Republic of', 'Laos': \"Lao People's Democratic Republic\", 'Syria': 'Syrian Arab Republic', 'Brunei': 'Brunei Darussalam', 'Venezuela': 'Venezuela, Bolivarian Republic of', 'Bolivia':  'Bolivia, Plurinational State of', 'Moldova': 'Moldova, Republic of'}).rename(index = lambda name: mapping.get(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#confirmed 500000\n",
    "#deaths 10000\n",
    "#recovered 100000\n",
    "\n",
    "def geo_frames(df, file, case_range):\n",
    "    for i in range(len(geo_confirmed.columns)):\n",
    "        fig = px.choropleth(df, locations=df.index,\n",
    "                            color=geo_confirmed.columns[i],\n",
    "                            range_color=(0, case_range),\n",
    "                            color_continuous_scale=Solarcorona,\n",
    "                           )\n",
    "\n",
    "        fig.update_layout(\n",
    "            title_text = 'COVID-19 Cases Confirmed                        GitHub: briancpark',\n",
    "        )\n",
    "\n",
    "        #fig.show()\n",
    "        fig.write_html(\"geo/\" + file + \"_html/\" + str(i).zfill(3) + \".html\")\n",
    "        \n",
    "#geo_frames(geo_confirmed, \"geo_confirmed\", 200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "for i in range(len(geo_confirmed.columns)):\n",
    "    driver = webdriver.Chrome(ChromeDriverManager().install())\n",
    "    driver.get(\"file:///Users/brianpark/Desktop/PUBLISHED%20Projects/COVID19/geo/geo_confirmed_html/\" + str(i).zfill(3) + \".html\")\n",
    "    time.sleep(3)\n",
    "    driver.save_screenshot(\"geo/geo_confirmed/\" + str(i).zfill(3) + \".png\")\n",
    "    driver.close()\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#len(geo_confirmed.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizations with US Data\n",
    "For some reason, plotly doesn't want to work when `write_image()` is called, so I used selenium instead to screenshot. Not a very convenient way, but in the end it gives high quality graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = list(set(list(COVID19_US_states['date'])))\n",
    "dates.sort(key = lambda date: datetime.strptime(date, '%Y-%m-%d')) \n",
    "states = list(set(list(COVID19_US_states['state'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_html(i, data_type, data_label, color_gradient, max_cases, date):\n",
    "    df = COVID19_US_counties#pd.read_csv(\"databases/nytimes/us-counties.csv\", dtype={\"fips\": str})\n",
    "    df = df[df['date']==date]\n",
    "\n",
    "    fig = px.choropleth(df, geojson=counties, locations='fips', color=data_type,\n",
    "                               color_continuous_scale=color_gradient,\n",
    "                               range_color=(0, max_cases),\n",
    "                               scope=\"usa\",\n",
    "                               labels={data_type:data_type}\n",
    "                              )\n",
    "    fig.update_layout(title_text = 'USA COVID-19 ' + data_label + ' by County on ' + str(date) + \"              GitHub:briancpark\")\n",
    "    fig.write_html(\"geo/geo_us_\" + data_type + \"_html/\" + str(i).zfill(3) + \".html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def update_us_cases_by_counties(max_cases, limit):\n",
    "        \n",
    "    i = 0\n",
    "\n",
    "    for date in dates:\n",
    "        create_html(i, 'cases', 'Cases', \"Sunsetdark\", max_cases, date)       \n",
    "        i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_us_deaths_by_counties(max_cases, limit):\n",
    "    i = 0\n",
    "    \n",
    "    for date in dates:\n",
    "        create_html(i, 'deaths', 'Deaths', \"Greys\", max_cases, date)\n",
    "        i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_png(file, limit):\n",
    "    if file == \"confirmed\":\n",
    "        directory = \"geo_us_cases\"\n",
    "    else:\n",
    "        directory = \"geo_us_deaths\"\n",
    "    \n",
    "    for i in range(len(dates) - limit, len(dates)):\n",
    "        options = webdriver.ChromeOptions()\n",
    "        options.add_argument('headless')\n",
    "        options.add_argument('window-size=1280x720');\n",
    "        \n",
    "        driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n",
    "        driver.get(\"file:///Users/brianpark/Projects/COVID-19-Visualizations/geo/\" + directory + \"_html/\" + str(i).zfill(3) + \".html\")\n",
    "        time.sleep(3)\n",
    "        driver.save_screenshot(\"geo/\" + directory + \"/\" + str(i).zfill(3) + \".png\")\n",
    "        driver.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compile Timelapses\n",
    "Create beautiful, and yet alarming dynamic graphs that implement time with COVID-19. `ffmpeg` is used to compile the `.gif` and `.mp4` files. Please make sure you have that installed. Can be simply done in your terminal via `pip install ffmpeg`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compile_timelapse():\n",
    "    !rm timelapses/global_confirmed_timelapse.mp4\n",
    "    !rm timelapses/global_deaths_timelapse.mp4\n",
    "    !rm timelapses/global_recovered_timelapse.mp4\n",
    "    \n",
    "    !rm timelapses/global_confirmed_timelapse.gif\n",
    "    !rm timelapses/global_deaths_timelapse.gif\n",
    "    !rm timelapses/global_recovered_timelapse.gif\n",
    "    \n",
    "    !ffmpeg -r 15 -i geo/geo_confirmed/%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p timelapses/global_confirmed_timelapse.mp4\n",
    "    !ffmpeg -r 15 -i geo/geo_deaths/%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p timelapses/global_deaths_timelapse.mp4\n",
    "    !ffmpeg -r 15 -i geo/geo_recovered/%03d.png -c:v libx26|4 -r 30 -pix_fmt yuv420p timelapses/global_recovered_timelapse.mp4\n",
    "        \n",
    "    !ffmpeg -i timelapses/global_confirmed_timelapse.mp4 timelapses/global_confirmed_timelapse.gif\n",
    "    !ffmpeg -i timelapses/global_deaths_timelapse.mp4 timelapses/global_deaths_timelapse.gif\n",
    "    !ffmpeg -i timelapses/global_recovered_timelapse.mp4 timelapses/global_recovered_timelapse.gif\n",
    "    \n",
    "    !rm timelapses/global_confirmed_normalized_timelapse.mp4\n",
    "    !rm timelapses/global_deaths_normalized_timelapse.mp4\n",
    "    !rm timelapses/global_recovered_normalized_timelapse.mp4\n",
    "    \n",
    "    !rm timelapses/global_confirmed_normalized_timelapse.gif\n",
    "    !rm timelapses/global_deaths_normalized_timelapse.gif\n",
    "    !rm timelapses/global_recovered_normalized_timelapse.gif\n",
    "    \n",
    "    !ffmpeg -r 15 -i geo/geo_confirmed_normalized/%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p timelapses/global_confirmed_normalized_timelapse.mp4\n",
    "    !ffmpeg -r 15 -i geo/geo_deaths_normalized/%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p timelapses/global_deaths_normalized_timelapse.mp4\n",
    "    !ffmpeg -r 15 -i geo/geo_recovered_normalized/%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p timelapses/global_recovered_normalized_timelapse.mp4\n",
    "        \n",
    "    !ffmpeg -i timelapses/global_confirmed_normalized_timelapse.mp4 timelapses/global_confirmed_normalized_timelapse.gif\n",
    "    !ffmpeg -i timelapses/global_deaths_normalized_timelapse.mp4 timelapses/global_deaths_normalized_timelapse.gif\n",
    "    !ffmpeg -i timelapses/global_recovered_normalized_timelapse.mp4 timelapses/global_recovered_normalized_timelapse.gif\n",
    "    \n",
    "    !rm timelapses/us_confirmed_timelapse.mp4\n",
    "    !rm timelapses/us_confirmed_timelapse.gif\n",
    "    \n",
    "    !rm timelapses/us_deaths_timelapse.mp4\n",
    "    !rm timelapses/us_deaths_timelapse.gif\n",
    "    \n",
    "    !ffmpeg -r 15 -i geo/geo_us_cases/%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p timelapses/us_confirmed_timelapse.mp4    \n",
    "    !ffmpeg -i timelapses/us_confirmed_timelapse.mp4 timelapses/us_confirmed_timelapse.gif\n",
    "    \n",
    "    !ffmpeg -r 15 -i geo/geo_us_deaths/%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p timelapses/us_deaths_timelapse.mp4\n",
    "    !ffmpeg -i timelapses/us_deaths_timelapse.mp4 timelapses/us_deaths_timelapse.gif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "update_us_cases_by_counties(10000, 5)#len(dates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "update_us_deaths_by_counties(1000, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convert_to_png(\"confirmed\", 5) #len(dates)) #10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "convert_to_png(\"deaths\", 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compile_timelapse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## print(px.colors.sequential.Inferno)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"#Debugging cell\n",
    "with urlopen('https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json') as response:\n",
    "        counties = json.load(response)\n",
    "\n",
    "plotly.io.orca.config.executable = '/path/to/orca'\n",
    "plotly.io.orca.config.save()\n",
    "\n",
    "df = pd.read_csv(\"databases/nytimes/us-counties.csv\", dtype={\"fips\": str})\n",
    "df = df[df['date']==\"2020-05-08\"]\n",
    "df['cases'] = 1 / np.log10(df[\"cases\"])\n",
    "\n",
    "Solarcorona = ['rgb(252, 222, 156)', 'rgb(250, 164, 118)', 'rgb(240, 116, 110)', 'rgb(227, 79, 111)', 'rgb(220, 57, 119)', 'rgb(185, 37, 122)', 'rgb(124, 29, 111)', '#1b0c41', '#000004']\n",
    "\n",
    "#Solarcorona = ['rgb(252, 222, 156)', 'rgb(250, 164, 118)', 'rgb(220, 57, 119)', 'rgb(185, 37, 122)', 'rgb(124, 29, 111)', '#1b0c41', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004']\n",
    "\n",
    "fig = px.choropleth(df, geojson=counties, locations='fips', color='cases',\n",
    "                           color_continuous_scale=Solarcorona,\n",
    "                           range_color=(0, 100000),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'cases':'cases'}\n",
    "                          )\n",
    "fig.update_layout(#margin={\"r\":0,\"t\":0,\"l\":0,\"b\":0}),\n",
    "                  title_text = 'USA COVID-19 Cases by County on ' + \"05-08\" + \"              GitHub:briancpark\",\n",
    "coloraxis_colorbar=dict(\n",
    "    title=\"Population\",\n",
    "    ticktext=[\"1M\", \"10M\", \"100M\", \"1B\"],\n",
    "))\n",
    "\n",
    "\n",
    "                    \n",
    "fig.show()\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "#Debugging cell\n",
    "with urlopen('https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json') as response:\n",
    "        counties = json.load(response)\n",
    "\n",
    "plotly.io.orca.config.executable = '/path/to/orca'\n",
    "plotly.io.orca.config.save()\n",
    "\n",
    "df = pd.read_csv(\"databases/nytimes/us-counties.csv\", dtype={\"fips\": str})\n",
    "df = df[df['date']==\"2020-05-08\"]\n",
    "\n",
    "Solarcorona = ['rgb(252, 222, 156)', 'rgb(250, 164, 118)', 'rgb(240, 116, 110)', 'rgb(227, 79, 111)', 'rgb(220, 57, 119)', 'rgb(185, 37, 122)', 'rgb(124, 29, 111)', '#1b0c41', '#000004']\n",
    "\n",
    "#Solarcorona = ['rgb(252, 222, 156)', 'rgb(250, 164, 118)', 'rgb(220, 57, 119)', 'rgb(185, 37, 122)', 'rgb(124, 29, 111)', '#1b0c41', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004', '#000004']\n",
    "\n",
    "fig = px.choropleth(df, geojson=counties, locations='fips', color='deaths',\n",
    "                           color_continuous_scale=\"Greys\",\n",
    "                           range_color=(0, 100),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'deaths':'deaths'},\n",
    "                          )\n",
    "fig.update_layout(#margin={\"r\":0,\"t\":0,\"l\":0,\"b\":0}),\n",
    "                  title_text = 'USA COVID-19 Deaths by County on ' + \"05-08\" + \"              GitHub:briancpark\")\n",
    "fig.show()\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "#Debugging this cell\n",
    "\n",
    "df = pd.read_csv(\"databases/nytimes/us-counties.csv\", dtype={\"fips\": str})\n",
    "df['fips'] = pd.to_numeric(df['fips'], errors='coerce')\n",
    "df = df.dropna(subset=['fips'])\n",
    "df['fips'] = df['fips'].astype(int)\n",
    "df = df[df['date']==\"2020-05-05\"]\n",
    "\n",
    "\n",
    "colorscale = [\"#f7fbff\", \"#ebf3fb\", \"#deebf7\", \"#d2e3f3\", \"#c6dbef\", \"#b3d2e9\", \"#9ecae1\",\n",
    "    \"#85bcdb\", \"#6baed6\", \"#57a0ce\", \"#4292c6\", \"#3082be\", \"#2171b5\", \"#1361a9\",\n",
    "    \"#08519c\", \"#0b4083\", \"#08306b\"]\n",
    "    \n",
    "endpts = list(np.linspace(1, 1000, len(colorscale) - 1))\n",
    "fips = df['fips'].tolist()\n",
    "values = df['cases'].tolist()\n",
    "\n",
    "\n",
    "fig = ff.create_choropleth(\n",
    "    fips=fips, values=values, scope=['usa'],\n",
    "    binning_endpoints=endpts, colorscale=colorscale,\n",
    "    show_state_data=False,\n",
    "    show_hover=True,\n",
    "    asp = 2.9,\n",
    "    title_text = 'COVID-19 in USA',\n",
    "    legend_title = 'Cases'\n",
    ")\n",
    "fig.layout.template = None\n",
    "fig.show()\n",
    "\n",
    "\n",
    "#plotly.io.write_image(fig, \"image.png\", format=None, scale=None, width=None, height=None)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning Methods\n",
    "A start. Goal is to predict coronavirus cases before a lockdown has initiated, and then compare it to real data. I will learn how machine learning works someday"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = COVID19_US_states.loc[COVID19_US_states['state'] == 'New York'].drop(['fips'], axis=1)\n",
    "pd.to_datetime(df['date'])\n",
    "\n",
    "df = df.set_index(df['date']).drop(['date'], axis=1)\n",
    "df = df.sort_values(by=['date'])\n",
    "\n",
    "#df.plot()\n",
    "\n",
    "#ates_test = \n",
    "nydates = df.index.to_list()[:22]\n",
    "lockdown_dates = df.index.to_list()[22:]\n",
    "\n",
    "df.head(22)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import curve_fit\n",
    "x = np.array(range(len(nydates)))\n",
    "y = np.array(df['cases'].tolist()[:22])\n",
    "\n",
    "def func(x, a, b, c):\n",
    "    return a * np.exp(-b * x) + c\n",
    "\n",
    "popt, pcov = curve_fit(func, x, y, p0=(1, 1e-6, 1))\n",
    "popt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xx = np.array(range(len(nydates) + len(lockdown_dates)))\n",
    "yy = func(xx, *popt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plt.plot(x, y, 'ko')\n",
    "#plt.plot(xx, yy)\n",
    "plt.plot(df.index.to_list(), df['cases'].to_list())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Drafts and Debugging For More Visualizations!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "\n",
    "df = px.data.election()\n",
    "geojson = px.data.election_geojson()\n",
    "\n",
    "#print(df[\"district\"][2])\n",
    "#print(geojson[\"features\"][0][\"properties\"])\n",
    "df = COVID19_US_counties[COVID19_US_counties['state'] == 'Alabama']\n",
    "df = df[df['date'] == '2020-04-01']\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "import json\n",
    "with urlopen('https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json') as response:\n",
    "    counties = json.load(response)\n",
    "\n",
    "import pandas as pd\n",
    "df = df\n",
    "\n",
    "import plotly.express as px\n",
    "\n",
    "fig = px.choropleth(df, geojson=counties, locations='fips', color='cases',\n",
    "                           color_continuous_scale=\"Viridis\",\n",
    "                           range_color=(0, 10000),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'cases':'cases'}\n",
    "                          )\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrieve_state_json(state):\n",
    "    custom = counties.copy()\n",
    "\n",
    "    for county in custom[\"features\"]:\n",
    "        if county['properties'][\"STATE\"] != \"01\":\n",
    "            custom[\"features\"].remove(county)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom = counties.copy()\n",
    "\n",
    "for county in custom[\"features\"]:\n",
    "    if county['properties'][\"STATE\"] != \"01\":\n",
    "        custom[\"features\"].remove(county)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "import json\n",
    "with urlopen('https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json') as response:\n",
    "    counties = json.load(response)\n",
    "\n",
    "import pandas as pd\n",
    "df = df\n",
    "\n",
    "import plotly.express as px\n",
    "\n",
    "fig = px.choropleth(df, geojson=custom, locations='fips', color='cases',\n",
    "                           color_continuous_scale=\"Viridis\",\n",
    "                           range_color=(0, 10000),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'cases':'cases'}\n",
    "                          )\n",
    "fig.update_geos(fitbounds=\"locations\")\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "\n",
    "df = df\n",
    "geojson = custom\n",
    "\n",
    "fig = px.choropleth(df, geojson=custom, color=\"cases\",\n",
    "                    locations=\"county\", featureidkey=\"01001\",\n",
    "                    projection=\"mercator\"\n",
    "                   )\n",
    "fig.update_geos(fitbounds=\"locations\", visible=True)\n",
    "fig.update_layout(margin={\"r\":0,\"t\":0,\"l\":0,\"b\":0})\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "custom['features'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BREAK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#New dataframes\n",
    "mapping = {country.name: country.alpha_3 for country in pycountry.countries}\n",
    "geo_confirmed = COVID19_confirmed.rename(index={'Korea, South': 'Korea, Republic of', 'US' :'United States', 'Taiwan*' :'Taiwan, Province of China', 'Vietnam':'Viet Nam', 'Russia': 'Russian Federation', 'Iran': 'Iran, Islamic Republic of', 'Tanzania': 'Tanzania, United Republic of', 'Laos': \"Lao People's Democratic Republic\", 'Syria': 'Syrian Arab Republic', 'Brunei': 'Brunei Darussalam', 'Venezuela': 'Venezuela, Bolivarian Republic of', 'Bolivia':  'Bolivia, Plurinational State of', 'Moldova': 'Moldova, Republic of'}).rename(index = lambda name: mapping.get(name))\n",
    "geo_deaths = COVID19_deaths.rename(index={'Korea, South': 'Korea, Republic of', 'US' :'United States', 'Taiwan*' :'Taiwan, Province of China', 'Vietnam':'Viet Nam', 'Russia': 'Russian Federation', 'Iran': 'Iran, Islamic Republic of', 'Tanzania': 'Tanzania, United Republic of', 'Laos': \"Lao People's Democratic Republic\", 'Syria': 'Syrian Arab Republic', 'Brunei': 'Brunei Darussalam', 'Venezuela': 'Venezuela, Bolivarian Republic of', 'Bolivia':  'Bolivia, Plurinational State of', 'Moldova': 'Moldova, Republic of'}).rename(index = lambda name: mapping.get(name))\n",
    "geo_recovered = COVID19_recovered.rename(index={'Korea, South': 'Korea, Republic of', 'US' :'United States', 'Taiwan*' :'Taiwan, Province of China', 'Vietnam':'Viet Nam', 'Russia': 'Russian Federation', 'Iran': 'Iran, Islamic Republic of', 'Tanzania': 'Tanzania, United Republic of', 'Laos': \"Lao People's Democratic Republic\", 'Syria': 'Syrian Arab Republic', 'Brunei': 'Brunei Darussalam', 'Venezuela': 'Venezuela, Bolivarian Republic of', 'Bolivia':  'Bolivia, Plurinational State of', 'Moldova': 'Moldova, Republic of'}).rename(index = lambda name: mapping.get(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "df = geo_deaths\n",
    "fig = px.choropleth(df, locations=df.index,\n",
    "                    color=\"2020-02-10\", # lifeExp is a column of gapminder\n",
    "                    range_color=(0, 10000),\n",
    "                    color_continuous_scale=Solarcorona,\n",
    "                   )\n",
    "\n",
    "fig.update_layout(\n",
    "    title_text = 'COVID-19 Cases Confirmed                        GitHub: briancpark',\n",
    ")\n",
    "\n",
    "fig.show()\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mask Usage\n",
    "Data was provided by the New York Times. Playing around with more data here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load mask usage database\n",
    "US_masks = pd.read_csv(\"databases/nytimes/mask-use/mask-use-by-county.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "US_masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "US_masks['COUNTYFP'] = US_masks['COUNTYFP'].apply(lambda x: '{0:0>5}'.format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.choropleth(US_masks, geojson=counties, locations='COUNTYFP', color='ALWAYS',\n",
    "                           color_continuous_scale=\"reds\",\n",
    "                           range_color=(0, 1),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'masks':'always'}\n",
    "                          )\n",
    "\n",
    "fig.update_layout(title_text = 'US Citizens Who Always Wears Masks in Social Distancing             GitHub:briancpark')\n",
    "fig.write_html(\"geo/us_mask_usage_html/always.html\")\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.choropleth(US_masks, geojson=counties, locations='COUNTYFP', color='FREQUENTLY',\n",
    "                           color_continuous_scale=\"reds\",\n",
    "                           range_color=(0, 1),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'masks':'always'}\n",
    "                          )\n",
    "\n",
    "fig.update_layout(title_text = 'US Citizens Who Frequently Wears Masks in Social Distancing             GitHub:briancpark')\n",
    "fig.write_html(\"geo/us_mask_usage_html/frequently.html\")\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.choropleth(US_masks, geojson=counties, locations='COUNTYFP', color='SOMETIMES',\n",
    "                           color_continuous_scale=\"reds\",\n",
    "                           range_color=(0, 1),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'masks':'always'}\n",
    "                          )\n",
    "\n",
    "fig.update_layout(title_text = 'US Citizens Who Sometimes Wears Masks in Social Distancing             GitHub:briancpark')\n",
    "fig.write_html(\"geo/us_mask_usage_html/sometimes.html\")\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.choropleth(US_masks, geojson=counties, locations='COUNTYFP', color='RARELY',\n",
    "                           color_continuous_scale=\"reds\",\n",
    "                           range_color=(0, 1),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'masks':'always'}\n",
    "                          )\n",
    "\n",
    "fig.update_layout(title_text = 'US Citizens Who Rarely Wears Masks in Social Distancing             GitHub:briancpark')\n",
    "fig.write_html(\"geo/us_mask_usage_html/rarely.html\")\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.choropleth(US_masks, geojson=counties, locations='COUNTYFP', color='NEVER',\n",
    "                           color_continuous_scale=\"reds\",\n",
    "                           range_color=(0, 1),\n",
    "                           scope=\"usa\",\n",
    "                           labels={'masks':'always'}\n",
    "                          )\n",
    "\n",
    "fig.update_layout(title_text = 'US Citizens Who Never Wears Masks in Social Distancing             GitHub:briancpark')\n",
    "fig.write_html(\"geo/us_mask_usage_html/never.html\")\n",
    "#fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = webdriver.ChromeOptions()\n",
    "options.add_argument('headless')\n",
    "options.add_argument('window-size=1920x1080');\n",
    "\n",
    "driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n",
    "driver.get(\"file:///Users/brianpark/Projects/COVID-19-Visualizations/geo/us_mask_usage_html/always.html\")\n",
    "time.sleep(3)\n",
    "driver.save_screenshot(\"geo/us_mask_usage/always.png\")\n",
    "driver.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = webdriver.ChromeOptions()\n",
    "options.add_argument('headless')\n",
    "options.add_argument('window-size=1920x1080');\n",
    "\n",
    "driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n",
    "driver.get(\"file:///Users/brianpark/Projects/COVID-19-Visualizations/geo/us_mask_usage_html/sometimes.html\")\n",
    "time.sleep(3)\n",
    "driver.save_screenshot(\"geo/us_mask_usage/sometimes.png\")\n",
    "driver.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = webdriver.ChromeOptions()\n",
    "options.add_argument('headless')\n",
    "options.add_argument('window-size=1920x1080');\n",
    "\n",
    "driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n",
    "driver.get(\"file:///Users/brianpark/Projects/COVID-19-Visualizations/geo/us_mask_usage_html/frequently.html\")\n",
    "time.sleep(3)\n",
    "driver.save_screenshot(\"geo/us_mask_usage/frequently.png\")\n",
    "driver.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = webdriver.ChromeOptions()\n",
    "options.add_argument('headless')\n",
    "options.add_argument('window-size=1920x1080');\n",
    "\n",
    "driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n",
    "driver.get(\"file:///Users/brianpark/Projects/COVID-19-Visualizations/geo/us_mask_usage_html/rarely.html\")\n",
    "time.sleep(3)\n",
    "driver.save_screenshot(\"geo/us_mask_usage/rarely.png\")\n",
    "driver.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "options = webdriver.ChromeOptions()\n",
    "options.add_argument('headless')\n",
    "options.add_argument('window-size=1920x1080');\n",
    "\n",
    "driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n",
    "driver.get(\"file:///Users/brianpark/Projects/COVID-19-Visualizations/geo/us_mask_usage_html/never.html\")\n",
    "time.sleep(3)\n",
    "driver.save_screenshot(\"geo/us_mask_usage/never.png\")\n",
    "driver.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import subprocess as cmd\n",
    "\n",
    "\n",
    "from datetime import date\n",
    "\n",
    "cmd.run(\"git add .\", check=True, shell=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cmd.run('git commit -m ' + '''\"''' + str(date.today()) + ''' update\"''', check=True, shell=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#os.system('git push')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git push"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}