GIS-workup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Three year summary Lake Geneva\n",
    "\n",
    "#### Notebook 1\n",
    "\n",
    "__Purpose:__ Present an analysis method for survey results from beach litter inventories on Lake Geneva.\n",
    "\n",
    "__Background:__ This is in the context of the global movement to reduce plastic debris in the maritime environment. Riverine inputs are major contributors of plastic debris (and all types of refuse) to the oceans. This is an analysis of the data collected on the shores of Lake Geneva over a three year period. The maritime protocol was modified in very specific ways to adjust for the local geography and population density.\n",
    "\n",
    "#### Research question: Is this a representative sample ?\n",
    "\n",
    "There is a push to quantify the amounts of plastic trash in the environment. It would be impossible to pick up every piece of trash in the environment and count it (that would solve the problem though). Extrapolating from economic and population data is one way to obtain a macro-view of the problem. But the margin of error on these type of calculations makes them unsuitable for identifying trends on a local or regional level.\n",
    "\n",
    "If sampling all the trash is not possibile, what if we sample as much as possible and see what that looks like? The following questions could be answered:\n",
    "\n",
    "1. What does the distribution of survey results look like?\n",
    "2. Do different groups of people produce different survey results?\n",
    "3. How different are the survey results from one location to another?\n",
    "4. What are the most abundant objects?\n",
    "5. How different are the survey results year over year?\n",
    "\n",
    "These series of notebooks will try to answer those questions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "import json\n",
    "import csv\n",
    "import datetime\n",
    "import collections\n",
    "# import pandas as pd\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import folium\n",
    "import geopandas\n",
    "import os\n",
    "import seaborn as sns\n",
    "import matplotlib.dates as mdates\n",
    "from matplotlib import colors as mcolors\n",
    "from matplotlib.ticker import MultipleLocator\n",
    "import matplotlib.patches as mpatch\n",
    "from matplotlib.lines import Line2D\n",
    "from Utilities.utility_functions import *\n",
    "idx = pd.IndexSlice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Directory already in place\n"
     ]
    }
   ],
   "source": [
    "# The data is off of the API at https://mwshovel.pythonanywhere.com/dirt/api_home.html \n",
    "# You will have the opportunity to save the data locally\n",
    "# get some file structures in place\n",
    "\n",
    "# Required variables:\n",
    "folders = [\"Data\", \"Charts\", \"Utilities\"]\n",
    "here = os.getcwd()\n",
    "\n",
    "# check for existing and if not make folders\n",
    "check_for_folders(folders, here)\n",
    "\n",
    "# make a dictionary to call path by directory name\n",
    "my_folders = make_folders(folders, here)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import requests\n",
    "# a = requests.get(\"https://mwshovel.pythonanywhere.com/api/list-of-beaches/\")\n",
    "# all_beaches = a.json()\n",
    "# b = pd.DataFrame(all_beaches)\n",
    "# b = b.loc[b.water_name_slug == \"lac-leman\"]\n",
    "# beach_slugs = b.slug.values\n",
    "# beach_slugs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# c = requests.get(\"https://mwshovel.pythonanywhere.com/api/surveys/daily-totals/code-totals/\")\n",
    "mcbp = [\n",
    "    'anarchy-beach',\n",
    "    'arabie',\n",
    "    'bain-des-dames',\n",
    "    'baye-de-clarens',\n",
    "    'baye-de-montreux-d',\n",
    "    'baye-de-montreux-g',\n",
    "    'boiron',\n",
    "    'grand-clos',\n",
    "    'jardin-botanique',\n",
    "    'la-morges',\n",
    "    'le-pierrier',\n",
    "    'le-port',\n",
    "    'maladaire',\n",
    "    'oyonne',    \n",
    "    'pierrier-sud',\n",
    "    'plage-de-dorigny',    \n",
    "    'quai-maria-belgia',    \n",
    "    'thonnon-les-bains',    \n",
    "    'versoix',\n",
    "    'veveyse',\n",
    "    'vidy',\n",
    "    'villa-barton'    \n",
    "]\n",
    "precious = [\n",
    "    'preverenges',\n",
    "    \n",
    "]\n",
    "slr =[\n",
    "    'lac-leman-hammerdirt',\n",
    "    'lacleman_gland_kubela',\n",
    "    'lacleman_gland_lecoanets',\n",
    "    'lacleman_vidy_santie',    \n",
    "]\n",
    "epfl = [\n",
    "    'tiger-duck-beach',\n",
    "    'rolle-plage',\n",
    "    'saint-sulpice',\n",
    "    'parc-des-pierrettes',\n",
    "    'plage-de-st-sulpice',    \n",
    "]\n",
    "# totals = c.json()\n",
    "# def just_lac_leman(a_list, some_records):\n",
    "#     new_records = []\n",
    "#     for data in some_records:\n",
    "#         if data['location'] in a_list:\n",
    "#             for record in data['dailyTotals']:\n",
    "#                 record['location_id'] = data['location']\n",
    "#                 record['code_id'] = record['code']\n",
    "#                 new_records.append(record)\n",
    "#     return new_records\n",
    "                \n",
    "# d = just_lac_leman(beach_slugs, totals)\n",
    "\n",
    "def add_project_location(an_array):\n",
    "    new_records = []\n",
    "    for data in an_array:\n",
    "        if data['slug'] in mcbp:\n",
    "            data['project_id'] = \"MCBP\"\n",
    "        elif data['slug'] in slr:\n",
    "            data['project_id'] = \"SLR\"\n",
    "        elif data['slug'] in epfl:\n",
    "            data['project_id'] = \"EPFL\"\n",
    "        elif data['slug'] in precious:\n",
    "            data['project_id'] = \"PC\"\n",
    "        new_records.append(data)\n",
    "    return new_records\n",
    "# e = add_project_location(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# file_name = here + '/Data/'+\"all_data\"+ \".json\"\n",
    "# with open(file_name, 'w') as outfile:\n",
    "#             json.dump(e, outfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# backtojson = b.to_dict(orient='records')\n",
    "# file_name = here + '/Data/'+\"beach_info\"+ \".json\"\n",
    "# with open(file_name, 'w') as outfile:\n",
    "#             json.dump(backtojson, outfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the JSON data in from local\n",
    "# there is no need to hit the server a million times\n",
    "\n",
    "# required variables\n",
    "the_jsons = [\n",
    "    '/home/mw-shovel/three_year_final/Data/beach_info.json',\n",
    "    '/home/mw-shovel/three_year_final/Data/all_data.json'\n",
    "]\n",
    "\n",
    "# all the survey results by code, location, date, project:\n",
    "my_survey_results = jsonFileGet(the_jsons[1])\n",
    "\n",
    "# all the location information:\n",
    "beach_info = jsonFileGet(the_jsons[0])\n",
    "beach_project = add_project_location(beach_info )\n",
    "beaches = pd.DataFrame(beach_project)\n",
    "drop_these = [\"baby-plage-geneva\",'rolle-plage','saint-sulpice']\n",
    "beaches = beaches[~beaches.slug.isin(drop_these)]\n",
    "beach_csv = here + '/Data/'+\"beach_data\"+ \".csv\"\n",
    "beaches.to_csv(beach_csv)\n",
    "\n",
    "# make a data frame:\n",
    "the_survey_results = pd.DataFrame(my_survey_results)\n",
    "\n",
    "the_csv = here + '/Data/'+\"all_data\"+ \".csv\"\n",
    "the_survey_results.to_csv( the_csv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# making a pcs/m column:\n",
    "# the_survey_results[\"pcs_m\"] = the_survey_results[\"quantity\"]/the_survey_results[\"length\"]\n",
    "\n",
    "# making a month, day and year column from a datetime object\n",
    "# makes sorting easier\n",
    "the_survey_results[\"py_date\"] = pd.to_datetime(the_survey_results[\"date\"])\n",
    "the_survey_results[\"py_month\"] = the_survey_results[\"py_date\"].dt.month\n",
    "the_survey_results[\"py_year\"] = the_survey_results[\"py_date\"].dt.year\n",
    "the_survey_results[\"py_day\"] = the_survey_results[\"py_date\"].dt.weekday"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### one df for abundance and one df for density:\n",
    "abundance = the_survey_results[[\"project_id\", \"location_id\", \"date\",\"py_date\", \"py_month\", \"py_year\", \"code_id\", \"quantity\"]].copy()\n",
    "density = the_survey_results[[\"project_id\", \"location_id\", \"date\",\"py_date\", \"py_day\",\"py_month\", \"py_year\", \"code_id\", \"pcs_m\"]].copy()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "year_one_end_start = convertStringToDate([(\"2015-11-15\", \"2016-11-14\")])\n",
    "year_two_end_start = convertStringToDate([(\"2016-11-15\", \"2017-11-14\")])\n",
    "year_three_end_start=convertStringToDate([(\"2017-11-15\", \"2018-11-14\")])\n",
    "project_start_end = convertStringToDate([(\"2015-11-15\", \"2018-11-14\")])\n",
    "start_date = datetime.datetime.strptime(\"2015-11-15\", \"%Y-%m-%d\")\n",
    "end_date = datetime.datetime.strptime(\"2018-11-14\", \"%Y-%m-%d\")\n",
    "project_names = abundance.project_id.unique()\n",
    "def getAnnualSummaries(aList, aDf):\n",
    "    local = aDf.index.get_level_values('project_id')\n",
    "    projects = [x for x in aList if x in local]\n",
    "    out_put = {}\n",
    "    for name in projects:\n",
    "        the_df = aDf.loc[idx[name,:,:],:]\n",
    "        the_summary = the_df.describe()\n",
    "        the_total = the_df.quantity.sum()\n",
    "        the_dict = dict(\n",
    "            project=name,\n",
    "            data=the_df,\n",
    "            summary=the_summary,\n",
    "            the_total=the_total\n",
    "        )\n",
    "        out_put.update({name:the_dict})\n",
    "    combined = dict(\n",
    "        project='All',\n",
    "        data=aDf,\n",
    "        the_total=aDf.quantity.sum(),\n",
    "        summary=aDf.describe()\n",
    "    )\n",
    "    out_put.update({'All':combined})\n",
    "    return out_put"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results: Number of samples, sample locations, profile of participants...\n",
    "\n",
    "#### Samples grouped by participants\n",
    "\n",
    "There were/are many groups on the lake shore concerned by this problem. The data originates from five distinct groups:\n",
    "\n",
    "1. Students from École interantionale de Genève\n",
    "2. Students from The EPFL Solid waste engineering course\n",
    "3. Members of the World Wildlife Fund and or STOPPP\n",
    "4. Members of hammerdirt\n",
    "5. Members of Precious Collect Léman\n",
    "\n",
    "__How are the observations similar or different when sorted by group membership?__ The sampling method and conditions leave alot of responsibiliyt to the sampler. What a persons \"sees\" and how fatigue and environmental conditions effect an individuals attention to detail and motivation are variables that are part of the sampling process.\n",
    "\n",
    "Following a protocol and educating surveyors should minimise the effects of those variables. None the less the effects are real and they may have an impact on the results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "project_data = abundance[\n",
    "    (abundance.py_date >= start_date) & (abundance.py_date <= end_date)]\n",
    "daily_quantity = project_data[\n",
    "    [\"project_id\", \"location_id\",\"py_date\",\"quantity\"]].groupby(\n",
    "    [\"project_id\", \"location_id\",\"py_date\"]).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "yearly_data = project_data[[\"project_id\", \"location_id\",\"py_date\"]].drop_duplicates().copy()\n",
    "\n",
    "yearly_data = yearly_data[[\"project_id\", \"location_id\",\"py_date\"]].groupby([\"project_id\", \"location_id\"]).count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All data  Nov 2015 - Nov 2018"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_data_summary = getAnnualSummaries(project_names,daily_quantity)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "code_folding": [
     0,
     18,
     23
    ]
   },
   "outputs": [],
   "source": [
    "def getRows(aDf, rows):\n",
    "    the_dict = aDf.to_dict()[\"quantity\"]\n",
    "    the_keys = list(the_dict.keys())\n",
    "    for name in the_keys:\n",
    "        if name in rows.keys():\n",
    "            if name in [\"mean\", \"50%\", \"75%\", \"25%\"]:\n",
    "                val = np.round(the_dict[name], 2)\n",
    "                rows[name].append(val)\n",
    "            else:\n",
    "                val = int(the_dict[name])\n",
    "                rows[name].append(val)\n",
    "        else:\n",
    "            if name in [\"mean\", \"50%\", \"75%\", \"25%\"]:\n",
    "                val = np.round(the_dict[name], 2)\n",
    "                rows[name] = [val]\n",
    "            else:\n",
    "                val = int(the_dict[name])\n",
    "                rows[name] = [val]\n",
    "def getTotals(aDict, rows):\n",
    "    if \"total-pcs\" in rows.keys():\n",
    "        rows[\"total-pcs\"].append(aDict[\"the_total\"])\n",
    "    else:\n",
    "        rows[\"total-pcs\"] = [aDict[\"the_total\"]]\n",
    "def makeRows(aDict):\n",
    "    rows={}\n",
    "    header = list(aDict.keys())\n",
    "    for values in aDict:\n",
    "        getRows(aDict[values][\"summary\"], rows)\n",
    "        getTotals(aDict[values],rows)\n",
    "    return rows, header\n",
    "the_rows, header = makeRows(all_data_summary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'count': [6, 107, 2, 33, 148],\n",
       " 'mean': [876.83, 380.1, 108.5, 150.61, 345.4],\n",
       " 'std': [714, 347, 51, 176, 364],\n",
       " 'min': [147, 37, 72, 5, 5],\n",
       " '25%': [366.75, 146.5, 90.25, 37.0, 114.0],\n",
       " '50%': [720.5, 285.0, 108.5, 87.0, 232.5],\n",
       " '75%': [1227.25, 507.0, 126.75, 224.0, 418.25],\n",
       " 'max': [2028, 2003, 145, 853, 2028],\n",
       " 'total-pcs': [5261, 40671, 217, 4970, 51119]}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "the_rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "code_folding": [
     0,
     10,
     20,
     31
    ],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def headerCell(label_s, label, header_bottom, ax):\n",
    "    header_cell = mpatch.Rectangle(\n",
    "            (label_s,header_bottom),\n",
    "            .18, .1, alpha=1, facecolor=\"royalblue\", edgecolor= \"royalblue\")\n",
    "    rx, ry = header_cell.get_xy()\n",
    "    cx = rx + header_cell.get_width()/2.0\n",
    "    cy = ry + header_cell.get_height()/2.0\n",
    "    ax.add_patch(header_cell)\n",
    "    ax.annotate(label, (cx, cy), color='w', weight='bold', \n",
    "            fontsize=12, ha='center', va='center')\n",
    "def tableCell(label_s, label, row_height, faceColor, edgeColor, fontColor, fontWeight, alpha, ax):\n",
    "    table_cell = mpatch.Rectangle(\n",
    "        (label_s,row_height),\n",
    "        .18, .1, alpha=1, facecolor=faceColor, edgecolor=edgeColor)\n",
    "    rx, ry = table_cell.get_xy()\n",
    "    cx = rx + table_cell.get_width()/2.0\n",
    "    cy = ry + table_cell.get_height()/2.0\n",
    "    ax.add_patch(table_cell)\n",
    "    ax.annotate(label, (cx, cy), color=fontColor, weight=fontWeight, \n",
    "            fontsize=12, ha='center', va='center')\n",
    "def rowHeader(label_s, label, row_height,faceColor, edgeColor, alpha, ax):\n",
    "    table_cell = mpatch.Rectangle(\n",
    "        (label_s,row_height),\n",
    "        .12, .1, alpha=1, facecolor=faceColor, edgecolor= edgeColor)\n",
    "    rx, ry = table_cell.get_xy()\n",
    "    cx = rx + table_cell.get_width()/2.0\n",
    "    cy = ry + table_cell.get_height()/2.0\n",
    "    ax.add_patch(table_cell)\n",
    "    ax.annotate(label, (cx, cy), color='b', weight='normal', \n",
    "            fontsize=12, ha='right', va='center')  \n",
    "\n",
    "def makeTable(header, the_rows, header_bottom):\n",
    "    fig = plt.figure(figsize=(8.5,6))\n",
    "    ax = fig.add_subplot(111)\n",
    "    header_bottom=.88\n",
    "    cell_width = .18\n",
    "    for i,label in enumerate(header):\n",
    "        if i == 0:\n",
    "            label_start = .1\n",
    "            headerCell(label_start, label,header_bottom, ax)\n",
    "        else:\n",
    "            label_start = .1 + (i*.18)\n",
    "            headerCell(label_start, label,header_bottom, ax)\n",
    "    for k,x in enumerate(the_rows):\n",
    "        cell_height=.095\n",
    "        label_start = .1\n",
    "        cell_width = .18\n",
    "        if k == 0:\n",
    "            row_height = header_bottom-cell_height        \n",
    "            for j,value in enumerate(the_rows[x]):\n",
    "                if j == 0:                \n",
    "                    label_start = .1\n",
    "                    tableCell(\n",
    "                        label_start,\n",
    "                        value,\n",
    "                        row_height,\n",
    "                        \"none\",\n",
    "                        \"royalblue\",\n",
    "                        \"royalblue\",\n",
    "                        \"normal\",\n",
    "                        1, ax)\n",
    "\n",
    "                else:\n",
    "                    label_start = .1 + (j*cell_width)\n",
    "                    tableCell(\n",
    "                        label_start,\n",
    "                        value,\n",
    "                        row_height,\n",
    "                        \"none\",\n",
    "                        \"royalblue\",\n",
    "                        \"royalblue\",\n",
    "                        \"normal\",\n",
    "                        1, ax)\n",
    "        else:\n",
    "            row_height = header_bottom-cell_height-(cell_height*k)\n",
    "            if k%2 != 0:        \n",
    "                for j,value in enumerate(the_rows[x]):\n",
    "                    if j == 0:\n",
    "                        label_start = .1\n",
    "                        tableCell(\n",
    "                            label_start,\n",
    "                            value,\n",
    "                            row_height,\n",
    "                            \"royalblue\",\n",
    "                            \"royalblue\",\n",
    "                            \"white\",\n",
    "                            \"normal\",\n",
    "                            1, ax\n",
    "                        )\n",
    "                    else:\n",
    "                        label_start = .1 + (j*cell_width)\n",
    "                        tableCell(\n",
    "                            label_start,\n",
    "                            value,\n",
    "                            row_height,\n",
    "                            \"royalblue\",\n",
    "                            \"royalblue\",\n",
    "                            \"white\",\n",
    "                            \"normal\",\n",
    "                            1, ax\n",
    "                        )\n",
    "            else:\n",
    "                for j,value in enumerate(the_rows[x]):\n",
    "                    if j == 0:\n",
    "                        label_start = .1\n",
    "                        tableCell(\n",
    "                            label_start,\n",
    "                            value,\n",
    "                            row_height,\n",
    "                            \"none\",\n",
    "                            \"royalblue\",\n",
    "                            \"royalblue\",\n",
    "                            \"normal\",\n",
    "                            1, ax\n",
    "                        )\n",
    "                    else:\n",
    "                        label_start = .1 + (j*cell_width)\n",
    "                        tableCell(\n",
    "                            label_start,\n",
    "                            value,\n",
    "                            row_height,\n",
    "                            \"none\",\n",
    "                            \"royalblue\",\n",
    "                            \"royalblue\",\n",
    "                            \"normal\",\n",
    "                            1, ax\n",
    "                        )\n",
    "    for n,x in enumerate(list(the_rows.keys())):\n",
    "        label_start = .01\n",
    "        cell_height=.095\n",
    "        if n == 0:\n",
    "            row_height = header_bottom-cell_height  \n",
    "            rowHeader(label_start, x, row_height,\"none\", \"none\", 1, ax)   \n",
    "        else:\n",
    "            row_height = header_bottom-cell_height-(cell_height*n)\n",
    "            rowHeader(label_start, x,row_height, \"none\", \"none\", 1, ax) \n",
    "\n",
    "    ax.axis(\"off\")\n",
    "    plt.show()\n",
    "makeTable(header, the_rows, .88)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Year one Nov 2015 - Nov 2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "year_one_data = daily_quantity.loc[idx[:,:,year_one_end_start[0][0]:year_one_end_start[0][1]], :]\n",
    "projct_names = list(year_one_data.index.get_level_values(0))\n",
    "all_data_summary = getAnnualSummaries(project_names,year_one_data)\n",
    "the_rows, header = makeRows(all_data_summary)\n",
    "makeTable(header, the_rows, .88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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></th>\n",
       "      <th></th>\n",
       "      <th>quantity</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>project_id</th>\n",
       "      <th>location_id</th>\n",
       "      <th>py_date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">EPFL</th>\n",
       "      <th>parc-des-pierrettes</th>\n",
       "      <th>2016-10-13</th>\n",
       "      <td>693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plage-de-st-sulpice</th>\n",
       "      <th>2016-10-13</th>\n",
       "      <td>2028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MCBP</th>\n",
       "      <th>arabie</th>\n",
       "      <th>2016-01-24</th>\n",
       "      <td>2003</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                           quantity\n",
       "project_id location_id         py_date             \n",
       "EPFL       parc-des-pierrettes 2016-10-13       693\n",
       "           plage-de-st-sulpice 2016-10-13      2028\n",
       "MCBP       arabie              2016-01-24      2003"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "year_one_data.iloc[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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></th>\n",
       "      <th>py_date</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>project_id</th>\n",
       "      <th>location_id</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">EPFL</th>\n",
       "      <th>parc-des-pierrettes</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plage-de-st-sulpice</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MCBP</th>\n",
       "      <th>arabie</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                py_date\n",
       "project_id location_id                 \n",
       "EPFL       parc-des-pierrettes        1\n",
       "           plage-de-st-sulpice        1\n",
       "MCBP       arabie                     3"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "year_one_data.reset_index(inplace=True)\n",
    "year_one_data = year_one_data[[\"project_id\", \"location_id\", \"py_date\"]].drop_duplicates().copy()\n",
    "year_one_data = year_one_data[[\"project_id\", \"location_id\",\"py_date\"]].groupby([\"project_id\", \"location_id\"]).count()\n",
    "year_one_data.iloc[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>Total</th>\n",
       "      <th>Year one</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>location_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>parc-des-pierrettes</th>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plage-de-st-sulpice</th>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>saint-sulpice</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tiger-duck-beach</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>anarchy-beach</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Total  Year one\n",
       "location_id                         \n",
       "parc-des-pierrettes      2       1.0\n",
       "plage-de-st-sulpice      2       1.0\n",
       "saint-sulpice            1       0.0\n",
       "tiger-duck-beach         1       0.0\n",
       "anarchy-beach            1       0.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.merge(yearly_data, year_one_data, on='location_id', how='left').fillna(0)\n",
    "\n",
    "df.columns = [\"Total\", \"Year one\"]\n",
    "\n",
    "df.iloc[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Year two Nov 2016 - Nov 2017"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "year_two_data = daily_quantity.loc[idx[:,:,year_two_end_start[0][0]:year_two_end_start[0][1]], :]\n",
    "projct_names = list(year_two_data.index.get_level_values(0))\n",
    "all_data_summary = getAnnualSummaries(project_names,year_two_data)\n",
    "the_rows, header = makeRows(all_data_summary)\n",
    "makeTable(header, the_rows, .88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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></th>\n",
       "      <th>py_date</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>project_id</th>\n",
       "      <th>location_id</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">EPFL</th>\n",
       "      <th>parc-des-pierrettes</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plage-de-st-sulpice</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">MCBP</th>\n",
       "      <th>arabie</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bain-des-dames</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baye-de-montreux-d</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                py_date\n",
       "project_id location_id                 \n",
       "EPFL       parc-des-pierrettes        1\n",
       "           plage-de-st-sulpice        1\n",
       "MCBP       arabie                     1\n",
       "           bain-des-dames             1\n",
       "           baye-de-montreux-d         1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "year_two_data.reset_index(inplace=True)\n",
    "year_two_data = year_two_data[[\"project_id\", \"location_id\", \"py_date\"]].drop_duplicates().copy()\n",
    "year_two_data = year_two_data[[\"project_id\", \"location_id\",\"py_date\"]].groupby([\"project_id\", \"location_id\"]).count()\n",
    "year_two_data.iloc[:5]"
   ]
  },
  {
   "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>Total</th>\n",
       "      <th>Year one</th>\n",
       "      <th>Year two</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>location_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>parc-des-pierrettes</th>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plage-de-st-sulpice</th>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>saint-sulpice</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tiger-duck-beach</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>anarchy-beach</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Total  Year one  Year two\n",
       "location_id                                   \n",
       "parc-des-pierrettes      2       1.0       1.0\n",
       "plage-de-st-sulpice      2       1.0       1.0\n",
       "saint-sulpice            1       0.0       0.0\n",
       "tiger-duck-beach         1       0.0       0.0\n",
       "anarchy-beach            1       0.0       0.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.merge(df, year_two_data, on='location_id', how='left').fillna(0)\n",
    "\n",
    "\n",
    "df.columns = ['Total', 'Year one', 'Year two']\n",
    "\n",
    "df.iloc[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Year three Nov 2017 - Nov 2018"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "year_three_data = daily_quantity.loc[idx[:,:,year_three_end_start[0][0]:year_three_end_start[0][1]], :]\n",
    "projct_names = list(year_three_data.index.get_level_values(0))\n",
    "all_data_summary = getAnnualSummaries(project_names,year_three_data)\n",
    "the_rows, header = makeRows(all_data_summary)\n",
    "makeTable(header, the_rows, .88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "year_three_data.reset_index(inplace=True)\n",
    "year_three_data = year_three_data[[\"project_id\", \"location_id\", \"py_date\"]].drop_duplicates().copy()\n",
    "year_three_data = year_three_data[[\"project_id\", \"location_id\",\"py_date\"]].groupby([\"project_id\", \"location_id\"]).count()\n",
    "year_three_data\n",
    "\n",
    "df = pd.merge(df, year_three_data, on='location_id', how='left').fillna(0)\n",
    "df.columns = ['Total', 'Year one', 'Year two','Year three']\n",
    "\n",
    "df.loc['Total']= df.sum(axis=0)\n",
    "\n",
    "df = df.astype('int32')\n",
    "\n",
    "df = df[[ 'Year one', 'Year two','Year three','Total']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>Year one</th>\n",
       "      <th>Year two</th>\n",
       "      <th>Year three</th>\n",
       "      <th>Total</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>location_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>parc-des-pierrettes</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plage-de-st-sulpice</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>saint-sulpice</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tiger-duck-beach</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>anarchy-beach</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>arabie</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bain-des-dames</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baye-de-clarens</th>\n",
       "      <td>13</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baye-de-montreux-d</th>\n",
       "      <td>15</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baye-de-montreux-g</th>\n",
       "      <td>11</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>boiron</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>grand-clos</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>jardin-botanique</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>la-morges</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>le-pierrier</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>le-port</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>maladaire</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>oyonne</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pierrier-sud</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>plage-de-dorigny</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>quai-maria-belgia</th>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>thonnon-les-bains</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>versoix</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>veveyse</th>\n",
       "      <td>14</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vidy</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>villa-barton</th>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>preverenges</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lac-leman-hammerdirt</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lacleman_gland_kubela</th>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lacleman_gland_lecoanets</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lacleman_vidy_santie</th>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Total</th>\n",
       "      <td>83</td>\n",
       "      <td>41</td>\n",
       "      <td>24</td>\n",
       "      <td>148</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          Year one  Year two  Year three  Total\n",
       "location_id                                                    \n",
       "parc-des-pierrettes              1         1           0      2\n",
       "plage-de-st-sulpice              1         1           0      2\n",
       "saint-sulpice                    0         0           1      1\n",
       "tiger-duck-beach                 0         0           1      1\n",
       "anarchy-beach                    0         0           1      1\n",
       "arabie                           3         1           1      5\n",
       "bain-des-dames                   1         1           1      3\n",
       "baye-de-clarens                 13         0           0     13\n",
       "baye-de-montreux-d              15         1           0     16\n",
       "baye-de-montreux-g              11         1           0     12\n",
       "boiron                           1         0           0      1\n",
       "grand-clos                       1         1           0      2\n",
       "jardin-botanique                 3         0           0      3\n",
       "la-morges                        0         1           0      1\n",
       "le-pierrier                      3         1           0      4\n",
       "le-port                          1         0           0      1\n",
       "maladaire                        2         0           0      2\n",
       "oyonne                           1         1           0      2\n",
       "pierrier-sud                     1         0           0      1\n",
       "plage-de-dorigny                 0         1           0      1\n",
       "quai-maria-belgia                0         8           2     10\n",
       "thonnon-les-bains                1         0           0      1\n",
       "versoix                          0         1           0      1\n",
       "veveyse                         14         3           0     17\n",
       "vidy                             1         0           0      1\n",
       "villa-barton                     9         0           0      9\n",
       "preverenges                      0         0           2      2\n",
       "lac-leman-hammerdirt             0         1           0      1\n",
       "lacleman_gland_kubela            0         6           5     11\n",
       "lacleman_gland_lecoanets         0         4           5      9\n",
       "lacleman_vidy_santie             0         7           5     12\n",
       "Total                           83        41          24    148"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_csv = here + '/Data/'+\"yearly_summary\"+ \".csv\"\n",
    "df.to_csv(the_csv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}