climate_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import all my dependencies\n",
    "%matplotlib inline\n",
    "from matplotlib import style\n",
    "style.use('fivethirtyeight')\n",
    "import matplotlib.pyplot as plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import datetime as dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reflect Tables into SQLAlchemy ORM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python SQL toolkit and Object Relational Mapper\n",
    "import sqlalchemy\n",
    "from sqlalchemy.ext.automap import automap_base\n",
    "from sqlalchemy.orm import Session\n",
    "from sqlalchemy import create_engine, func, asc\n",
    "from sqlalchemy import inspect\n",
    "from sqlalchemy.sql import func\n",
    "from sqlalchemy import extract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pymysql\n",
    "pymysql.install_as_MySQLdb()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step 1: establish connection to the engine (db) [5 steps]\n",
    "# papa\n",
    "engine = create_engine(\"sqlite:///hawaii.sqlite\")\n",
    "#prints the tables names directly form the \"engine\" \n",
    "#print(engine.table_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['measurement', 'station']\n"
     ]
    }
   ],
   "source": [
    "# optional: use inspect() to obtain table names\n",
    "# Entry point to SQLAlchemy’s public API for viewing the configuration and construction of in-memory objects\n",
    "# https://docs.sqlalchemy.org/en/latest/core/inspection.html\n",
    "inspector = inspect(engine)\n",
    "print(inspector.get_table_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step 2: reflect an existing database into a new model\n",
    "Base = automap_base()\n",
    "\n",
    "# reflect the tables\n",
    "Base.prepare(engine, reflect=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['measurement', 'station']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# view all of the classes(tables) found using automap() \n",
    "Base.classes.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step 3: save references to each table\n",
    "Measurement = Base.classes.measurement\n",
    "Station = Base.classes.station"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(Measurement)\n",
    "# what does \"ext\" in the output reference?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step 4: create our session(link) to the DB\n",
    "# nieto\n",
    "session = Session(engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#station_list = session.query(Station).order_by(Station.name.desc())\n",
    "#for one in station_list:\n",
    " #   print(one.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Precipitation Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('2017-08-23'),\n",
       " ('2017-08-23'),\n",
       " ('2017-08-23'),\n",
       " ('2017-08-23'),\n",
       " ('2017-08-22')]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Design a query to retrieve the last 12 months of precipitation data and plot the results:\n",
    "\n",
    "# 1.calculate the date 1 year ago from the last data point in the database #'2017-08-23'\n",
    "session.query(Measurement.date).order_by(Measurement.date.desc()).limit(5).all()\n",
    "#for each in List:\n",
    "#   print(each.date) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.perform a query to retrieve the data and precipitation scores\n",
    "#   displays all data from all columns in table \"Measurements\" for dates  2016-08-23 to 2017-08-23\n",
    "prcp_data = session.query(Measurement).filter(Measurement.date <= '2017-08-23').\\\n",
    "        filter(Measurement.date >= '2016-08-23')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.save the query results as a Pandas DataFrame \n",
    "precip_df = pd.read_sql_query(prcp_data.statement, session.bind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3b.displays all data from columns: \"date\"(set as index), and \"prcp\"\n",
    "data_index = precip_df[[\"date\",\"prcp\"]].set_index(\"date\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data_index.to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>prcp</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2016-08-23</th>\n",
       "      <td>2.71</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-08-24</th>\n",
       "      <td>9.33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-08-25</th>\n",
       "      <td>0.54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-08-26</th>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-08-27</th>\n",
       "      <td>0.32</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            prcp\n",
       "date            \n",
       "2016-08-23  2.71\n",
       "2016-08-24  9.33\n",
       "2016-08-25  0.54\n",
       "2016-08-26  0.10\n",
       "2016-08-27  0.32"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4.sort the dataframe by date, and sum \"prcp\" data == showcasing total amount of precipitation per day\n",
    "data_index.groupby([\"date\"]).sum().head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": false
   },
   "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": [
    "# 5.use Pandas Plotting with Matplotlib to plot the data \n",
    "plot_prcp = data_index.plot(color='lightblue', alpha=0.95)\n",
    "plot.xticks([])\n",
    "plot.xlabel(\"date\")\n",
    "plot.legend(loc=0)\n",
    "plot.show(plot_prcp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>prcp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>2021.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.177279</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.461190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.020000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>0.130000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>6.700000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              prcp\n",
       "count  2021.000000\n",
       "mean      0.177279\n",
       "std       0.461190\n",
       "min       0.000000\n",
       "25%       0.000000\n",
       "50%       0.020000\n",
       "75%       0.130000\n",
       "max       6.700000"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 6.summary statistics for the precipitation data\n",
    "data_index.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Station Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 7.query shows how many stations are available in this dataset\n",
    "session.query(Station).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\MARIA JOSE\\Anaconda3\\lib\\site-packages\\sqlalchemy\\sql\\compiler.py:643: SAWarning: Can't resolve label reference 'total DESC'; converting to text() (this warning may be suppressed after 10 occurrences)\n",
      "  util.ellipses_string(element.element))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('USC00519281', 2772),\n",
       " ('USC00519397', 2724),\n",
       " ('USC00513117', 2709),\n",
       " ('USC00519523', 2669),\n",
       " ('USC00516128', 2612),\n",
       " ('USC00514830', 2202),\n",
       " ('USC00511918', 1979),\n",
       " ('USC00517948', 1372),\n",
       " ('USC00518838', 511)]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 8.list most active stations and the counts in descending order\n",
    "session.query(Measurement.station, func.count(Measurement.station).label('total')).group_by(Measurement.station).order_by('total DESC').all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(54.0, 85.0, 71.66378066378067)]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 9. calculate the low temp,high temp, and avg temp using most active station\n",
    "session.query(func.min(Measurement.tobs), func.max(Measurement.tobs), func.avg(Measurement.tobs)).filter(Measurement.station == 'USC00519281').all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choose the station with the highest number of temperature observations. \n",
    "\n",
    "# 10.query the last 12 months of temperature observation data for this station\n",
    "#  filter on table, col='USC00519281', and chosen date, order by number of tol ASC\n",
    "pstation = session.query(Measurement.tobs, Measurement.date).filter(Measurement.station == 'USC00519281').filter(Measurement.date <= '2017-08-23').\\\n",
    "        filter(Measurement.date >= '2016-08-23')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 10b.save query as Df  \n",
    "popstationdf = pd.read_sql_query(pstation.statement, session.bind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAacAAAD1CAYAAAD03jrQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAFV5JREFUeJzt3XGwnXV95/H3NyExKskNlwIbJU2gnqXFzkoU2RAyVghWa4uhRhcdWrMdGHdmga07lRa0LotTF9tqq7vjoBig2U4rUko26G7bgVRbMkLWkYAKsRwKCURC0ITccLu1AfLdP85zk8slN7kn99zn+eWe92vmzjnPc85znu/9zXPzye95fuf3RGYiSVJJZjRdgCRJYxlOkqTiGE6SpOIYTpKk4hhOkqTiHNd0AYczNDTkUEJJmuYGBgZi7Dp7TpKk4hhOkqTiGE5H0G63my6hWLbN+Gyb8dk247NtDjKcJEnFMZwkScUperSeJPWDzGR4eJg5c+YwNDTUdDk9N2PGDI4//ngiXjEob1yGkyQ1bHh4mFe96lWcdNJJzJkzp+lyem7fvn0MDw8zd+7cCW/jaT1Jatj+/fuZPXt202VMmdmzZ7N///6utjGcJEnFMZwkqc/t2bOHNWvWHPY99957L5dccklNFXnNSVLNbto2i8HhvbXu89ol82rd32TdsLm37XOk339oaIibb76Zyy+/vKf7nQzDSZL63PXXX88TTzzB8uXLOf/88wG45557iAg++tGP8t73vheAvXv3cumll/LYY4+xbNkyPvvZz5KZXHnllTz44INEBJdeeilXXHHFpGsynCSpz1133XVs2bKFjRs3sn79em699VY2btzIrl27uOCCC1i2bBkADzzwAJs2bWLhwoWsWrWKr33tayxatIgdO3Zw3333AZ1ThL3gNSdJ0gH3338/q1atYubMmZx88sksW7aMBx54AIA3v/nNLF68mJkzZ7Jq1Sruu+8+Fi9ezNatW7n66qu55557mDevN6dQDSdJ0gGZ49+paOyXaCOC+fPns3HjRpYvX86Xv/xlrrrqqp7UYThJUp+bO3cuzz//PADLli1j3bp1vPTSS/z4xz/mW9/6Fm95y1uAzmm9rVu3sn//ftatW8fSpUvZtWsX+/fvZ+XKlXz84x/noYce6klNXnOSpD43ODjI0qVLOffcc7nwwgt54xvfyPLly4kIPvnJT3LKKafw6KOP8ta3vpXrr7+eRx55hGXLlnHRRRfx8MMPc8UVVxz4ku11113Xk5ricF24ppVwJ9x2u02r1Wq6jCLZNuOzbcZ39T1bGTxxsNZ9lj6UfGhoiIGBAX7yk59My+mL4ODveCjeCVeSdEwwnCRJxTGcJEnFMZwkScUxnCSpYTNmzGDfvn1NlzFl9u3bx4wZ3cWNQ8klqWHHH388w8PD7Nmzp2czLJRk5E643TCcJKlhEcHcuXN55plnWLhwYdPlFKG203oRMT8i7oiIH0TElog4NyIGI+LuiGhXjyfUVY8kqVx1XnP6PPDXmfmzwJuALcA1wIbMbAEbqmVJUp+rJZwiYh7wNuBmgMzcl5l7gJXA2upta4GL66hHklS2unpOpwM/Am6NiM0RsSYiXguckpk7AKrHk2uqR5JUsFrm1ouIs4H7gfMyc1NEfB7YC1yVmfNHve+5zDxw3Wn03HrtdnvK65Q09W7aNqv2fX540Qu171OHN3ruyUPNrVfXaL3twPbM3FQt30Hn+tLOiFiQmTsiYgHw7Hgf0NQkmk7gOT7bZny2zWFsq3/i11br2Bie7XFzUC2n9TLzGeCpiDijWrUCeAS4C1hdrVsNrK+jHklS2er8ntNVwJ9FxGzgceA36ITj7RFxGfAk8P4a65EkFaq2cMrMB4GzD/HSirpqkCQdG5xbT5JUHMNJklQcw0mSVBzDSZJUHGcll/rcDZv3Nl2C9Ar2nCRJxTGcJEnFMZwkScUxnCRJxTGcJEnFMZwkScUxnCRJxTGcJEnFMZwkScUxnCRJxTGcJEnFMZwkScVx4ldJ017dk9teu2Rerfubjuw5SZKKYzhJkopjOEmSimM4SZKKYzhJkopT22i9iNgKPA+8BLyYmWdHxCDwVWAxsBX4d5n5XF01SZLKVHfP6fzMPCszz66WrwE2ZGYL2FAtS5L6XNOn9VYCa6vna4GLG6xFklSIyMx6dhTxBPAckMCXMvOmiNiTmfNHvee5zDxhZHloaOhAce12u5Y6pX5z07ZZTZcw7Xx40QtNl1C8Vqt14PnAwECMfb3OGSLOy8ynI+Jk4O6I+EE3G4/+RerUbrcb23fpbJvxHUttMzhc7+wJu3ftZvDEwVr3WbdW6+hmiDiWjpupVttpvcx8unp8FlgHnAPsjIgFANXjs3XVI0kqVy3hFBGvjYi5I8+BXwS+D9wFrK7ethpYX0c9kqSy1XVa7xRgXUSM7PPPM/OvI+LbwO0RcRnwJPD+muqRJBWslnDKzMeBNx1i/S5gRR01SJKOHU0PJZck6RUMJ0lScQwnSVJxDCdJUnEMJ0lScQwnSVJxDCdJUnEMJ0lScQwnSVJxDCdJUnEMJ0lScQwnSVJxDCdJUnEMJ0lScSYcThHxnyLip6ayGEmSoLue04XA1oj4ekRcEhGvmqqiJEn9bcLhlJnvARYBfwV8BHgmItZExNumqjhJUn/q6ppTZu7KzC9k5rnALwBvBb4REVsj4uMRcfyUVClJ6itdD4iIiBURcSvwTWAn8CHg14EldHpVkiRNynETfWNEfAb4ADAE/E/gdzPzh6Nevx94rucVSpL6zoTDCZgD/GpmfvtQL2bmCxFxdm/KkiT1s27C6Qbg/41eEREnAK/OzKcBMvMHPaxNktSnurnm9L+AU8esOxVYN9EPiIiZEbE5Ir5eLZ8WEZsioh0RX42I2V3UI0maprrpOZ2Rmd8bvSIzvxcRP9vFZ/wmsAWYVy3/PvDHmXlbRHwRuAy4sYvPk6bUDZv3HtV2u3fNYnC4+22vXTLvyG+S+kA3PadnI+INo1dUy7smsnFEnAr8MrCmWg7gAuCO6i1rgYu7qEeSNE11E063AH8ZEb8SEWdGxEV0gmXNBLf/HPDbwP5q+URgT2a+WC1vB17fRT2SpGmqm9N6nwZeAD4DLASeohNMf3SkDSPiV4BnM/M7EfH2kdWHeGuO9xntdruLUnuryX2Xbrq3ze5dsyax7e6ut7n6nu63ORYdTdscS9rtnZPYdnr/TY1otVqHfX3C4ZSZ+4E/rH66dR7wnoh4N50h6fPo9KTmR8RxVe/pVODp8T7gSL/IVGm3243tu3T90DZHc90IOv/4Dp442ONqpod+aJtW6+iuHfbD39REddNzIiLOAN4EvGyaosy85XDbZea1wLXVZ7wd+GhmXhoRfwG8D7gNWA2s76YeSdL01M0MER8D/gvwEC//vlPSuR51NH4HuC0ifg/YDNx8lJ8jSZpGuuk5fQQ4JzO/O5kdZuY36czLR2Y+Dpwzmc+TJE0/3YzW+2fAGSAkSVOum3D6BPA/ImJBRMwY/TNVxUmS+lM3p/X+pHq8fNS6oHPNaWavCpIkqZtwOm3KqpAkaZRuvue0DaA6jXdKZu6YsqokSX1twteLImJ+RPw58BPgsWrde6ph4JIk9Uw3gxm+SOcuuIuAfdW6+4BLel2UJKm/dXPNaQXwuuqOtwmQmT+KiJOnpjRJUr/qpuc0BPzU6BUR8dOA154kST3VTTitoXPLjPOBGRFxLp17MH1xSiqTJPWtbk7r/T6dwRBfAGbRmU/vS8Dnp6AuSVIf62YoedK5zcXnpq4cSZK6m5X8gvFey8y/7U05kiR1d1pv7O0sTgJm07m9+uk9q0iS1Pe6Oa33sumLImIm8LvA870uSpLU3456RvHMfAn4FPDbvStHkqRJhFPlHcD+XhQiSdKIbgZEPEXn9hgjXgPMAf5jr4uSJPW3bgZE/NqY5X8CHs3MvT2sR5KkrgZE/N1UFiJJ0ohuTuv9KS8/rXdImfmhSVUkSep73QyI2ANcTOeW7NurbVdW6/9x1I8kSZPSzTWnfw38cmbeO7IiIpYDn8jMd/a8MklS3+qm57QUuH/Muk3AuUfaMCLmRMT/jYiHIuLhiLi+Wn9aRGyKiHZEfDUiZndRjyRpmuomnDYD/y0iXg1QPX4KeHAC2/4LcEFmvgk4C3hXRCylM9P5H2dmC3gOuKyb4iVJ01M34fTvgfOAoYjYSefmg8uB1UfaMDuGq8VZ1U8CFwB3VOvX0rmmJUnqc9G5E0YXG0QsBF4H7MjMJ7vYbibwHeANdO4J9YfA/Zn5hlGf+1eZ+fMj2wwNDR0ort1ud1Wn1As3bZvVdAk6Bn140QtNl1C8Vqt14PnAwECMfb2bARFExInA24EFmfkHEfE6YEZmbj/SttVcfGdFxHxgHfBzh3rbeNuP/kXq1G63G9t36fqhbQaHj+475rt37WbwxMEeVzM99EPbtFrzjmq7fvibmqgJn9aLiF8A/gG4FPhEtboF3NjNDjNzD/BNOgMs5kfESECeCjzdzWdJkqanbnpOnwMuycwNEfFctW4TcM6RNoyIk4AXMnNPNZDiQjqDIb4BvA+4jc61q/XdFC9JJbph89H2uGcddW/92iVH11srVTfhtDgzN1TPR06/7ZvgZywA1lbXnWYAt2fm1yPiEeC2iPg9OqMBx97QUJLUh7oJp0ci4p2Z+Tej1l0IfO9IG2bmd4Elh1j/OBPoeUmS+ks34fRbwNcj4n8Dr46ILwEX0ZnCSJKknpnwgIjMvB/4N8DDwC3AE8A5mfntKapNktSnJtRzqq4VbQDemZl/MLUlSZL63YR6TtV3lE6b6PslSZqMbq45XQ/cGBHX0bllxoEvzGbm/l4XJo11tMNzJR17ugmnNdXjhzgYTFE9n9nLoiRJ/e2I4RQR/yozn6FzWk+SpCk3kZ7To8C8zNwGEBF3ZuZ7p7YsSVI/m8gAh7Gzxb59CuqQJOmAiYRTd/fUkCRpkiZyWu+4iDifgz2osctk5t9ORXGSpP40kXB6ls6MECN2jVlO4PReFiVJ6m9HDKfMXFxDHZIkHeCMD5Kk4hhOkqTiGE6SpOIYTpKk4hhOkqTiGE6SpOIYTpKk4hhOkqTiGE6SpOLUEk4RsTAivhERWyLi4Yj4zWr9YETcHRHt6vGEOuqRJJWtrp7Ti8BvZebPAUuBKyLiTOAaYENmtoAN1bIkqc/VEk6ZuSMzH6iePw9sAV4PrATWVm9bC1xcRz2SpLLVfs0pIhYDS4BNwCmZuQM6AQacXHc9kqTyRGZ99xKMiOOBvwM+lZl3RsSezJw/6vXnMvPAdaehoaEDxbXb7drqVJlu2jar6RKkYn140QtNl9CVVqt14PnAwMDYO65P6H5OPRERs4C/BP4sM++sVu+MiAWZuSMiFtC5d9Qhjf5F6tRutxvbd+nqbpvB4b217Wuydu/azeCJg02XUSTbZnyTaZtWa16Pq2lWXaP1ArgZ2JKZfzTqpbuA1dXz1cD6OuqRJJWtrp7TecCvA9+LiAerdR8DPg3cHhGXAU8C76+pHklSwWoJp8zcCLzinGJlRR01SJKOHc4QIUkqjuEkSSqO4SRJKo7hJEkqjuEkSSqO4SRJKo7hJEkqjuEkSSqO4SRJKo7hJEkqjuEkSSqO4SRJKo7hJEkqjuEkSSqO4SRJKo7hJEkqjuEkSSqO4SRJKo7hJEkqjuEkSSrOcU0XoGPXTdtmMTi8t+kyJE1D9pwkScWpJZwi4paIeDYivj9q3WBE3B0R7erxhDpqkSSVr66e058A7xqz7hpgQ2a2gA3VsiRJ9YRTZv49sHvM6pXA2ur5WuDiOmqRJJWvyWtOp2TmDoDq8eQGa5EkFeSYGa3Xbrf7ct9lm8XuXWM7xBph24zPthnf0bZNu72zx5VMrVarddjXmwynnRGxIDN3RMQC4NnDvflIv8hUabfbje27eNu2MnjiYNNVFGn3rt22zThsm/FNpm1arXk9rqZZTZ7WuwtYXT1fDaxvsBZJUkHqGkr+FeA+4IyI2B4RlwGfBt4REW3gHdWyJEn1nNbLzA+O89KKOvYvSTq2OEOEJKk4x8xoPUnS+G7YXO88l9cumdoBGPacJEnFMZwkScXxtN4UqbuLLUnTiT0nSVJxDCdJUnEMJ0lScQwnSVJxDCdJUnEMJ0lScfpiKPlkhnXv3jWLwWGHhUtSnew5SZKKYzhJkopjOEmSimM4SZKKYzhJkopjOEmSimM4SZKKYzhJkopjOEmSimM4SZKKYzhJkorTeDhFxLsi4h8i4rGIuKbpeiRJzWs0nCJiJvAF4JeAM4EPRsSZTdYkSWpe07OSnwM8lpmPA0TEbcBK4JFe7uTaJfMmsfVktp3ubJvx2Tbjs23GZ9uMaPq03uuBp0Ytb6/WSZL6WNPhFIdYl7VXIUkqStOn9bYDC0ctnwo8PbIwMDBwqPCSJE1zTfecvg20IuK0iJgNfAC4q+GaJEkNazScMvNF4Ergb4AtwO2Z+XBT9UTE/Ii4IyJ+EBFbIuLciBiMiLsjol09ntBUfU0ap23+a0T8MCIerH7e3XSdTYiIM0a1wYMRsTciPuKxc9i28dgBIuI/R8TDEfH9iPhKRMyp/rO+qTpuvlr9x73vRKaXeEZExFrg3sxcUx0QrwE+BuzOzE9X38M6ITN/p9FCGzBO23wEGM7MzzRbXTmqr0f8EPi3wBV47Bwwpm1+gz4/diLi9cBG4MzM/OeIuB34P8C7gTsz87aI+CLwUGbe2GStTWj6tF4xImIe8DbgZoDM3JeZe+gMbV9bvW0tcHEzFTbnMG2jV1oB/GNmbsNjZ6zRbaOO44BXR8RxdP7DtwO4ALijer1vjxvD6aDTgR8Bt0bE5ohYExGvBU7JzB0A1ePJTRbZkPHaBuDKiPhuRNzSj6etDuEDwFeq5x47Lze6baDPj53M/CHwGeBJOqE0BHwH2FNd8oA+/nqN4XTQccCbgRszcwnwT4DTKXWM1zY3Aj8DnEXnj+uzjVVYgOp053uAv2i6ltIcom36/tipAnklcBrwOuC1dGbLGasvr70YTgdtB7Zn5qZq+Q46/yDvjIgFANXjsw3V16RDtk1m7szMlzJzP/BlOjN+9LNfAh7IzJ3VssfOQS9rG48dAC4EnsjMH2XmC8CdwDJgfnWaD8Z8vaafGE6VzHwGeCoizqhWraAzjdJdwOpq3WpgfQPlNWq8thn5h7fyq8D3ay+uLB/k5aet+v7YGeVlbeOxA3RO5y2NiNdERHDw35xvAO+r3tO3x42j9UaJiLOANcBs4HE6I4pmALcDP03nYHp/Zu5urMiGjNM2/53OaZkEtgL/YeQaS7+JiNfQmYrr9MwcqtadiMfOeG3zp3jsEBHXA5cALwKbgcvpXGO6DRis1v1aZv5LY0U2xHCSJBXH03qSpOIYTpKk4hhOkqTiGE6SpOIYTpKk4hhOkqTiGE6SpOIYTpKk4vx/w6YI/jf1MycAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot histogram, bins=12\n",
    "popular_station = plot.hist(popstationdf['tobs'], bins=12, alpha=0.5)\n",
    "plot.ylabel(\"Frequency\")\n",
    "plot.legend([\"tobs\"])\n",
    "plot.show(popular_station)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Temperature Analysis of my Trip : 12-27-2015 to 01-10-2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function called `calc_temps` will accept start date and end date in the format '%Y-%m-%d' \n",
    "# and return the minimum, average, and maximum temperatures for that range of dates\n",
    "def calc_temps(start_date, end_date):\n",
    "    \"\"\"TMIN, TAVG, and TMAX for a list of dates.\n",
    "    \n",
    "    Args:\n",
    "        start_date (string): A date string in the format %Y-%m-%d\n",
    "        end_date (string): A date string in the format %Y-%m-%d\n",
    "        \n",
    "    Returns:\n",
    "        TMIN, TAVE, and TMAX\n",
    "    \"\"\"\n",
    "    \n",
    "    return session.query(func.min(Measurement.tobs), func.avg(Measurement.tobs), func.max(Measurement.tobs)).\\\n",
    "        filter(Measurement.date >= start_date).filter(Measurement.date <= end_date).all()\n",
    "\n",
    "# function usage example\n",
    "#print(calc_temps('2012-02-28', '2012-03-05'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(62.0, 70.96551724137932, 78.0)]\n"
     ]
    }
   ],
   "source": [
    "# 12. calculate MY TRIP's tmin, tavg, and tmax \n",
    "mytrip = print(calc_temps('2015-12-27', '2016-01-10'))\n",
    "mytrip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.pyplot import figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 13. plot the results from your previous query as a bar chart. \n",
    "#     Use \"Trip Avg Temp\" as your Title\n",
    "#     Use the average temperature for the y value\n",
    "#     Use the peak-to-peak (tmax-tmin) value as the y error bar (yerr)\n",
    "\n",
    "mean = 70.96\n",
    "peak2peak = 16\n",
    "ind = 1    # the x locations for the groups\n",
    "\n",
    "plot.figure(figsize=(4,8))\n",
    "plot.xticks([])\n",
    "\n",
    "plot.title(\"Trip Avg Temp\")\n",
    "plot.ylabel(\"Temp (F)\")\n",
    "plot.xlim(.10 , 1.8)\n",
    "plot.ylim(0,90)\n",
    "\n",
    "mytrip_temp = plot.bar(ind, mean, yerr=peak2peak, color='lightcoral', ecolor=\"yellow\", align=\"center\", alpha=0.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rainfall per Weather Station"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "stations_list=session.query(Station.station)\n",
    "stations_df = pd.read_sql_query(stations_list.statement, session.bind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'station': {0: 'USC00519397',\n",
       "  1: 'USC00513117',\n",
       "  2: 'USC00514830',\n",
       "  3: 'USC00517948',\n",
       "  4: 'USC00518838',\n",
       "  5: 'USC00519523',\n",
       "  6: 'USC00519281',\n",
       "  7: 'USC00511918',\n",
       "  8: 'USC00516128'}}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stations_df.to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 14. calculate the rainfall per weather station for your trip dates using the previous year's matching dates.\n",
    "alist = session.query(Measurement.station, func.sum(Measurement.prcp)).filter(Measurement.date <= '2016-01-10').\\\n",
    "        filter(Measurement.date >= '2015-12-27').group_by(Measurement.station)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 14b. use function to pull out all data correspondent to the stations from the list of \"station_results\", in a form of a tupple \n",
    "def rainfall_pstation(name):\n",
    "    \"\"\"rainfall_pstation.\n",
    "    \n",
    "    Args:\n",
    "        name (str): Name of station string in the format 'USC00519397'\n",
    "        \n",
    "    Returns:\n",
    "        A list of tuples containing each result correspondant to each column in table \"Stations\"\n",
    "    \n",
    "    \"\"\"\n",
    "    sel = [Station.station, Station.name, Station.latitude, Station.longitude, Station.elevation]\n",
    "    return session.query(*sel).filter(Station.station == name).first()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 14c.looped through the list filtered by station for my trip dates\n",
    "stations_results = []\n",
    "station_list = ['USC00513117','USC00514830', 'USC00516128', 'USC00517948', 'USC00519281', 'USC00519397','USC00519523']\n",
    "\n",
    "for one in station_list:\n",
    "    r=rainfall_pstation(one)\n",
    "    stations_results.append(r)\n",
    "    \n",
    "# show results \n",
    "#stations_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 14d. create a df of station_results\n",
    "stationinfo_df = pd.DataFrame(stations_results)\n",
    "# create a df of rainfall results\n",
    "rainfallinfo_df = pd.read_sql_query(alist.statement, session.bind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>station</th>\n",
       "      <th>name</th>\n",
       "      <th>latitude</th>\n",
       "      <th>longitude</th>\n",
       "      <th>elevation</th>\n",
       "      <th>sum_1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>USC00516128</td>\n",
       "      <td>MANOA LYON ARBO 785.2, HI US</td>\n",
       "      <td>21.33310</td>\n",
       "      <td>-157.80250</td>\n",
       "      <td>152.4</td>\n",
       "      <td>5.28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>USC00519281</td>\n",
       "      <td>WAIHEE 837.5, HI US</td>\n",
       "      <td>21.45167</td>\n",
       "      <td>-157.84889</td>\n",
       "      <td>32.9</td>\n",
       "      <td>2.54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>USC00513117</td>\n",
       "      <td>KANEOHE 838.1, HI US</td>\n",
       "      <td>21.42340</td>\n",
       "      <td>-157.80150</td>\n",
       "      <td>14.6</td>\n",
       "      <td>1.42</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>USC00519397</td>\n",
       "      <td>WAIKIKI 717.2, HI US</td>\n",
       "      <td>21.27160</td>\n",
       "      <td>-157.81680</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>USC00519523</td>\n",
       "      <td>WAIMANALO EXPERIMENTAL FARM, HI US</td>\n",
       "      <td>21.33556</td>\n",
       "      <td>-157.71139</td>\n",
       "      <td>19.5</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>USC00514830</td>\n",
       "      <td>KUALOA RANCH HEADQUARTERS 886.9, HI US</td>\n",
       "      <td>21.52130</td>\n",
       "      <td>-157.83740</td>\n",
       "      <td>7.0</td>\n",
       "      <td>0.44</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>USC00517948</td>\n",
       "      <td>PEARL CITY, HI US</td>\n",
       "      <td>21.39340</td>\n",
       "      <td>-157.97510</td>\n",
       "      <td>11.9</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       station                                    name  latitude  longitude  \\\n",
       "2  USC00516128            MANOA LYON ARBO 785.2, HI US  21.33310 -157.80250   \n",
       "4  USC00519281                     WAIHEE 837.5, HI US  21.45167 -157.84889   \n",
       "0  USC00513117                    KANEOHE 838.1, HI US  21.42340 -157.80150   \n",
       "5  USC00519397                    WAIKIKI 717.2, HI US  21.27160 -157.81680   \n",
       "6  USC00519523      WAIMANALO EXPERIMENTAL FARM, HI US  21.33556 -157.71139   \n",
       "1  USC00514830  KUALOA RANCH HEADQUARTERS 886.9, HI US  21.52130 -157.83740   \n",
       "3  USC00517948                       PEARL CITY, HI US  21.39340 -157.97510   \n",
       "\n",
       "   elevation  sum_1  \n",
       "2      152.4   5.28  \n",
       "4       32.9   2.54  \n",
       "0       14.6   1.42  \n",
       "5        3.0   0.67  \n",
       "6       19.5   0.67  \n",
       "1        7.0   0.44  \n",
       "3       11.9    NaN  "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 14e. Display Results:\n",
    "#      A.merge tables\n",
    "#      B.sort this in descending order by precipitation amount and list the station, name, latitude, longitude, and elevation\n",
    "pd.merge(stationinfo_df, rainfallinfo_df, on=\"station\", how=\"inner\").sort_values(by=[\"sum_1\"],ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optional Challenge Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(65.0, 75.75510204081633, 82.0)]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a query that will calculate the daily normals \n",
    "# (i.e. the averages for tmin, tmax, and tavg for all historic data matching a specific month and day)\n",
    "\n",
    "def daily_normals(date):\n",
    "    \"\"\"Daily Normals.\n",
    "    \n",
    "    Args:\n",
    "        date (str): A date string in the format '%m-%d'\n",
    "        \n",
    "    Returns:\n",
    "        A list of tuples containing the daily normals, tmin, tavg, and tmax\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    sel = (func.min(Measurement.tobs), func.avg(Measurement.tobs), func.max(Measurement.tobs))\n",
    "    return session.query(*sel).filter(func.strftime(\"%m-%d\", Measurement.date) == date).all()\n",
    "\n",
    "\n",
    "daily_normals(\"10-12\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the daily normals for your trip\n",
    "\n",
    "# A. created a for loop that runs through date_list, \n",
    "# B. pulls each \"day\" and plugs it in def daily_normals(),\n",
    "# C. appends each return of (min, avg, max temp) into list date_results\n",
    "\n",
    "date_results = []\n",
    "date_list = [\"12-27\", \"12-28\", \"12-29\", \"12-30\",\"12-31\", \"01-01\", \"01-02\", \"01-03\", \"01-04\", \"01-05\", \"01-06\", \"01-07\", \"01-08\", \"01-09\", \"01-12\"]\n",
    "\n",
    "for day in date_list:\n",
    "    abc=daily_normals(day)\n",
    "    date_results.append(abc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[(62.0, 71.91666666666667, 79.0)],\n",
       " [(62.0, 70.52083333333333, 77.0)],\n",
       " [(57.0, 70.29166666666667, 78.0)],\n",
       " [(63.0, 69.86363636363636, 76.0)],\n",
       " [(56.0, 68.27906976744185, 77.0)],\n",
       " [(62.0, 69.15384615384616, 77.0)],\n",
       " [(60.0, 69.39622641509433, 77.0)],\n",
       " [(62.0, 68.9090909090909, 77.0)],\n",
       " [(58.0, 70.0, 76.0)],\n",
       " [(56.0, 67.96428571428571, 76.0)],\n",
       " [(61.0, 68.96491228070175, 76.0)],\n",
       " [(57.0, 68.54385964912281, 76.0)],\n",
       " [(57.0, 67.16071428571429, 75.0)],\n",
       " [(58.0, 67.9298245614035, 78.0)],\n",
       " [(57.0, 67.4074074074074, 81.0)]]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date_results"
   ]
  }
 ],
 "metadata": {
  "kernel_info": {
   "name": "python3"
  },
  "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.0"
  },
  "nteract": {
   "version": "0.9.1"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}