Weather_Visualisation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\"> Group 17 </h1> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Presentors :\n",
    "<br>Pranjal Jain\n",
    "<br>Samratsinh Dhumal\n",
    "<br>Snigdh Chandra</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Phase 1:Creating Database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### importing packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import csv\n",
    "import sqlite3\n",
    "from sqlite3 import Error\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.dates as mdates\n",
    "plt.style.use('fivethirtyeight')\n",
    "import seaborn as sns\n",
    "from datetime import datetime\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import interact, interact_manual\n",
    "from IPython.display import clear_output\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Connecting to SQLite Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_connection(db_file, delete_db=False):\n",
    "    if delete_db and os.path.exists(db_file):\n",
    "        os.remove(db_file)\n",
    "    conn = None\n",
    "    try:\n",
    "        conn = sqlite3.connect(db_file)\n",
    "        conn.execute(\"PRAGMA foreign_keys = 1\")\n",
    "    except Error as e:\n",
    "        print(e)\n",
    "\n",
    "    return conn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating New Table Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_table(conn, create_table_sql):\n",
    "    try:\n",
    "        c = conn.cursor()\n",
    "        c.execute(create_table_sql)\n",
    "    except Error as e:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selecting from Table Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select(conn,selct_sql):\n",
    "    cur = conn.cursor()\n",
    "    try:\n",
    "        cur.execute(selct_sql)\n",
    "        names = list(map(lambda x: x[0], cur.description))\n",
    "        rows = cur.fetchall()\n",
    "    except Error as e:\n",
    "        names = e\n",
    "        rows = []\n",
    "    return [names,rows]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting from Table Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delete(conn,delete_sql):\n",
    "    cur = conn.cursor()\n",
    "    try:\n",
    "        cur.execute(delete_sql)\n",
    "        print(\"deleted\")\n",
    "    except Error as e:\n",
    "        print(\"not deleted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Table function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update(conn,update_sql):\n",
    "    cur = conn.cursor()\n",
    "    try:\n",
    "        cur.execute(update_sql)\n",
    "        #names = list(map(lambda x: x[0], cur.description))\n",
    "        #rows = cur.fetchall()\n",
    "        conn.commit()\n",
    "    except Error as e:\n",
    "        print(\"Failed to update\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create View"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_view(conn, create_view_sql):\n",
    "    try:\n",
    "        c = conn.cursor()\n",
    "        c.execute(create_view_sql)\n",
    "    except Error as e:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting csv File to SQLite File Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_as_sql(file,conn,table_name,index=False):\n",
    "    read_csv = pd.read_csv(file)\n",
    "    read_csv.to_sql(table_name, conn, index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "conn = create_connection('weather_data',True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Applications/anaconda3/lib/python3.7/site-packages/pandas/core/generic.py:2712: UserWarning:\n",
      "\n",
      "The spaces in these column names will not be changed. In pandas versions < 0.14, spaces were converted to underscores.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''save_as_sql('Dataset/historical-hourly-weather-data/city_attributes.csv',conn,'cities',False)\n",
    "save_as_sql('Dataset/historical-hourly-weather-data/humidity.csv',conn,'humidity',False)\n",
    "save_as_sql('Dataset/historical-hourly-weather-data/pressure.csv',conn,'pressure',False)\n",
    "save_as_sql('Dataset/historical-hourly-weather-data/temperature.csv',conn,'temperature',False)\n",
    "save_as_sql('Dataset/historical-hourly-weather-data/weather_description.csv',conn,'weather_description',False)\n",
    "save_as_sql('Dataset/historical-hourly-weather-data/wind_direction.csv',conn,'wind_direction',False)\n",
    "save_as_sql('Dataset/historical-hourly-weather-data/wind_speed.csv',conn,'wind_speed',False)\n",
    "save_as_sql('Dataset/USA_Historical_Tornado.csv',conn,'USA_Historical_Tornado',False)\n",
    "save_as_sql('Dataset/USA_CityCoordinates.csv',conn,'USA_City_Coordinates',False)'''\n",
    "\n",
    "save_as_sql('humidity.csv',conn,'humidity',False)\n",
    "save_as_sql('city_attributes.csv',conn,'cities',False)\n",
    "save_as_sql('pressure.csv',conn,'pressure',False)\n",
    "save_as_sql('temperature.csv',conn,'temperature',False)\n",
    "save_as_sql('weather_description.csv',conn,'weather_description',False)\n",
    "save_as_sql('wind_direction.csv',conn,'wind_direction',False)\n",
    "save_as_sql('wind_speed.csv',conn,'wind_speed',False)\n",
    "save_as_sql('USA_Historical_Tornado.csv',conn,'USA_Historical_Tornado',False)\n",
    "save_as_sql('USA_CityCoordinates.csv',conn,'USA_City_Coordinates',False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Cleaning Process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### deleting cities other than USA, empty rows, and cities with major missing values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deleted\n",
      "deleted\n",
      "deleted\n",
      "deleted\n",
      "deleted\n",
      "deleted\n",
      "deleted\n",
      "deleted\n",
      "deleted\n"
     ]
    }
   ],
   "source": [
    "delete(conn,\"DELETE FROM cities WHERE country != 'United States'\")\n",
    "delete(conn,\"DELETE FROM cities WHERE City = 'San Francisco'\")\n",
    "delete(conn,\"DELETE FROM cities WHERE City = 'Miami'\")\n",
    "delete(conn,\"DELETE FROM cities WHERE City = 'New York'\")\n",
    "delete(conn,\"Delete FROM humidity where datetime = '2012-10-01 12:00:00'\")\n",
    "delete(conn,\"Delete FROM pressure where datetime = '2012-10-01 12:00:00'\")\n",
    "delete(conn,\"Delete FROM wind_speed where datetime = '2012-10-01 12:00:00'\")\n",
    "delete(conn,\"Delete FROM wind_direction where datetime = '2012-10-01 12:00:00'\")\n",
    "delete(conn,\"Delete FROM temperature where datetime = '2012-10-01 12:00:00'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selcting all Cities of USA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "[names,city_name] = select(conn,\"Select city from cities\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating Null Values in Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "for city in city_name:\n",
    "    humidity_nullvalues_update = \"\"\"Update humidity set [\"\"\"+city[0]+\"\"\"] = (SELECT avg_val \n",
    "                                    from (Select AVG(h2.[\"\"\"+city[0]+\"\"\"]) as avg_val, Substr(h2.datetime,1,7) \n",
    "                                    as tdatet FROM humidity as h2 group by Substr(h2.datetime,1,7)) as temp1 \n",
    "                                    where Substr(humidity.datetime,1,7)=temp1.tdatet)\n",
    "                                    where datetime not in (SELECT h1.datetime FROM \n",
    "                                    humidity as h1 where [\"\"\"+city[0]+\"\"\"] >= 0)\"\"\"\n",
    "    update(conn,humidity_nullvalues_update)\n",
    "\n",
    "    temperature_nullvalues_update = \"\"\"Update temperature set [\"\"\"+city[0]+\"\"\"] = (SELECT avg_val \n",
    "                                       from (Select AVG(t2.[\"\"\"+city[0]+\"\"\"]) as avg_val, Substr(t2.datetime,1,7) as tdatet FROM temperature as t2 group by Substr(t2.datetime,1,7)) as temp1 \n",
    "                                       where Substr(temperature.datetime,1,7)=temp1.tdatet)\n",
    "    where datetime not in (SELECT t2.datetime FROM temperature as t2 where  [\"\"\"+city[0]+\"\"\"] >= 0)\"\"\"\n",
    "    update(conn,temperature_nullvalues_update)\n",
    "    \n",
    "    pressure_nullvalues_update = \"\"\"Update pressure set [\"\"\"+city[0]+\"\"\"] = (SELECT avg_val \n",
    "                                       from (Select AVG(p2.[\"\"\"+city[0]+\"\"\"]) as avg_val, Substr(p2.datetime,1,7) as tdatet FROM pressure as p2 group by Substr(p2.datetime,1,7)) as temp1 \n",
    "                                       where Substr(pressure.datetime,1,7)=temp1.tdatet)\n",
    "    where datetime not in (SELECT p2.datetime FROM pressure as p2 where  [\"\"\"+city[0]+\"\"\"] >= 0)\"\"\"\n",
    "    update(conn,pressure_nullvalues_update)\n",
    "    \n",
    "    winddir_nullvalues_update = \"\"\"Update wind_direction set [\"\"\"+city[0]+\"\"\"] = (SELECT avg_val \n",
    "                                       from (Select AVG(wd2.[\"\"\"+city[0]+\"\"\"]) as avg_val, Substr(wd2.datetime,1,7) as tdatet FROM wind_direction as wd2 group by Substr(wd2.datetime,1,7)) as temp1 \n",
    "                                       where Substr(wind_direction.datetime,1,7)=temp1.tdatet)\n",
    "    where datetime not in (SELECT wd2.datetime FROM wind_direction as wd2 where  [\"\"\"+city[0]+\"\"\"] >= 0)\"\"\"\n",
    "    update(conn,winddir_nullvalues_update)\n",
    "    \n",
    "    windsp_nullvalues_update = \"\"\"Update wind_speed set [\"\"\"+city[0]+\"\"\"] = (SELECT avg_val \n",
    "                                       from (Select AVG(ws2.[\"\"\"+city[0]+\"\"\"]) as avg_val, Substr(ws2.datetime,1,7) as tdatet FROM wind_speed as ws2 group by Substr(ws2.datetime,1,7)) as temp1 \n",
    "                                       where Substr(wind_speed.datetime,1,7)=temp1.tdatet)\n",
    "    where datetime not in (SELECT ws2.datetime FROM wind_speed as ws2 where  [\"\"\"+city[0]+\"\"\"] >= 0)\"\"\"\n",
    "    update(conn,windsp_nullvalues_update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function to Round City Coordinate to Join Two Tables  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coord_round_dwn(a):\n",
    "    if(a<0):\n",
    "        b = math.floor(abs(a));\n",
    "        return (b*(-1));\n",
    "    else:\n",
    "        return (round(a))\n",
    "    \n",
    "def getcities(tl):\n",
    "    att = {}\n",
    "    for at in tl:\n",
    "        if(at in att):\n",
    "            att[at] = att[at]+1;\n",
    "        else:\n",
    "            att[at] = 1\n",
    "    #print(att)\n",
    "    return(list(att.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rounding Coordinate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "str = '''Select U2.City,U2.Latitude,U2.Longitude,U1.state_name,U1.lat,U1.lng \n",
    "        from USA_City_Coordinates as U1 INNER JOIN cities as U2 on U1.city = U2.City \n",
    "        WHERE U2.Country='United States' and \n",
    "        round(U1.lat) = round(U2.Latitude) and \n",
    "        round(U1.lng) = round(U2.Longitude)'''\n",
    "\n",
    "[a,b] = select(conn,str)\n",
    "lama = []\n",
    "asas = []\n",
    "for l1 in b:\n",
    "    l = (l1[0],coord_round_dwn(l1[1]),coord_round_dwn(l1[2]),l1[3],coord_round_dwn(l1[4]),coord_round_dwn(l1[5]))\n",
    "    lama.append(l)\n",
    "    asas.append(l[0])\n",
    "final_cities = getcities(asas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a joint table for all data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "for city in city_name:\n",
    "    str = \"\"\"CREATE VIEW [\"\"\"+city[0]+\"\"\"_info] \n",
    "            (DateTime,Humidity,Weather_Description,Pressure,Temperature,Wind_Direction,Wind_Speed)\n",
    "             AS \n",
    "             Select h1.datetime,h1.[\"\"\"+city[0]+\"\"\"] as Humidity,wd1.[\"\"\"+city[0]+\"\"\"] as Weather_Description,\n",
    "             p1.[\"\"\"+city[0]+\"\"\"] as Pressure,t1.[\"\"\"+city[0]+\"\"\"] as Temperature,widir.[\"\"\"+city[0]+\"\"\"] as Wind_Direction,\n",
    "             wsp.[\"\"\"+city[0]+\"\"\"] as Wind_Speed\n",
    "             from humidity as h1 \n",
    "             INNER JOIN weather_description as wd1 on h1.datetime=wd1.datetime \n",
    "             INNER JOIN pressure as p1 on h1.datetime=p1.datetime \n",
    "             INNER JOIN temperature as t1 on h1.datetime=t1.datetime \n",
    "             INNER JOIN wind_direction as widir on h1.datetime=widir.datetime \n",
    "             INNER JOIN wind_speed as wsp on h1.datetime=wsp.datetime\"\"\"\n",
    "    \n",
    "    (create_view(conn,str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Displaying cities  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'Portland', 1: 'Seattle', 2: 'Los Angeles', 3: 'San Diego', 4: 'Las Vegas', 5: 'Phoenix', 6: 'Albuquerque', 7: 'Denver', 8: 'San Antonio', 9: 'Dallas', 10: 'Houston', 11: 'Kansas City', 12: 'Minneapolis', 13: 'Saint Louis', 14: 'Chicago', 15: 'Nashville', 16: 'Indianapolis', 17: 'Atlanta', 18: 'Detroit', 19: 'Jacksonville', 20: 'Charlotte', 21: 'Pittsburgh', 22: 'Philadelphia', 23: 'Boston'}\n"
     ]
    }
   ],
   "source": [
    "str2 = \"SELECT name FROM sqlite_master WHERE type = 'view'\"\n",
    "[temp1,temp2] = select(conn,str2)\n",
    "cityview_list = []\n",
    "cityview_dict = {}\n",
    "i = 0\n",
    "for temp3 in temp2:\n",
    "    cityview_list.append(temp3[0])\n",
    "    cityview_dict[i] = temp3[0][:-5]\n",
    "    i = i + 1\n",
    "print(cityview_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter index number for desired city values:\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: ''",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-03e76a645bda>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mindex1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Please enter index number for desired city values:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'\\033[1m'\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mcityview_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m\" Data\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mcity_val\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcityview_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mstr3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"SELECT * FROM [\"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mcity_val\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m\"]\"\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mcity_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_sql_query\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mconn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: ''"
     ]
    }
   ],
   "source": [
    "index1 = int(input(\"Please enter index number for desired city values:\"))\n",
    "print('\\033[1m'+cityview_dict[index1]+\" Data\")\n",
    "city_val = cityview_list[index1]\n",
    "str3 = \"SELECT * FROM [\"+city_val+\"]\";\n",
    "city_df = pd.read_sql_query(str3,conn)\n",
    "city_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ploting Given City and Parameter Over Years Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def years_plot(city='Portland',parameter='humidity',frequency = 'M'):\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from \"+ parameter +\";\"\n",
    "    [names,parameter_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_parameter = pd.DataFrame(parameter_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_parameter = city_parameter.set_index([0])\n",
    "    city_parameter.index = pd.to_datetime(city_parameter.index)\n",
    "    \n",
    "    #plot\n",
    "    city_parameter.asfreq(frequency).plot()\n",
    "    plt.title(parameter + ' in '+ city +' over time')\n",
    "    plt.xlabel('Years')\n",
    "    plt.ylabel('Value')\n",
    "    plt.show()\n",
    "\n",
    "##\n",
    "years_plot('Portland','humidity','M')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ploting Given City and Parameter Over a Year Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-e0b79dd3e4c3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0;31m##\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m \u001b[0myearly_plot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Portland'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'humidity'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'W'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2016\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-20-e0b79dd3e4c3>\u001b[0m in \u001b[0;36myearly_plot\u001b[0;34m(city, parameter, frequency, year)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0myearly_plot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcity\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Portland'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mparameter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'humidity'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfrequency\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'M'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0myear\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2016\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mstring\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Select datetime,\\\"\"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mcity\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m\"\\\" from \"\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0;34m+\u001b[0m\u001b[0;34m\" WHERE datetime LIKE '\"\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myear\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m\u001b[0;34m\"%';\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;34m[\u001b[0m\u001b[0mnames\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mparameter_list\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mselect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mstring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;31m#converting to dataframe\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object is not callable"
     ]
    }
   ],
   "source": [
    "def yearly_plot(city='Portland',parameter='humidity',frequency = 'M',year=2016):  \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from \"+ parameter +\" WHERE datetime LIKE '\"+ str(year) +\"%';\"\n",
    "    [names,parameter_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_parameter = pd.DataFrame(parameter_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_parameter = city_parameter.set_index([0])\n",
    "    city_parameter.index = pd.to_datetime(city_parameter.index)\n",
    "    \n",
    "    #plot\n",
    "    city_parameter.asfreq(frequency).plot()\n",
    "    plt.title(parameter + ' in '+ city +' City over time for a year' + str(year))\n",
    "    plt.xlabel('Month')\n",
    "    plt.ylabel('Value')\n",
    "    plt.show()\n",
    "\n",
    "    \n",
    "##\n",
    "yearly_plot('Portland','humidity','W',2016)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting Given City and Parameter over Year Stacked for Comparision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'''def yearly_stacked_plot(city='Portland',parameter='humidity',frequency = 'M',years=[2016]):\n",
    "    for year in years: \n",
    "        string = \"Select datetime,\\\"\"+city+\"\\\" from \"+ parameter +\" WHERE datetime LIKE '\"+ str(year) +\"%';\"\n",
    "        [names,parameter_list] = select(conn,string)\n",
    "        \n",
    "        datetime = []\n",
    "        for element in parameter_list:\n",
    "            datetime.append(str(element)[7:21])\n",
    "            \n",
    "        city_datatime = pd.DataFrame(datetime)\n",
    "        \n",
    "        #converting to dataframe\n",
    "        city_parameter = pd.DataFrame(parameter_list)\n",
    "        \n",
    "        city_parameter['datetime'] = city_datatime\n",
    "        \n",
    "        #setting datetime as index\n",
    "        city_parameter = city_parameter.set_index(['datetime'])\n",
    "        city_parameter.index = pd.to_datetime(city_parameter.index,format=\"%m-%d %H:%M:%S\",errors='ignore')\n",
    "        \n",
    "        #plot\n",
    "        \n",
    "        city_parameter.asfreq(frequency).plot()\n",
    "        #plt.title(parameter + ' in '+ city +' City over time for a year' + str(year))\n",
    "\n",
    "##\n",
    "plt.figure(figsize =(20,20))\n",
    "yearly_stacked_plot('Portland','humidity','M',[2014,2015])\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### City Parameter Graph Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def city_parameter(city='Portland'):\n",
    "    \n",
    "    plt.figure(figsize =(20,20))\n",
    "    \n",
    "    #defining subplot\n",
    "    plt.subplot(3,3,1)\n",
    "    \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from pressure;\"\n",
    "    [names,pressure_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_pressure = pd.DataFrame(pressure_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_pressure = city_pressure.set_index([0])\n",
    "    city_pressure.index = pd.to_datetime(city_pressure.index)\n",
    "    \n",
    "    city_pressure = city_pressure.dropna()\n",
    "    \n",
    "    sns.distplot(city_pressure,color='blue')\n",
    "    plt.title('Distribution of pressure')\n",
    "    plt.xlabel('Freq')\n",
    "    plt.ylabel('Value')\n",
    "    \n",
    "    #defining subplot\n",
    "    plt.subplot(3,3,2)\n",
    "    \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from temperature;\"\n",
    "    [names,temperature_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_temperature = pd.DataFrame(temperature_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_temperature = city_temperature.set_index([0])\n",
    "    city_temperature.index = pd.to_datetime(city_temperature.index)\n",
    "    \n",
    "    city_temperature = city_temperature.dropna()\n",
    "    \n",
    "    sns.distplot(city_temperature,color='red')\n",
    "    plt.title('Distribution of temperature')\n",
    "    plt.xlabel('Freq')\n",
    "    plt.ylabel('Value')\n",
    "    \n",
    "    #defining subplot\n",
    "    plt.subplot(3,3,3)\n",
    "    \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from humidity;\"\n",
    "    [names,humidity_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_humidity = pd.DataFrame(humidity_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_humidity = city_humidity.set_index([0])\n",
    "    city_humidity.index = pd.to_datetime(city_humidity.index)\n",
    "    \n",
    "    city_humidity = city_humidity.dropna()\n",
    "    \n",
    "    sns.distplot(city_humidity,color='magenta')\n",
    "    plt.title('Distribution of humidity')\n",
    "    plt.xlabel('Freq')\n",
    "    plt.ylabel('Value')\n",
    "    \n",
    "    #defining subplot\n",
    "    plt.subplot(3,3,4)\n",
    "    \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from wind_speed;\"\n",
    "    [names,windspeed_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_windspeed = pd.DataFrame(windspeed_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_windspeed = city_windspeed.set_index([0])\n",
    "    city_windspeed.index = pd.to_datetime(city_windspeed.index)\n",
    "    \n",
    "    city_windspeed = city_windspeed.dropna()\n",
    "    \n",
    "    sns.distplot(city_windspeed,color='brown')\n",
    "    plt.title('Distribution of wind speed')\n",
    "    plt.xlabel('Freq')\n",
    "    plt.ylabel('Value')\n",
    "    \n",
    "    #defining subplot\n",
    "    plt.subplot(3,3,5)\n",
    "    \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from wind_direction;\"\n",
    "    [names,winddirection_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_winddirection = pd.DataFrame(winddirection_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_winddirection = city_winddirection.set_index([0])\n",
    "    city_winddirection.index = pd.to_datetime(city_winddirection.index)\n",
    "    \n",
    "    city_winddirection = city_winddirection.dropna()\n",
    "    \n",
    "    sns.distplot(city_winddirection,color='yellow')\n",
    "    plt.title('Distribution of wind direction')\n",
    "    plt.xlabel('Freq')\n",
    "    plt.ylabel('Value')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "##\n",
    "city_parameter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameter Relation Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_relation(city='Portland',parameter1='humdity',parameter2='temperature'):\n",
    "    \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from \"+ parameter1 +\";\"\n",
    "    [names,parameter1_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_parameter1 = pd.DataFrame(parameter1_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_parameter1 = city_parameter1.set_index([0])\n",
    "    city_parameter1.index = pd.to_datetime(city_parameter1.index)\n",
    "    \n",
    "    #city_parameter1 = city_parameter1.dropna()\n",
    "    \n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from \"+ parameter2 +\";\"\n",
    "    [names,city_parameter2_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_parameter2 = pd.DataFrame(city_parameter2_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_parameter2 = city_parameter2.set_index([0])\n",
    "    city_parameter2.index = pd.to_datetime(city_parameter2.index)\n",
    "    \n",
    "    #city_parameter2 = city_parameter2.dropna()\n",
    "    \n",
    "    plt.scatter(x=city_parameter1,y=city_parameter2,color='orange')\n",
    "    plt.title(parameter1 + ' vs '+ parameter2)\n",
    "    plt.xlabel(parameter1)\n",
    "    plt.ylabel(parameter2)\n",
    "    plt.show()\n",
    "    \n",
    "##\n",
    "parameter_relation('New York','pressure','wind_speed')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Weather Description Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def city_weather_description(city='Boston'):\n",
    "    \n",
    "    plt.figure(figsize=(30,30))\n",
    "    \n",
    "    string = \"\"\"Select p.datetime,p.[\"\"\"+city+\"\"\"],wd.[\"\"\"+city+\"\"\"]\n",
    "                 from pressure as p\n",
    "                 INNER JOIN weather_description as wd on p.datetime=wd.datetime\"\"\"\n",
    "    \n",
    "    [names,pressure_description_list] = select(conn,string)\n",
    "    \n",
    "    #converting to dataframe\n",
    "    city_pressure_description = pd.DataFrame(pressure_description_list)\n",
    "    \n",
    "    #setting datetime as index\n",
    "    city_pressure_description = city_pressure_description.set_index([0])\n",
    "    city_pressure_description.index = pd.to_datetime(city_pressure_description.index)\n",
    "    \n",
    "    city_pressure_description.groupby(2).count()[1].plot(kind='bar',color='purple')\n",
    "    plt.title('Count of Weather Description',fontsize= 30)\n",
    "    plt.xlabel('Weather Description', fontsize= 30)\n",
    "    plt.rcParams.update({'font.size': 30})\n",
    "    \n",
    "  \n",
    "##\n",
    "city_weather_description()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### City Monthly Parameter Flactualtion Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_monthly_flctuations(city='Portland'):\n",
    "    \n",
    "    #plot figure\n",
    "    plt.figure(figsize=(15,15))\n",
    "    \n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from temperature;\"\n",
    "    [names,temperature_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_temperature = pd.DataFrame(temperature_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_temperature[0])\n",
    "    city_temperature['month']=time.month\n",
    "\n",
    "    plt.subplot(3,3,1)\n",
    "    plot_temperature = sns.boxplot(x='month',y=1,data=city_temperature)\n",
    "    plot_temperature.set(ylabel=\"Tempreture\")\n",
    "    plt.title('Temperature across month box plot')\n",
    "    \n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from pressure;\"\n",
    "    [names,pressure_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_pressure = pd.DataFrame(pressure_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_pressure[0])\n",
    "    city_pressure['month']=time.month\n",
    "    \n",
    "    plt.subplot(3,3,2)\n",
    "    plot_pressure = sns.boxplot(x='month',y=1,data=city_pressure)\n",
    "    plot_pressure.set(ylabel=\"Pressure\")\n",
    "    plt.title('Pressure across month box plot')\n",
    "    \n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from humidity;\"\n",
    "    [names,humidity_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_humidity = pd.DataFrame(humidity_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_humidity[0])\n",
    "    city_humidity['month']=time.month\n",
    "    \n",
    "    plt.subplot(3,3,3)\n",
    "    plot_humidity = sns.boxplot(x='month',y=1,data=city_humidity)\n",
    "    plot_humidity.set(ylabel=\"Humidity\")\n",
    "    plt.title('Humidity across month box plot')\n",
    "    \n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from wind_speed;\"\n",
    "    [names,windspeed_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_windspeed = pd.DataFrame(windspeed_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_windspeed[0])\n",
    "    city_windspeed['month']=time.month\n",
    "    \n",
    "    plt.subplot(3,3,4)\n",
    "    plot_windspeed = sns.boxplot(x='month',y=1,data=city_windspeed)\n",
    "    plot_windspeed.set(ylabel=\"Wind speed\")\n",
    "    plt.title('Wind speed across month box plot')\n",
    "    \n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from wind_direction;\"\n",
    "    [names,winddirection_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_winddirection = pd.DataFrame(winddirection_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_winddirection[0])\n",
    "    city_winddirection['month']=time.month\n",
    "    \n",
    "    plt.subplot(3,3,5)\n",
    "    plot_winddirection = sns.boxplot(x='month',y=1,data=city_winddirection)\n",
    "    plot_winddirection.set(ylabel=\"Wind direction\")\n",
    "    \n",
    "    plt.title('Wind direction across month box plot')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "parameter_monthly_flctuations()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### City Weekly Parameter Flactualtion Over Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_weekly_flctuations(city='Portland'):\n",
    "\n",
    "    #plot figure\n",
    "    plt.figure(figsize=(15,15))\n",
    "\n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from temperature;\"\n",
    "    [names,temperature_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_temperature = pd.DataFrame(temperature_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_temperature[0])\n",
    "    city_temperature['week']=time.week\n",
    "\n",
    "    plt.subplot(3,3,1)\n",
    "    plot_temperature = sns.lineplot(x='week',y=1,data=city_temperature)\n",
    "    plot_temperature.set(ylabel=\"Tempreture\")\n",
    "    plt.title('Temperature across week box plot')\n",
    "\n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from pressure;\"\n",
    "    [names,pressure_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_pressure = pd.DataFrame(pressure_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_pressure[0])\n",
    "    city_pressure['week']=time.week\n",
    "\n",
    "    plt.subplot(3,3,2)\n",
    "    plot_pressure = sns.lineplot(x='week',y=1,data=city_pressure)\n",
    "    plot_pressure.set(ylabel=\"Pressure\")\n",
    "    plt.title('Pressure across month box plot')\n",
    "\n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from humidity;\"\n",
    "    [names,humidity_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_humidity = pd.DataFrame(humidity_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_humidity[0])\n",
    "    city_humidity['week']=time.week\n",
    "\n",
    "    plt.subplot(3,3,3)\n",
    "    plot_humidity = sns.lineplot(x='week',y=1,data=city_humidity)\n",
    "    plot_humidity.set(ylabel=\"Humidity\")\n",
    "    plt.title('Humidity across week box plot')\n",
    "\n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from wind_speed;\"\n",
    "    [names,windspeed_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_windspeed = pd.DataFrame(windspeed_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_windspeed[0])\n",
    "    city_windspeed['week']=time.week\n",
    "\n",
    "    plt.subplot(3,3,4)\n",
    "    plot_windspeed = sns.lineplot(x='week',y=1,data=city_windspeed)\n",
    "    plot_windspeed.set(ylabel=\"Wind speed\")\n",
    "    plt.title('Wind speed across week box plot')\n",
    "\n",
    "    #SQL\n",
    "    string = \"Select datetime,\\\"\"+city+\"\\\" from wind_direction;\"\n",
    "    [names,winddirection_list] = select(conn,string)\n",
    "\n",
    "    #convert ing to dataframe\n",
    "    city_winddirection = pd.DataFrame(winddirection_list)\n",
    "\n",
    "    #setting datetime as index\n",
    "    time = pd.DatetimeIndex(city_winddirection[0])\n",
    "    city_winddirection['week']=time.week\n",
    "\n",
    "    plt.subplot(3,3,5)\n",
    "    plot_winddirection = sns.lineplot(x='week',y=1,data=city_winddirection)\n",
    "    plot_winddirection.set(ylabel=\"Wind direction\")\n",
    "\n",
    "    plt.title('Wind direction across week box plot')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "parameter_weekly_flctuations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Yr_df = pd.read_sql_query(\"SELECT DISTINCT Yr from USA_Historical_Tornado\", conn)\n",
    "Tor_df = pd.read_sql_query(\"SELECT st,len,\\\"start lat\\\",\\\"start lon\\\",\\\"fin lat\\\",\\\"fin lon\\\" from USA_Historical_Tornado WHERE Yr = 1950\", conn)\n",
    "City_at_df = pd.read_sql_query(\"Select City,Latitude,Longitude from cities WHERE country = 'United States'\", conn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Yr_list = Yr_df['Yr'].values.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m=widgets.Dropdown(\n",
    "    options=Yr_list,\n",
    "    description='Year:',\n",
    "    disabled=False,\n",
    ")\n",
    "display(m)\n",
    "fig = go.Figure()\n",
    "\n",
    "\n",
    "fig.add_trace(go.Scattergeo(\n",
    "        locationmode = 'USA-states',\n",
    "        lon = Tor_df['start lon'],\n",
    "        lat = Tor_df['start lat'],\n",
    "        text = Tor_df['st'],\n",
    "        mode = 'markers',\n",
    "        marker = dict(\n",
    "            size = 8,\n",
    "            opacity = 0.8,\n",
    "            reversescale = False,\n",
    "            autocolorscale = False,\n",
    "            symbol = 'square',\n",
    "            line = dict(\n",
    "                width=0.1,\n",
    "                color='black'\n",
    "            ),\n",
    "            colorscale = 'darkmint',\n",
    "            cmin = 0,\n",
    "            color = Tor_df['len'],\n",
    "            cmax = Tor_df['len'].max(),\n",
    "            colorbar_title=\"Length of Tornadoes\"\n",
    "        )))\n",
    "\n",
    "fig.add_trace(go.Scattergeo(\n",
    "    locationmode = 'USA-states',\n",
    "    text = City_at_df['City'],   \n",
    "    lon = City_at_df['Longitude'],\n",
    "    lat = City_at_df['Latitude'],\n",
    "    mode = 'markers+text',\n",
    "    textposition = 'bottom center',\n",
    "    marker_color = 'maroon',\n",
    "    ))\n",
    "\n",
    "\n",
    "fig.update_layout(\n",
    "    title_text = 'Tornadoes in the Year 1950',\n",
    "    showlegend = False,\n",
    "    geo = go.layout.Geo(\n",
    "        scope = 'usa',\n",
    "        projection_type = 'albers usa',\n",
    "        showland = True,\n",
    "        landcolor = 'lightgray',\n",
    "        countrycolor = 'white',\n",
    "    ),\n",
    ")\n",
    "\n",
    "fig.show()\n",
    "\n",
    "def on_change(change):\n",
    "    clear_output()\n",
    "    display(m)\n",
    "    input_val=str(change['owner'])[-5:-1]\n",
    "    Tor_df = pd.read_sql_query(\"SELECT st,len,\\\"start lat\\\",\\\"start lon\\\",\\\"fin lat\\\",\\\"fin lon\\\" from USA_Historical_Tornado WHERE Yr =\"+input_val, conn)\n",
    "    \n",
    "    fig = go.Figure()\n",
    "\n",
    "    fig.add_trace(go.Scattergeo(\n",
    "        locationmode = 'USA-states',\n",
    "        lon = Tor_df['start lon'],\n",
    "        lat = Tor_df['start lat'],\n",
    "        text = Tor_df['st'],\n",
    "        mode = 'markers',\n",
    "        marker = dict(\n",
    "            size = 8,\n",
    "            opacity = 0.8,\n",
    "            reversescale = False,\n",
    "            autocolorscale = False,\n",
    "            symbol = 'square',\n",
    "            line = dict(\n",
    "                width=0.1,\n",
    "                color='black'\n",
    "            ),\n",
    "            colorscale = 'darkmint',\n",
    "            cmin = 0,\n",
    "            color = Tor_df['len'],\n",
    "            cmax = Tor_df['len'].max(),\n",
    "            colorbar_title=\"Length of Tornadoes\"\n",
    "    )))\n",
    "\n",
    "    fig.add_trace(go.Scattergeo(\n",
    "        locationmode = 'USA-states',\n",
    "        text = City_at_df['City'],   \n",
    "        lon = City_at_df['Longitude'],\n",
    "        lat = City_at_df['Latitude'],\n",
    "        mode = 'markers+text',\n",
    "        textposition = 'bottom center',\n",
    "        marker_color = 'maroon',\n",
    "    ))\n",
    "\n",
    "\n",
    "    fig.update_layout(\n",
    "        title_text = 'Tornadoes in the Year '+input_val,\n",
    "        showlegend = False,\n",
    "        geo = go.layout.Geo(\n",
    "            scope = 'usa',\n",
    "            projection_type = 'albers usa',\n",
    "            showland = True,\n",
    "            landcolor = 'lightgray',\n",
    "            countrycolor = 'white',\n",
    "        ),\n",
    "    )\n",
    "\n",
    "    fig.show()\n",
    "m.observe(on_change)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}