main.py

"""File to execute to show results"""
# Data
from parameters import SESSION
# Basic
import re
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import warnings
# 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")
    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 choose_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"""
        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"

        # 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 = choose_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 " + str(attr) + " pour la station : " + station)
        plt.legend()
        plt.show()
        plt.savefig('./out/graph_' + station + '_' + str(attr) + '.png')

        res = stm.tsa.seasonal_decompose(ts, freq=15, extrapolate_trend='freq')
        res.plot()
        plt.show()
        plt.savefig('./out/decompose_' + station + '_' + str(attr) + '.png')

        stm_graphs.tsaplots.plot_acf(ts, lags=30)
        plt.show()
        plt.savefig('./out/acf_' + station + '_' + str(attr) + '.png')

    def map(self):
        self.table = "TABLE_TIME"

        date = ask_d()
        attr = choose_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))

        try:
            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:
                    continue
                x, y = the_map(row.lon, row.lat)
                value = getattr(row, attr)
                plt.plot(x, y, 'go')
                plt.annotate(round(value, 1), (x, y))
            plt.title('Map')
            plt.show()
            plt.savefig('./out/map.png')
        except:
            dateb = list(date)
            dateb[3] = 0
            dateb[4] = 0
            dateb = tuple(dateb)

            datee = list(date)
            datee[3] = 23
            datee[4] = 59
            datee = tuple(dateb)
            print("Seul ces heures sont disponibles pour ce jour")
            query = "SELECT DISTINCT time FROM {} WHERE time>={} AND time <= {} ALLOW FILTERING".format(self.table,
                                                                                                        dateb, datee)
            for row in execute_query(query):
                print(getattr(row, "time"))

    def cluster(self):
        self.table = "TABLE_TIME"

        # Ask Date
        print("Entrez la date de départ")
        date_b = ask_d()
        print("Entrez la date de fin")
        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()