NASA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NASA NeoWs API: Potentially Hazardous Asteroids\n",
    "\n",
    "Find out how many potentially hazardous asteroids were present each month in a given date range.\n",
    "\n",
    "---\n",
    "## Objective of NASA API Portal\n",
    "\n",
    "To make NASA data eminently accessible to application developers.\n",
    "\n",
    "## NeoWs API\n",
    "\n",
    "Provides near earth Asteroid information. Useful for anyone curious about astronomical happenings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import calendar\n",
    "from collections import defaultdict\n",
    "from datetime import datetime, timedelta\n",
    "import os\n",
    "import requests\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def get_date_range():\n",
    "    \"\"\"\n",
    "    Solicit user for start date and end date.\n",
    "    \n",
    "    Args:\n",
    "        None\n",
    "    \n",
    "    Returns:\n",
    "        tuple: tuple containing start date and end date\n",
    "    \"\"\"\n",
    "    \n",
    "    start_date = datetime.fromisoformat(input('Enter start date (YYYY-MM-DD): ')).date()\n",
    "    end_date = datetime.fromisoformat(input('Enter end date (YYYY-MM-DD): ')).date()\n",
    "    assert end_date > start_date, 'End date must be greater than start date.'\n",
    "    assert (end_date - start_date).days <= 720, 'Maximum date range is 2 years.'\n",
    "    \n",
    "    return start_date, end_date\n",
    "\n",
    "\n",
    "def _extract_data(near_earth_objects):\n",
    "    \"\"\"\n",
    "    Creates dictionary for asteroid properties \n",
    "    and fills dictionary with data from response.\n",
    "    \n",
    "    Args:\n",
    "        near_earth_objects(dict): dict of contents of 'near_earth_objects' key of response\n",
    "    \n",
    "    Returns:\n",
    "        dict: dict of useful portions of the data\n",
    "    \"\"\"\n",
    "    keys_to_check = [\n",
    "        'name',\n",
    "        'date',\n",
    "        'close_approach_data',\n",
    "        'estimated_diameter',\n",
    "        'is_potentially_hazardous_asteroid'\n",
    "    ]\n",
    "    # make an dictionary with keys of useful features\n",
    "    asteroid_dict = defaultdict(list)\n",
    "\n",
    "    # iterate through each day of the span of days selected\n",
    "    for date in near_earth_objects:\n",
    "        # iterate through the list of entries for the day\n",
    "        for entry in near_earth_objects[date]:\n",
    "            # iterate through each key of the dictionary making up each entry\n",
    "            for key in keys_to_check:\n",
    "                # seek out relevant portions of data\n",
    "                if key == 'close_approach_data':\n",
    "                    asteroid_dict['close_approach_date'].append(\n",
    "                        entry[key][0]['close_approach_date'])\n",
    "                    asteroid_dict['relative_velocity_mph'].append(\n",
    "                        entry[key][0]['relative_velocity']['miles_per_hour'])\n",
    "                    asteroid_dict['miss_distance_miles'].append(\n",
    "                        entry[key][0]['miss_distance']['miles'])\n",
    "                elif key == 'estimated_diameter':\n",
    "                    asteroid_dict['est_diameter_max_feet'].append(\n",
    "                        entry[key]['feet']['estimated_diameter_max'])\n",
    "                elif key == 'date':\n",
    "                    asteroid_dict['date'].append(date)\n",
    "                else:\n",
    "                    asteroid_dict[key].append(entry[key])\n",
    "    \n",
    "    return dict(asteroid_dict)\n",
    "\n",
    "\n",
    "def get_data_dictionary(start, end):\n",
    "    \"\"\"\n",
    "    Make API call and extract select data from response.\n",
    "    Start and end are at most 7 days apart.\n",
    "    \n",
    "    Args:\n",
    "        start(datetime.date): start date of query\n",
    "        end(datetime.date): end date of query\n",
    "        \n",
    "    Returns:\n",
    "        dict: dict of select portions of data from API response\n",
    "    \"\"\"\n",
    "    path = 'https://api.nasa.gov/neo/rest/v1/feed?start_date={}&end_date={}&api_key={}'\n",
    "    url = path.format(start, end, os.environ['NASA_NEOWS_API_KEY'])\n",
    "    \n",
    "    # get data\n",
    "    print('\\rQuerying for {} to {}...'.format(start, end), end='', flush=True)\n",
    "    rsp = requests.get(url)\n",
    "    # parse JSON reponse and grab the contents of 'near_earth_objects' key\n",
    "    neo = rsp.json()['near_earth_objects']\n",
    "    # make a filtered dictionary out of the contents of 'near_earth_objects' key\n",
    "    asteroid_dict = _extract_data(neo)\n",
    "    \n",
    "    return asteroid_dict\n",
    "\n",
    "\n",
    "def format_df(df):\n",
    "    \"\"\"\n",
    "    Various formatting steps to apply to dataFrame.\n",
    "    \n",
    "    Args:\n",
    "        df(pandas.DataFrame): unformatted dataFrame \n",
    "        \n",
    "    Returns:\n",
    "        df(pandas.DataFrame): formatted dataFrame\n",
    "    \"\"\"\n",
    "    df['year'], df['month'], df['day'] = zip(*df.close_approach_date.str.split('-'))\n",
    "    for col in ['year', 'month', 'day']:\n",
    "        df[col] = df[col].astype(int)\n",
    "    for col in ['est_diameter_max_feet', 'relative_velocity_mph', 'miss_distance_miles']:\n",
    "        df[col] = df[col].astype(float)\n",
    "    df.drop(columns=['date'], inplace=True)\n",
    "    df.rename(columns={'name': 'asteroid_name'}, inplace=True)\n",
    "    df.set_index('asteroid_name', inplace=True)\n",
    "    \n",
    "    return df\n",
    "\n",
    "\n",
    "def plot_df(df, start, end):\n",
    "    \"\"\"\n",
    "    Plot the dataFrame to show number of potentially hazardous asteroids per month/year.\n",
    "    \n",
    "    Args:\n",
    "        df(pandas.DataFrame): formatted dataFrame\n",
    "        start(datetime.date): start date of entire query range\n",
    "        end(datetime.date): end date of entire query range\n",
    "        \n",
    "    Returns:\n",
    "        None\n",
    "    \"\"\"\n",
    "    # filter for potentially hazardous asteroids\n",
    "    df = df[df['is_potentially_hazardous_asteroid']]\n",
    "    grouped_df = df.groupby(['year','month'])\n",
    "    groups = grouped_df.groups\n",
    "    grouped_df = grouped_df.size()\n",
    "    plot = grouped_df.plot(kind='bar', width=1.0, edgecolor='black', figsize=(10,10))\n",
    "    xticks = ['{} {}'.format(calendar.month_abbr[int(x[1])], x[0]) for x in groups.keys()]\n",
    "    title = 'Number of Potentially Hazardous Asteroids\\nPer Month From {} to {}'\n",
    "    title = title.format(start, end)\n",
    "    for i, v in enumerate(grouped_df.values):\n",
    "        plot.text(x=i, y=v+(max(grouped_df.values)/100), s=str(v))\n",
    "    plot.set_xticklabels(xticks, rotation=45)\n",
    "    plot.set_xlabel('')\n",
    "    plot.set_ylabel('Frequency\\n', fontsize=12)\n",
    "    plot.set_title(title, fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter start date (YYYY-MM-DD): 2019-01-01\n",
      "Enter end date (YYYY-MM-DD): 2019-05-31\n",
      "Querying for 2019-05-25 to 2019-05-31..."
     ]
    },
    {
     "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>relative_velocity_mph</th>\n",
       "      <th>miss_distance_miles</th>\n",
       "      <th>est_diameter_max_feet</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>is_potentially_hazardous_asteroid</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>False</th>\n",
       "      <td>28,276</td>\n",
       "      <td>18,757,964</td>\n",
       "      <td>848</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>True</th>\n",
       "      <td>37,817</td>\n",
       "      <td>24,667,156</td>\n",
       "      <td>2,122</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  relative_velocity_mph miss_distance_miles  \\\n",
       "is_potentially_hazardous_asteroid                                             \n",
       "False                                            28,276          18,757,964   \n",
       "True                                             37,817          24,667,156   \n",
       "\n",
       "                                  est_diameter_max_feet  \n",
       "is_potentially_hazardous_asteroid                        \n",
       "False                                               848  \n",
       "True                                              2,122  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    start_date, end_date = get_date_range()\n",
    "    date_difference = (end_date - start_date).days\n",
    "    num_weeks = int(date_difference/7)\n",
    "    num_days = date_difference%7\n",
    "    \n",
    "    start, end = start_date, start_date + timedelta(days=num_days)\n",
    "    asteroid_dfs = [pd.DataFrame(get_data_dictionary(start, end))]\n",
    "    for _ in range(num_weeks):\n",
    "        start, end = end + timedelta(days=1), end + timedelta(days=7)\n",
    "        asteroid_dfs.append(pd.DataFrame(get_data_dictionary(start, end)))\n",
    "\n",
    "    asteroid_df = pd.concat(asteroid_dfs, axis=0)\n",
    "    asteroid_df = format_df(asteroid_df)\n",
    "    # compare stats between potentially hazardous and non-potentially hazardous asteroids\n",
    "    display(\n",
    "        asteroid_df.groupby(\n",
    "        ['is_potentially_hazardous_asteroid']\n",
    "        ).mean()[[\n",
    "            'relative_velocity_mph',\n",
    "            'miss_distance_miles',\n",
    "            'est_diameter_max_feet'\n",
    "        ]].apply(lambda s: s.apply(lambda x: '{:,.0f}'.format(x)))\n",
    "    )\n",
    "    plot_df(asteroid_df, start_date, end_date)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.6"
  },
  "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
}