KiteUp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests as r\n",
    "import datetime as dt\n",
    "import pandas as pd\n",
    "import json\n",
    "import os\n",
    "try:\n",
    "    from emailer import send_mail\n",
    "except ModuleNotFoundError as e:\n",
    "    print(\"Running without email\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KiteUp - Icelandic weather alert system for kitesurfers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "'''CONSTANTS\n",
    "Weather Station Id's'''\n",
    "REY = 1 # Reykjavík : Grótta\n",
    "EYR = 1395 # Eyrarbakki : Ölfurárós\n",
    "GEL = 1480 # Geldingarnes : Geldingarnes\n",
    "STR = 1473 # Straumsvík : Skógtjörn, Grótta\n",
    "TYK = 6208 # Þykkvibær\n",
    "\n",
    "'''\n",
    "TIDE Station Id's\n",
    "''' \n",
    "REY_TIDE = 23 # Reykjavík\n",
    "TLH_TIDE = 25 # Þorlákshöfn\n",
    "\n",
    "'''END OF CONTANTS'''\n",
    "\n",
    "\n",
    "'''Configure your variables:\n",
    "hour_range - Hour range, compared with <= and >=\n",
    "wind_range - In m/s, <= and >=\n",
    "min_rows - Minimum rows per day. Some forecasts only predict every 3 hours, Some every hour. compared with <= and >=\n",
    "locations - Put in the stations you want to get updates about along with the directions you want to filter for\n",
    "            Each weather station can have many kiteable locations you can check for, see STR(Straumsvík) station for example.\n",
    "'''\n",
    "\n",
    "# Time range\n",
    "hour_range = ['09:00','20:00']\n",
    "# Wind with m/s range that will be compared with <= and >=\n",
    "# A 9 metre kite your wind range could be around [6,12] m/s\n",
    "wind_range = [6,12]\n",
    "\n",
    "# For rain filter, checks if it contains any of these in a string lowercase\n",
    "do_not_want = ['rign','skúr'] # Leave empty if you want any kind of weather condition\n",
    "\n",
    "\n",
    "check_days = 2 # How many days ahead to check, including today, highest is 5\n",
    "\n",
    "include_directions = True # if to include the directions for the spots given below\n",
    "min_rows = 2 # Setting min rows as 2 because some forecasts only predict for every 3 hours\n",
    "\n",
    "# Spots:\n",
    "# Stores directions\n",
    "# Each spot also stores a Tide ID and Minimum tide height in meters for each spot. Empty list if not applicable.\n",
    "# Try to come up with the best locations, directions and tides to look for. Tide height will be compared with >= row['Sjávarhæð [m]']\n",
    "GROTTA = {'Grótta':[['N','NNA','NV','NNV','VNV','V','VSV','SV'],[REY_TIDE, 2]]}\n",
    "SKOGTJ = {'Skógtjörn':[['S','SA','SSA','SV','SSV','VSV'],[]]}\n",
    "GELNES = {'Geldingarnes':[['A','ASA','SSA','SA','V','VNV'],[REY_TIDE, 0]]}\n",
    "OLFUS = {'Ölfusárlón':[['N','NA','NNA','NNV','S','SSA','SSV','SV','SA','V','VNV','VSV','A','ANA','ASA'],[TLH_TIDE, 1]]}\n",
    "THOR = {'Thorlakshofn':[['A','ASA','SSA','S','SA','SSV','VSV','VNV','V'],[TLH_TIDE, 0.5]]}\n",
    "THYK = {'Tykkvibær':[['A','ASA','SA','SSA','NV','NNV','V','VNV','VSV'],[TLH_TIDE, 0]]}\n",
    "\n",
    "\n",
    "# Weather stations can have many spots\n",
    "locations = {\n",
    "                REY:[GROTTA],\n",
    "                EYR:[OLFUS, THOR],\n",
    "                TYK:[THYK],\n",
    "                GEL:[GELNES],\n",
    "                STR:[SKOGTJ, \n",
    "                    GROTTA]\n",
    "            }\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# WRITE YOUR CUSTOM SETTINGS TO A JSON FILE\n",
    "\n",
    "my_settings = {\n",
    "    'yourname': {\n",
    "            'locations': locations,\n",
    "            'hour_range': hour_range,\n",
    "            'wind_range': wind_range,\n",
    "            'do_not_want': do_not_want,\n",
    "            'check_days': check_days,\n",
    "            'include_directions': include_directions,\n",
    "            'min_rows': min_rows,\n",
    "            'email': 'example@blamail.com',\n",
    "    }\n",
    "}\n",
    "\n",
    "def save_settings(my_settings):  \n",
    "    with open(\"settings.json\", 'w', encoding='latin-1') as f:\n",
    "        json.dump(my_settings, f, ensure_ascii=False, indent=4, sort_keys=True) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class kiter:\n",
    "    def __init__(self, attributes):\n",
    "        if type(attributes) == str:\n",
    "            attributes =  json.loads(attributes)\n",
    "        for attribute, value in attributes.items():\n",
    "            self.__setattr__(attribute, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def query_weather_api(locations):\n",
    "    base_url = \"https://apis.is\"\n",
    "    path = \"/weather/forecasts/is/?stations=\"\n",
    "    station_text_format = \"{},\" * len(locations)\n",
    "    stations = station_text_format.format(*locations.keys())\n",
    "    res = r.get(url=base_url + path + stations)\n",
    "    return res\n",
    "    '''\n",
    "    Response:\n",
    "    results - listi af dict:\n",
    "        id - Stöðvanúmer\n",
    "        name - Nafn á stöð\n",
    "        atime - tími hvenær spá er gefin út á forminu %Y-%m-%d %H:%M:%S\n",
    "        forecast - list af dict: \n",
    "            ftime - tími á forminu %Y-%m-%d %H:%M:%S\n",
    "            F - vindhraði, \n",
    "            D - vindstefnu'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def query_tides_api(location_id, day):\n",
    "    # This function returns a dataframe about the tides 24 hours from starting daytime\n",
    "    base_url = \"http://www.vegagerdin.is\"\n",
    "    path = \"/vs/StationsDetails.aspx\"\n",
    "    query_format = \"?ID={}&Per=24&Dt={}&nohead=true\".format(location_id, day.strftime(\"%Y%m%d%H%M\"))\n",
    "    df = pd.read_html(base_url + path + query_format, decimal=',', thousands='.')[0]\n",
    "    return df\n",
    "\n",
    "def clean_tides_df(df):\n",
    "    df.columns = df.iloc[0,:].values\n",
    "    df = df.iloc[1:,:].reset_index(drop=True) \n",
    "    df['Tími'] = pd.to_datetime(df['Tími'],format='%d.%m.%Y %H:%M') # example format we get from vegagerdin: '6.10.2018 19:00'\n",
    "    df['Sjávarhæð [m]'] = pd.to_numeric(df['Sjávarhæð [m]'])\n",
    "    df.rename(columns={'Tími':'ftime'}, inplace=True)\n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def wind_filter(df, wind_range):\n",
    "    return df[(df.F  >= wind_range[0]) & (df.F <= wind_range[1])]\n",
    "\n",
    "def directions_filter(df, directions): # Checks the 'D' column (Direction)\n",
    "    return df[df.D.isin(directions)]\n",
    "\n",
    "def hour_range_filter(df, hour_range):\n",
    "    return df.between_time(*hour_range)\n",
    "\n",
    "def rain_filter(df, wcond): # Checks the 'W' column (Weather)\n",
    "    if not wcond:\n",
    "        return df\n",
    "    for cw in wcond: # use ~ for to reverse the booleans because we do not want it to contain this weather description\n",
    "        df = df[~df.W.str.lower().str.contains(cw)]\n",
    "    return df\n",
    "\n",
    "def tides_filter(df, min_height):\n",
    "    return df[df['Sjávarhæð [m]'] >= min_height] # Returns only the rows for which the statement is true \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def run_filters(df, k, direction_tide, day):\n",
    "    df = wind_filter(df, k.wind_range)\n",
    "    df = rain_filter(df, k.do_not_want)\n",
    "\n",
    "    if not df.empty:\n",
    "        if include_directions: # Wind directions\n",
    "            df = directions_filter(df, direction_tide[0])\n",
    "        # Query for the tides sea stations for day interval for the next 24hours\n",
    "        if direction_tide[1]: # If the list is not empty, such as with Skógtjörn, We only go here where it is needed or we want to merge the datasets for display purposes\n",
    "            df_tides = clean_tides_df(query_tides_api(direction_tide[1][0], day - pd.DateOffset(hour=0))) # Always reset the hour to 00:00, to get the next 24 hours\n",
    "            df = pd.merge(left=df, right=df_tides, on='ftime', how='inner')\n",
    "            df = tides_filter(df, direction_tide[1][1])\n",
    "    return df\n",
    "    \n",
    "'''\n",
    "day_check function:\n",
    "Filters out if the forecast of the day has the right wind and kite–able directions\n",
    "Parameters:\n",
    "df – df containing weather for one day\n",
    "location_id - weather station id '''\n",
    "def day_check(df, k, location_id, link, utgafutimi, day):\n",
    "    message = \"\"\n",
    "    for spot in k.locations[str(location_id)]:\n",
    "        clean_df = df.copy() # For all the spots we need a fresh copy from here\n",
    "        for name, direction_tide in spot.items():\n",
    "            df = run_filters(df, k, direction_tide, day)\n",
    "            if df.shape[0] >= min_rows:\n",
    "                df = df.reset_index(drop=True)\n",
    "                message += \"{}\\n{}\\nStart: {}\\n{}\\n\".format(spot,link,df.loc[0,'ftime'],df.to_string(justify='left', col_space=5))\n",
    "                \n",
    "            df = clean_df.copy()\n",
    "    return message        \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def main(k):\n",
    "    \n",
    "    response_weather = query_weather_api(k.locations)\n",
    "    vedur = response_weather.json()['results']\n",
    "    alert = list()\n",
    "    for i in range(len(vedur)):\n",
    "        location_id = int(vedur[i]['id'])\n",
    "        link = vedur[i]['link']\n",
    "        \n",
    "        utgafutimi = vedur[i]['atime']\n",
    "        df = pd.DataFrame(vedur[i]['forecast'])\n",
    "        df['ftime'] = df['ftime'].astype('datetime64[s]')\n",
    "        df['F'] = df['F'].astype('float')\n",
    "        \n",
    "        # Set the index to a DateTimeIndex so we can filter by hour\n",
    "        df.set_index(pd.DatetimeIndex(df['ftime']), inplace=True)\n",
    "        df.index.names=['index']\n",
    "        df = hour_range_filter(df, k.hour_range)\n",
    "        \n",
    "        # Get the first date\n",
    "        day = df['ftime'].iloc[0]\n",
    "\n",
    "        for i in range(0, check_days):\n",
    "            df_day = df[df.ftime.dt.day == day.day]\n",
    "            # Call day_check with a dataframe for each day\n",
    "            message = day_check(df_day, k, location_id, link, utgafutimi, day)\n",
    "            if message:\n",
    "                message = \"Spá gefin út: \" + utgafutimi + '\\n' + message\n",
    "                alert.append(message)\n",
    "            # Iterate to the next day\n",
    "            day += pd.DateOffset(days=1)\n",
    "    \n",
    "    print(\"\\n\".join(alert))\n",
    "    if alert:\n",
    "        try:\n",
    "            send_mail(\"\\n\".join(alert), [k.email])\n",
    "        except NameError as e:\n",
    "            print(\"Not sending email\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spá gefin út: 2018-10-06 18:00:00\n",
      "{'Geldingarnes': [['A', 'ASA', 'SSA', 'SA', 'V', 'VNV'], [23, 0]]}\n",
      "http://www.vedur.is/vedur/spar/stadaspar/hofudborgarsvaedid/#group=100&station=1480\n",
      "Start: 2018-10-08 15:00:00\n",
      "      D      F    N     R     T     TD    W         ftime               Sjávarföll [m] Áhlaðandi [m]  Sjávarhæð [m]\n",
      "0      A     6.0   100   0.0   4     1     Alskýjað 2018-10-08 15:00:00  2.4            0.2           2.6          \n",
      "1      A     6.0   100   0.0   4     1     Alskýjað 2018-10-08 16:00:00  3.4            0.2           3.6          \n",
      "2      A     6.0   100   0.0   3     1     Alskýjað 2018-10-08 17:00:00  4.0            0.2           4.2          \n",
      "3      A     6.0   100   0.0   2     0     Alskýjað 2018-10-08 20:00:00  3.4            0.2           3.6          \n",
      "\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    filename = \"settings.json\"\n",
    "    if os.path.exists(filename):\n",
    "        with open(filename, 'r', encoding='latin-1') as f:\n",
    "            settings = json.load(f)\n",
    "    for name,v in settings.items():\n",
    "        k = kiter(v)\n",
    "        # Run the program for every different kiter settings\n",
    "        main(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}