main.py

"""File to execute to show results"""
# Data
from parameters import SESSION, DIR_OUT, START, END
# Basic
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import warnings
import re
import os
# Stats
import statsmodels.graphics as stm_graphs
import pandas as pd 
import statsmodels.api as stm
import numpy as np
# Graph map
from mpl_toolkits.basemap import Basemap
from pandas.plotting import register_matplotlib_converters
from datetime import datetime

register_matplotlib_converters()
warnings.filterwarnings("ignore")


def execute_query(query):
    for row in SESSION.execute(query):
        yield row


def ask_q(possibilities, text=">>> "):
    """Demande une question"""
    answer = None
    while answer not in possibilities:
        answer = input(text)
    return answer


def ask_d(text=">>> "):
    """Demande une date"""
    print("Entrez une date sous la forme YYYY-MM-DD HH:mm")
    print("Comprise entre {} et {}".format(START.strftime('%Y-%m-%d'), END.strftime('%Y-%m-%d')))
    date_parser = re.compile(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}) (?P<hour>\d{2}):(?P<minute>\d{2})")
    match = None

    while match is None:
        t = input(text)
        match = date_parser.match(t)

    m = match.groupdict()
    result = (int(m['year']), int(m['month']), int(m['day']), int(m['hour']), int(m['minute']))
            
    return result


def chose_attr():
    """Permet de demander un attribut dans la table"""
    # Search element
    decision = {
        "tmpf": "La témparature",
        "relh": "L'humidité"
    }
    print("Choisissez un élément parmis les suivant :")
    for code, text in decision.items():
        print("\t-", text, ":", code)
    return ask_q(decision.keys())


def ask_cluster(text=">>> "):
    answer = ""
    while not answer or not answer.isdigit():
        answer = input(text)
    return int(answer)


class Manager:
    table = None  # table name use by the function

    def run(self):
        """Chose objective"""
        # Initialisation
        os.makedirs(DIR_OUT, exist_ok=True)

        # Chose objective
        print("Choisissez ce que vous voulez faire")
        print("\t1 - Pour un point donné de l’espace, je veux pouvoir avoir un historique du passé")
        print("\t2 - À un instant donné je veux pouvoir obtenir une carte me représentant n’importe quel indicateur")
        print("\t3 - Pour une période de temps donnée, je veux pouvoir obtenir clusteriser l’espace, et représenter "
              "cette clusterisation")
        decision = {
            "1": "historic",
            "2": "map",
            "3": "cluster"
        }
        answer = ask_q(decision.keys())
        getattr(self, decision[answer])()

    def historic(self):
        self.table = "TABLE_SPACE"
        print("=== Choix 1 : Historique ===")

        # Search station
        stations = []
        print("Choisissez une station parmis celles-ci:")
        query = "SELECT DISTINCT station FROM {}".format(self.table)
        for i, row in enumerate(execute_query(query), 1):
            end = "\n" if i % 3 == 0 else ""
            print("\t", row.station, end=end)
            stations.append(row.station)
        print()

        station = ask_q(stations)
        attr = chose_attr()

        ts = pd.Series()
        query = "SELECT time, {} FROM {} WHERE station={}".format(attr, self.table, station.__repr__())
        for row in execute_query(query):
            value = getattr(row, attr)
            if value is None:
                continue
            ts.loc[datetime(*list(row.time))] = value

        plt.figure(figsize=(25, 16))
        axes = plt.subplot()
        axes.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))
        plt.xticks(rotation=90)

        plt.plot(ts, label=attr)
        plt.title("Donnees de {} pour la station : {}".format(attr, station))
        plt.legend()
        plt.show()
        path = os.path.join(DIR_OUT, 'graph_{}_{}.png'.format(station, attr))
        plt.savefig(path)

        res = stm.tsa.seasonal_decompose(ts, freq=15, extrapolate_trend='freq')
        res.plot()
        plt.show()
        path = os.path.join(DIR_OUT, 'decompose_{}_{}.png'.format(station, attr))
        plt.savefig(path)

        stm_graphs.tsaplots.plot_acf(ts, lags=30)
        plt.show()
        path = os.path.join(DIR_OUT, 'acf_{}_{}.png'.format(station, attr))
        plt.savefig(path)

    def map(self):
        self.table = "TABLE_TIME"
        print("=== Choix 2 : Map ===")

        date = ask_d()
        attr = chose_attr()

        plt.figure(figsize=(14, 14))
        the_map = Basemap(projection='mill', llcrnrlat=25.281898, llcrnrlon=-18.42, urcrnrlat=48.08, urcrnrlon=10.35,
                          resolution='l')
        # draw coastlines, country boundaries, fill continents.
        the_map.drawcoastlines(linewidth=0.25)
        the_map.drawcountries(linewidth=0.25)
        the_map.fillcontinents(color='coral', lake_color='aqua')
        # draw the edge of the map projection region (the projection limb)
        the_map.drawmapboundary(fill_color='aqua')
        # draw lat/lon grid lines every 30 degrees.
        the_map.drawmeridians(np.arange(0, 360, 30))
        the_map.drawparallels(np.arange(-90, 90, 30))

        date_ok = False  # The date is valide
        query = "SELECT station, lon, lat, {} FROM {} WHERE time={}".format(attr, self.table, date)
        for row in execute_query(query):
            if getattr(row, "station") is None or getattr(row, attr) is None:
                continue
            date_ok = True
            x, y = the_map(getattr(row, "lon"), getattr(row, "lat"))
            value = getattr(row, attr)
            plt.plot(x, y, 'go')
            plt.annotate(round(value, 1), (x, y))

        title = "Map {} du {}".format(attr, datetime(*list(date)).strftime('%Y-%m-%d %H:%M'))
        plt.title(title)
        plt.show()
        for elt in ' :-':
            title = title.replace(elt, '_')
        path = os.path.join(DIR_OUT, title.lower() + '.png')
        plt.savefig(path)

        # If date is wrong, show some dates for this day
        if not date_ok:
            date_begin = list(date)
            date_begin[3] = date_begin[4] = 0  # set hours and minutes at 0
            date_begin = tuple(date_begin)

            date_end = list(date)
            date_end[3] = 23
            date_end[4] = 59
            date_end = tuple(date_end)
            print("Seules ces heures sont disponibles pour ce jour")

            query = "SELECT DISTINCT time FROM {} WHERE time >= {} AND time <= {} ALLOW FILTERING".format(
                self.table,
                date_begin,
                date_end,
            )
            for row in execute_query(query):
                resp = list(getattr(row, "time"))
                print(str(resp[3]).zfill(2) + ":" + str(resp[4]).zfill(2), end=" - ")

    def cluster(self):
        self.table = "TABLE_TIME"
        print("=== Choix 3 : CLUSTER ===")

        # Ask Date
        print("La date de départ :")
        date_b = ask_d()
        print("Entrez la date de fin sous la forme YYYY-MM-DD HH:mm")
        date_e = ask_d()
        print("Entrez le nombre de cluster voulus")
        nb_clust = ask_cluster()

        query = "SELECT * FROM {} WHERE time>={} AND time <= {}".format(self.table, date_b, date_e)
        for row in execute_query(query):
            if getattr(row, "station") is None:
                continue
            x, y = map(getattr(row, "lon"), getattr(row, "lat"))
            value = getattr(row, attr)
            plt.plot(x, y, 'go')
            plt.annotate(round(value, 1), (x, y))

        if False:
            plt.figure(figsize=(14, 14))
            map = Basemap(projection='mill', llcrnrlat=25.281898, llcrnrlon=-18.42, urcrnrlat=48.08, urcrnrlon=10.35,
                          resolution='l')
            # draw coastlines, country boundaries, fill continents.
            map.drawcoastlines(linewidth=0.25)
            map.drawcountries(linewidth=0.25)
            map.fillcontinents(color='coral', lake_color='aqua')
            # draw the edge of the map projection region (the projection limb)
            map.drawmapboundary(fill_color='aqua')
            # draw lat/lon grid lines every 30 degrees.
            map.drawmeridians(np.arange(0, 360, 30))
            map.drawparallels(np.arange(-90, 90, 30))

            plt.title('Map')
            plt.show()
            plt.savefig('./out/map.png')


if __name__ == "__main__":
    Manager().run()