Module DateFab_NumTombee_Dataset

#################################################
### THIS FILE WAS AUTOGENERATED! DO NOT EDIT! ###
#################################################
# file to edit: 00 - Class DateFab_NumTombee_Dataset.ipynb

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from bokeh.io import show, output_notebook
from bokeh.models import ColumnDataSource
from bokeh.plotting import figure
from bokeh.transform import jitter
from bokeh.models import HoverTool
from bokeh.models import Legend, LegendItem
from math import pi

from IPython.display import set_matplotlib_formats
set_matplotlib_formats('png', 'pdf')

import os.path, platform





from exp.init_D059 import *
check_SECU()


class DateFab_NumTombee_Dataset:
    '''Pour stocker les datasets contenant les clés Date_Fab et Num_Tombee'''
    def __init__(self, dataset, name, description=''):
        '''
        les attributs:
        - dataset : une copie du dataframe, on supprime les vrais doublons (2 lignes strictement identiques)
        - name : le nom (abrégé) du dataframe
        - description : une description en quelques mots
        '''
        self.dataset = dataset.copy()
        self.name = name
        self.description = description
        # on supprime les lignes dupliquées: 2 lignes strictement identiques
        self.dataset.drop_duplicates(inplace=True)

    def get_info(self):
        '''retourne le nom, la description du dataset'''
        return f"\n Dataset {self.name} [{self.description}]\n"

    def get_shape(self):
        '''retourne le nombre de lignes et colonnes du dataset'''
        return f" - shape : ({self.dataset.shape})\n"

    def get_dates(self):
        '''retourne l'amplitude temporelle de Date_Fab du dataset'''
        return f" - amplitude temporelle : ({self.dataset.Date_Fab.min()} - {self.dataset.Date_Fab.max()})\n"

    def __repr__(self):
        '''retourne get_info quand évalué directement'''
        return self.get_info()

    def __str__(self):
        '''retourne get_info, get_shape, get_dates dans un print(<DateFab_NumTombee_Dataset>)'''
        return self.get_info()+self.get_shape()+self.get_dates()+'\n'

    def get_duplicates(self, keep=False):
        '''retourne les lignes du dataset qui contiennent des doublons sur la base de la clé
        Date_Fab, Num_Tombee
        keep{‘first’, ‘last’, False}, default ‘False’
            Determines which duplicates (if any) to mark.
            first : Mark duplicates as True except for the first occurrence.
            last : Mark duplicates as True except for the last occurrence.
            False : Mark all duplicates as True.
        '''
        return self.dataset.loc[self.dataset.duplicated(subset=['Num_Tombee', 'Date_Fab'], keep=keep)]

    def _create_tempo_df(self, dataset_copy):
        '''
        fonction technique (pas à appeler directement)
        à partir d'un dataset qui contient
        les colonnes date_week, date_year
        crée un dataframe dense de 0 de la 1ere semaine à la derniere
        (c'est uniquement pour completer les density plots : plot_density_per_week, plot_density_per_week_bokeh, comparaison_plot_density)
        '''
        if (dataset_copy.shape[0]==0):
            return pd.DataFrame()
        debut_annee=dataset_copy['date_year'].min()
        fin_annee=dataset_copy['date_year'].max()
        debut_semaine=dataset_copy.loc[dataset_copy['date_year'] == debut_annee]['date_week'].min()
        fin_semaine=dataset_copy.loc[dataset_copy['date_year'] == fin_annee]['date_week'].max()
        liste_tempo = []
        for annee in range(debut_annee, fin_annee+1):
            deb_sem = 1
            fin_sem = 52
            if (annee == debut_annee):
                deb_sem = debut_semaine
            if (annee == fin_annee):
                fin_sem = fin_semaine
            for sem in range(deb_sem, fin_sem+1):
                liste_tempo.append([annee, sem, 0, 0])
        liste_tempo_df = pd.DataFrame(liste_tempo, columns =['date_year', 'date_week', 'Unique', 'Doublons']).set_index(['date_year', 'date_week'])
        return liste_tempo_df


    def plot_density_per_week_matplotlib(self, without_duplicate=False):
        '''affiche le nombre d'observations par semaine
        si without_duplicate=True, on drop les doublons sur le critere ['Num_Tombee', 'Date_Fab']
        sinon on les affiche en rouge (par défaut)
        '''
        dataset_copy = self.dataset.copy()
        if (without_duplicate):
            dataset_copy.drop_duplicates(subset=['Date_Fab', 'Num_Tombee'], inplace=True)
        # add columns for week and year of the date
        dataset_copy['date_week'] = dataset_copy['Date_Fab'].apply(lambda x: x.isocalendar()[1])
        dataset_copy['date_year'] = dataset_copy['Date_Fab'].apply(lambda x: x.isocalendar()[0])

        dataset_unique = dataset_copy.drop_duplicates(subset=['Date_Fab', 'Num_Tombee'])
        dataset_doublon = dataset_copy.loc[dataset_copy.index.difference(dataset_unique.index)]
        groupage_unique = dataset_unique.groupby([dataset_unique['date_year'],dataset_unique['date_week']])['Num_Tombee'].count()
        groupage_doublon = dataset_doublon.groupby([dataset_doublon['date_year'],dataset_doublon['date_week']])['Num_Tombee'].count()

        graph_rft = pd.concat([groupage_unique, groupage_doublon], axis=1)
        graph_rft.columns=['Unique', 'Doublons']
        graph_rft=graph_rft[['Unique', 'Doublons']]

        graph_rft=graph_rft.reindex(self._create_tempo_df(dataset_copy).index)

        colors = ["green" , "red"]
        barWidth = 0.85
        graph_rft.plot.bar(stacked=True, color=colors, figsize=(17,7),width=barWidth)
        plt.show()

    def plot_density_per_week(self, without_duplicate=False):
        '''affiche le nombre d'observations par semaine
        si without_duplicate=True, on drop les doublons sur le critere ['Num_Tombee', 'Date_Fab']
        sinon on les affiche en rouge (par défaut)
        '''
        dataset_copy = self.dataset.copy()
        if (without_duplicate):
            dataset_copy.drop_duplicates(subset=['Date_Fab', 'Num_Tombee'], inplace=True)
        # add columns for week and year of the date
        dataset_copy['date_week'] = dataset_copy['Date_Fab'].apply(lambda x: x.isocalendar()[1])
        dataset_copy['date_year'] = dataset_copy['Date_Fab'].apply(lambda x: x.isocalendar()[0])

        dataset_unique = dataset_copy.drop_duplicates(subset=['Date_Fab', 'Num_Tombee'])
        dataset_doublon = dataset_copy.loc[dataset_copy.index.difference(dataset_unique.index)]
        groupage_unique = dataset_unique.groupby([dataset_unique['date_year'],dataset_unique['date_week']])['Num_Tombee'].count()
        groupage_doublon = dataset_doublon.groupby([dataset_doublon['date_year'],dataset_doublon['date_week']])['Num_Tombee'].count()

        graph_rft = pd.concat([groupage_unique, groupage_doublon], axis=1)
        graph_rft.columns=['Unique', 'Doublons']
        graph_rft=graph_rft[['Unique', 'Doublons']]

        graph_rft=graph_rft.reindex(self._create_tempo_df(dataset_copy).index)
        graph_rft=graph_rft.reset_index(level=[0,1])
        graph_rft['index']=graph_rft['date_year'].apply(str)+'-'+graph_rft['date_week'].apply(str)
        graph_rft.fillna(0, inplace=True)
        graph_rft['total']=graph_rft['Unique']+graph_rft['Doublons']
    #     graph_rft['index']=graph_rft['index'].astype('int64')
        graph_rft.set_index(['index'], inplace=True)

        graph_rft.drop(['date_year', 'date_week'], axis=1, inplace=True)

    #     return graph_rft

        colors = ["green" , "red"]
        barWidth = 0.7
    #         graph_rft.plot.bar(stacked=True, color=colors, figsize=(17,7),width=barWidth)
    #         plt.show()

        output_notebook()
        TOOLS = "xpan,xwheel_zoom,crosshair, reset,save"

        p = figure(x_range=list(graph_rft.index), title="Density plot "+self.name,
                   tools=TOOLS, active_scroll='xwheel_zoom', plot_width=900, plot_height=500)
        v = p.vbar_stack(['Unique', 'Doublons'], x='index', width=barWidth, color=colors,
                     source=graph_rft, line_color=None)

        tooltips = [
            ("Total ", "@total"),
            ("Unique ", "@Unique"),
            ("Doublons ", "@Doublons"),
            ('# de semaine ', "@index")
        ]

        hover = HoverTool(tooltips=tooltips)
        p.add_tools(hover)
    #     item1 = LegendItem({'label':'Unique', 'renderers':[p.renderers[0]]});
    #     item2 = LegendItem({'label':'Doublons', 'renderers':[p.renderers[1]]});
    #     legend = Legend(items=[item1, item2])
    #     p.add_layout(legend)

        legend=Legend(items=[
            ("Unique",   [v[0]]),
            ("Doublons",   [v[1]])
        ], location=(0, -30))
        p.add_layout(legend)

        p.legend.orientation = "horizontal"
        p.legend.location = "top_center"
        p.legend.click_policy="hide"

        p.xaxis.major_label_orientation = 3*pi/8
        p.xaxis.axis_label_text_font_size = "5pt"
        p.xaxis.major_label_text_font_size = "5pt"
        p.xaxis.axis_label_text_font = "times"
        p.xaxis.axis_label_text_color = "black"

        show(p)

    def extraire_periode(self, date_debut, date_fin):
        '''
        retourne un objet DateFab_NumTombee_Dataset
        en ne gardant le contenu du dataset obéissant à date_debut<= Date_Fab <= date_fin

        les dates peuvent être à structure variable: '2021' (année), '2021-01' (mois), '2021-05-23' (jour)
        '''
        sous_dataset=self.dataset.copy()[(self.dataset.Date_Fab >= pd.to_datetime(date_debut))
                                                     & (self.dataset.Date_Fab <= pd.to_datetime(date_fin))]
        nouveauDateFab_NumTombee_Dataset = DateFab_NumTombee_Dataset(sous_dataset, self.name, self.description+f' filtré entre {date_debut} et {date_fin}.')
        return nouveauDateFab_NumTombee_Dataset


    def comparaison(self, autreDateFab_NumTombee_Dataset):
        '''retourne 3 objets DateFab_NumTombee_Dataset dont les datasets sont:
        - dataset_commun - c'est l'intersection des index (Date_Fab, Num_Tombee) de self et autreDateFab_NumTombee_Dataset
        - dataset_difference_gauche - c'est la difference des index (Date_Fab, Num_Tombee) de self et
                                        autreDateFab_NumTombee_Dataset en partant de self
        - dataset_difference_droite - c'est la difference des index (Date_Fab, Num_Tombee) de self et
                                        autreDateFab_NumTombee_Dataset en partant de autreDateFab_NumTombee_Dataset
        '''
        index_commun = self.dataset.set_index(['Date_Fab', 'Num_Tombee']).index.intersection(autreDateFab_NumTombee_Dataset.dataset.set_index(['Date_Fab', 'Num_Tombee']).index)
        index_gauche = self.dataset.set_index(['Date_Fab', 'Num_Tombee']).index.difference(autreDateFab_NumTombee_Dataset.dataset.set_index(['Date_Fab', 'Num_Tombee']).index)
        index_droite = autreDateFab_NumTombee_Dataset.dataset.set_index(['Date_Fab', 'Num_Tombee']).index.difference(self.dataset.set_index(['Date_Fab', 'Num_Tombee']).index)

        if (len(index_commun)==0):
            dataset_commun=pd.DataFrame(columns=self.dataset.columns)
        else:
            dataset_commun = self.dataset.set_index(['Date_Fab', 'Num_Tombee']).loc[index_commun].reset_index()

        if (len(index_gauche)==0):
            dataset_difference_gauche = pd.DataFrame(columns=self.dataset.columns)
        else:
            dataset_difference_gauche = self.dataset.set_index(['Date_Fab', 'Num_Tombee']).loc[index_gauche].reset_index()

        if (len(index_droite)==0):
            dataset_difference_droite = pd.DataFrame(columns=autreDateFab_NumTombee_Dataset.dataset.columns)
        else:
            dataset_difference_droite = autreDateFab_NumTombee_Dataset.dataset.set_index(['Date_Fab', 'Num_Tombee']).loc[index_droite].reset_index()

        dataset_commun_obj = DateFab_NumTombee_Dataset(dataset_commun, self.name+' inter '+autreDateFab_NumTombee_Dataset.name, 'Intersection des 2 datasets : \n'+self.description+'\n'+autreDateFab_NumTombee_Dataset.description)
        dataset_difference_gauche_obj = DateFab_NumTombee_Dataset(dataset_difference_gauche, self.name+' diff '+autreDateFab_NumTombee_Dataset.name, 'Différence des 2 datasets : \n'+self.description+'\n'+autreDateFab_NumTombee_Dataset.description)
        dataset_difference_droite_obj = DateFab_NumTombee_Dataset(dataset_difference_droite, autreDateFab_NumTombee_Dataset.name+' diff '+self.name, 'Différence des 2 datasets : \n'+autreDateFab_NumTombee_Dataset.description+'\n'+self.description)
        print(f'couverture commune : {100*dataset_commun_obj.dataset.shape[0]/(dataset_commun_obj.dataset.shape[0]+dataset_difference_gauche_obj.dataset.shape[0]+dataset_difference_droite_obj.dataset.shape[0]):0.02f} %')
        return dataset_commun_obj, dataset_difference_gauche_obj, dataset_difference_droite_obj


    def comparaison_plot_density_matplotlib(self, autreDateFab_NumTombee_Dataset):
        '''affiche le nombre d'observations par semaine
        3 informations :
        - en bleu : les données uniquement dans self
        - en vert: les données (index) communes aux 2 datasets
        - en rouge : les données uniquement dans autreDateFab_NumTombee_Dataset
        '''
        obj_commun, obj_gauche, obj_droite = self.comparaison(autreDateFab_NumTombee_Dataset)
        for dataset in [obj_commun.dataset, obj_gauche.dataset, obj_droite.dataset]:
            # add columns for week and year of the date
            dataset['date_week'] = dataset['Date_Fab'].apply(lambda x: x.isocalendar()[1])
            dataset['date_year'] = dataset['Date_Fab'].apply(lambda x: x.isocalendar()[0])

        groupage_commun = obj_commun.dataset.groupby([obj_commun.dataset['date_year'],obj_commun.dataset['date_week']])['Num_Tombee'].count()
        groupage_gauche = obj_gauche.dataset.groupby([obj_gauche.dataset['date_year'],obj_gauche.dataset['date_week']])['Num_Tombee'].count()
        groupage_droite = obj_droite.dataset.groupby([obj_droite.dataset['date_year'],obj_droite.dataset['date_week']])['Num_Tombee'].count()


        graph_rft = pd.concat([groupage_gauche, groupage_commun, groupage_droite], axis=1)
        graph_rft.columns=[obj_gauche.name, obj_commun.name, obj_droite.name]
        graph_rft=graph_rft[[obj_gauche.name, obj_commun.name, obj_droite.name]]

        graph_rft=graph_rft.reindex(self._create_tempo_df(obj_commun.dataset).index.union(self._create_tempo_df(obj_gauche.dataset).index.union(self._create_tempo_df(obj_droite.dataset).index)))

        colors = ["blue", "green" , "red"]
        barWidth = 0.85
        graph_rft.plot.bar(stacked=True, color=colors, figsize=(17,7),width=barWidth)
        plt.show()

    def comparaison_plot_density(self, autreDateFab_NumTombee_Dataset):
        '''affiche le nombre d'observations par semaine
        3 informations :
        - en bleu : les données uniquement dans self
        - en vert: les données (index) communes aux 2 datasets
        - en rouge : les données uniquement dans autreDateFab_NumTombee_Dataset
        '''
        obj_commun, obj_gauche, obj_droite = self.comparaison(autreDateFab_NumTombee_Dataset)

        for dataset in [obj_commun.dataset, obj_gauche.dataset, obj_droite.dataset]:
            # add columns for week and year of the date
            if (dataset.empty):
                dataset['date_week'] = dataset['Date_Fab']
                dataset['date_year'] = dataset['Date_Fab']
            else:
                dataset['date_week'] = dataset['Date_Fab'].apply(lambda x: x.isocalendar()[1])
                dataset['date_year'] = dataset['Date_Fab'].apply(lambda x: x.isocalendar()[0])

        groupage_commun = obj_commun.dataset.groupby([obj_commun.dataset['date_year'],obj_commun.dataset['date_week']])['Num_Tombee'].count()
        groupage_gauche = obj_gauche.dataset.groupby([obj_gauche.dataset['date_year'],obj_gauche.dataset['date_week']])['Num_Tombee'].count()
        groupage_droite = obj_droite.dataset.groupby([obj_droite.dataset['date_year'],obj_droite.dataset['date_week']])['Num_Tombee'].count()


        graph_rft = pd.concat([groupage_gauche, groupage_commun, groupage_droite], axis=1)
        graph_rft.columns=[obj_gauche.name, obj_commun.name, obj_droite.name]
        graph_rft=graph_rft[[obj_gauche.name, obj_commun.name, obj_droite.name]]

        graph_rft=graph_rft.reindex(self._create_tempo_df(obj_commun.dataset).index.union(self._create_tempo_df(obj_gauche.dataset).index.union(self._create_tempo_df(obj_droite.dataset).index)))

        colors = ["blue", "green" , "red"]
        barWidth = 0.85
    #     graph_rft.plot.bar(stacked=True, color=colors, figsize=(17,7),width=barWidth)
    #     plt.show()
        graph_rft=graph_rft.reset_index(level=[0,1])
        graph_rft['index']=graph_rft['date_year'].apply(str)+'-'+graph_rft['date_week'].apply(str)
        graph_rft.fillna(0, inplace=True)

        graph_rft['total']=graph_rft[graph_rft.columns[2]]+graph_rft[graph_rft.columns[3]]+graph_rft[graph_rft.columns[4]]
    #     graph_rft['index']=graph_rft['index'].astype('int64')
        graph_rft.set_index(['index'], inplace=True)

        graph_rft.drop(['date_year', 'date_week'], axis=1, inplace=True)
    #     return graph_rft

    #     return graph_rft

    #     colors = ["green" , "red"]
        barWidth = 0.7
    #         graph_rft.plot.bar(stacked=True, color=colors, figsize=(17,7),width=barWidth)
    #         plt.show()

        graph_rft.columns=['gauche', 'commun', 'droite', 'total']

        output_notebook()
        TOOLS = "xpan,xwheel_zoom,crosshair, reset,save"

        p = figure(x_range=list(graph_rft.index), title="Density plot "+self.name+" vs "+autreDateFab_NumTombee_Dataset.name,
                   tools=TOOLS, active_scroll='xwheel_zoom', plot_width=900, plot_height=500)
        v = p.vbar_stack(['gauche', 'commun', 'droite'], x='index', width=barWidth, color=colors,
                     source=graph_rft, line_color=None)



        tooltips = [
            ("Total ", "@total"),
            (obj_gauche.name, "@gauche"),
            (obj_commun.name, "@commun"),
            (obj_droite.name, "@droite"),
            ('# de semaine ', "@index")
        ]

        hover = HoverTool(tooltips=tooltips)
        p.add_tools(hover)
    #     item1 = LegendItem({'label':'Unique', 'renderers':[p.renderers[0]]});
    #     item2 = LegendItem({'label':'Doublons', 'renderers':[p.renderers[1]]});
    #     legend = Legend(items=[item1, item2])
    #     p.add_layout(legend)

        legend=Legend(items=[
            (obj_gauche.name,   [v[0]]),
            (obj_commun.name,   [v[1]]),
            (obj_droite.name,   [v[2]])
        ], location=(0, -30))
        p.add_layout(legend)

        p.legend.orientation = "horizontal"
        p.legend.location = "top_center"
        p.legend.click_policy="hide"

        p.xaxis.major_label_orientation = 3*pi/8
        p.xaxis.axis_label_text_font_size = "5pt"
        p.xaxis.major_label_text_font_size = "5pt"
        p.xaxis.axis_label_text_font = "times"
        p.xaxis.axis_label_text_color = "black"

        show(p)

    def plot(self, date_debut=None, date_fin=None):
        '''affichage interactif des num_tombee en fonction de la date de fab
        en precisant date_debut et date_fin, on vient resserrer la fenetre de visualisation
        les dates peuvent être à structure variable: '2021' (année), '2021-01' (mois), '2021-05-23' (jour)
        '''
        dataset_copy = self.dataset.copy()
        if (date_debut==None):
            date_debut=dataset_copy.Date_Fab.min()
        if (date_fin==None):
            date_fin=dataset_copy.Date_Fab.max()

        output_notebook()
        source_donnees = ColumnDataSource(dataset_copy[(dataset_copy.Date_Fab >= pd.to_datetime(date_debut))
                                                     & (dataset_copy.Date_Fab <= pd.to_datetime(date_fin))])
        TOOLS = "xpan,xwheel_zoom,box_zoom,crosshair, reset,save"
        p = figure(x_axis_type='datetime', active_scroll='xwheel_zoom', tools=TOOLS,plot_width=900, plot_height=500)

        p.line(x='Date_Fab', y='Num_Tombee', source=source_donnees)

        p.circle(x='Date_Fab', y='Num_Tombee', size=3, line_color="green",
                 fill_color="white", line_width=1, source=source_donnees, legend_label=self.name)

        hover = HoverTool(tooltips=[('Date tombée','@Date_Fab{%Y-%m-%d %H:%M:%S}'),
                                ('Num tombée', '@Num_Tombee')],
                      formatters={'@Date_Fab':'datetime'})
        p.add_tools(hover)
        p.title.text = "Num_tombee en fonction de la date"
        show(p)

    def comparaison_plot(self, autreDateFab_NumTombee_Dataset, date_debut=None, date_fin=None):
        '''affichage interactif des num_tombee en fonction de la date de fab
        pour les 3 datasets retournés par comparaison
        '''
        dataset_copy = self.dataset.copy()
        if (date_debut==None):
            date_debut=dataset_copy.Date_Fab.min()
        if (date_fin==None):
            date_fin=dataset_copy.Date_Fab.max()

        dataset_commun_obj, dataset_difference_gauche_obj, dataset_difference_droite_obj = self.extraire_periode(date_debut, date_fin).comparaison(autreDateFab_NumTombee_Dataset.extraire_periode(date_debut, date_fin))

        output_notebook()
        source_donnees_commun = ColumnDataSource(dataset_commun_obj.dataset)
        source_donnees_droite = ColumnDataSource(dataset_difference_droite_obj.dataset)
        source_donnees_gauche = ColumnDataSource(dataset_difference_gauche_obj.dataset)

        TOOLS = "xpan,xwheel_zoom,box_zoom,crosshair, reset,save"
        p = figure(x_axis_type='datetime', active_scroll='xwheel_zoom', tools=TOOLS,plot_width=900, plot_height=500)

#         p.line(x='Date_Fab', y='Num_Tombee', source=source_donnees)

        p.circle(x='Date_Fab', y='Num_Tombee', size=3, line_color="green",
                 fill_color="white", line_width=1, source=source_donnees_commun, legend_label=dataset_commun_obj.name)
        p.circle(x='Date_Fab', y='Num_Tombee', size=3, line_color="red",
                 fill_color="white", line_width=1, source=source_donnees_droite, legend_label=dataset_difference_droite_obj.name)
        p.circle(x='Date_Fab', y='Num_Tombee', size=3, line_color="blue",
                 fill_color="white", line_width=1, source=source_donnees_gauche, legend_label=dataset_difference_gauche_obj.name)

        hover = HoverTool(tooltips=[('Date tombée','@Date_Fab{%Y-%m-%d %H:%M:%S}'),
                                ('Num tombée', '@Num_Tombee')],
                      formatters={'@Date_Fab':'datetime'})
        p.add_tools(hover)
        p.title.text = "Num_tombee en fonction de la date"
        p.legend.click_policy="hide"
        show(p)



class STAM(DateFab_NumTombee_Dataset):
    '''
    Hérite de DateFab_NumTombee_Dataset
    (Pour stocker les datasets contenant les clés Date_Fab et Num_Tombee)
    Date_Fab_complet est horodatée et permet de faire des passages entre date calendaire et date michelin
    Date_Fab_complet est créé à l'initialisation
    Date_Fab n'est pas horodaté
    '''
    def __init__(self, dataset, name, description='', date_calendaire = False):
        '''
        les attributs:
        - dataset : une copie du dataframe
        - name : le nom (abrégé) du dataframe
        - description : une description en quelques mots
        - date_calendaire : False si les dates sont stockées en date Michelin, True si stockées en date Calendaire
        '''
        super().__init__(dataset, name, description)
        self._create_dtdate_fom_datecomplet()
        self.date_calendaire= date_calendaire

    def get_info(self):
        '''get_info de DateFab_NumTombee_Dataset complété avec l'info de date_calendaire'''
        return super().get_info()+' '+f'Date calendaire: [{self.date_calendaire}]\n'

    def _create_dtdate_fom_datecomplet(self):
        '''
        fonction technique (pas appelable directement)
        si la colonne Date_Fab_complet existe déjà, on est dans le cas d'un dataset CLEAN
        donc on ne fait rien
        '''
        if not ('Date_Fab_complet' in self.dataset.columns):
            self.dataset['Date_Fab_complet']=self.dataset['Date_Fab']
            self.dataset['Date_Fab']=self.dataset['Date_Fab_complet'].dt.date
            self.dataset['Date_Fab']=self.dataset['Date_Fab'].astype('datetime64')

    def passage_date_Calendaire(self, heureEquipeA = 6):
        '''
        passe en heure calendaire depuis une heure Michelin
        seulement si date_calendaire == False

        pour info: la journée Michelin est incrémentée non pas à minuit mais en debut d'équipe A
        Dates Michelin:
        2021-01-23 23:00,  2021-01-23 02:00,  2021-01-23 05:59,  2021-01-24 06:05,
        devient
        Dates calendaire:
        2021-01-23 23:00,  2021-01-24 02:00,  2021-01-24 05:59,  2021-01-24 06:05,
        '''
        if (self.date_calendaire):
            print(self.get_info()+ 'déjà en date Calendaire\n')
        else:
            self.dataset['Date_Fab_complet']=self.dataset['Date_Fab_complet'].apply(lambda row:self._ajoute_un_jour(row, heureEquipeA))
            self.dataset['Date_Fab_complet']=self.dataset['Date_Fab_complet'].astype('datetime64')
            self.date_calendaire = True
            self.dataset.sort_values('Date_Fab_complet', inplace=True)
            self.dataset['Date_Fab']=self.dataset['Date_Fab_complet'].dt.date
            self.dataset['Date_Fab']=self.dataset['Date_Fab'].astype('datetime64')

    def passage_date_Michelin(self, heureEquipeA = 6):
        '''
        passe en heure Michelin depuis une heure calendaire
        seulement si date_calendaire == True

        pour info: la journée Michelin est incrémentée non pas à minuit mais en debut d'équipe A
        Dates calendaire:
        2021-01-23 23:00,  2021-01-24 02:00,  2021-01-24 05:59,  2021-01-24 06:05,
        devient
        Dates Michelin:
        2021-01-23 23:00,  2021-01-23 02:00,  2021-01-23 05:59,  2021-01-24 06:05,
        '''
        if (not self.date_calendaire):
            print(self.get_info()+ 'déjà en date Michelin\n')
        else:
            self.dataset['Date_Fab_complet']=self.dataset['Date_Fab_complet'].apply(lambda row:self._retire_un_jour(row, heureEquipeA))
            self.dataset['Date_Fab_complet']=self.dataset['Date_Fab_complet'].astype('datetime64')
            self.date_calendaire = False
            self.dataset.sort_values('Date_Fab_complet', inplace=True)
            self.dataset['Date_Fab']=self.dataset['Date_Fab_complet'].dt.date
            self.dataset['Date_Fab']=self.dataset['Date_Fab'].astype('datetime64')


    def _ajoute_un_jour(self, date, heureEquipeA):
        '''
        fonction technique (pas appelable directement)
        '''
        heure = date.hour
        if (heure < heureEquipeA):
            return date+np.timedelta64(24, 'h')
        return date

    def _retire_un_jour(self, date, heureEquipeA):
        '''
        fonction technique (pas appelable directement)
        '''
        heure = date.hour
        if (heure < heureEquipeA):
            return date-np.timedelta64(24, 'h')
        return date

    def supprime_doublons(self):
        '''si 2 lignes ont la meme Date_Fab_complet+Num_Tombee,
        on ne garde que la dernière mesure (devrait correspondre à CE)
        (en rediscuter avec Fred)
        '''
        self.dataset.sort_values(['Date_Mes'], inplace=True)
        self.dataset.drop_duplicates(subset=['Date_Fab_complet', 'Num_Tombee'], keep='last', inplace=True)
        self.name = self.name+' sans doublon'
        self.description = self.description + '\n sans doublon'
        self.dataset.sort_values(['Date_Fab_complet'], inplace=True)

    def extraire_periode(self, date_debut, date_fin):
        '''
        retourne un objet STAM
        en ne gardant le contenu du dataset obéissant à date_debut<= Date_Fab <= date_fin

        les dates peuvent être à structure variable: '2021' (année), '2021-01' (mois), '2021-05-23' (jour)
        '''
        sous_dataset=self.dataset.copy()[(self.dataset.Date_Fab >= pd.to_datetime(date_debut))
                                                     & (self.dataset.Date_Fab <= pd.to_datetime(date_fin))]
        nouveauSTAM = STAM(sous_dataset, self.name, self.description+f' filtré entre {date_debut} et {date_fin}.', date_calendaire=self.date_calendaire)
        return nouveauSTAM


    def plot(self, date_debut=None, date_fin=None):
        '''affichage interactif des num_tombee en fonction de la date de fab complet
        en precisant date_debut et date_fin, on vient resserrer la fenetre de visualisation
        les dates peuvent être à structure variable: '2021' (année), '2021-01' (mois), '2021-05-23' (jour)

        il y a 2 courbes, en vert les tests nonCE, en rouge les tests CE
        si on clique dans la legende on peut venir n'afficher que la courbe de son choix
        '''
        mergeStam_copy = self.dataset.copy()
        if (date_debut==None):
            date_debut=mergeStam_copy.Date_Fab_complet.min()
        if (date_fin==None):
            date_fin=mergeStam_copy.Date_Fab_complet.max()

        # quand mergeStam_copy['CE'] est de type object, on est sur un STAM merge (avec des entrées 'CE' et nan)
        # quand mergeStam_copy['CE'] est de type int64, on est sur un STAM clean (avec des entrées 1 et 0)
        # on passe tout dans le style clean

        if (mergeStam_copy['CE'].dtypes == 'object'):
            mergeStam_copy['CE'] = mergeStam_copy['CE'].str.strip()
            mergeStam_copy['CE'].fillna(0,inplace=True)
            mergeStam_copy['CE'].replace('CE', 1, inplace=True)
            mergeStam_copy['CE'] = mergeStam_copy['CE'].astype('int64')

        output_notebook()
        source_stam = ColumnDataSource(mergeStam_copy[(mergeStam_copy.Date_Fab_complet >= pd.to_datetime(date_debut))
                                                     & (mergeStam_copy.Date_Fab_complet <= pd.to_datetime(date_fin))])
        source_stam_CE = ColumnDataSource(mergeStam_copy[(mergeStam_copy.Date_Fab_complet >= pd.to_datetime(date_debut))
                                                     & (mergeStam_copy.Date_Fab_complet <= pd.to_datetime(date_fin))
                                                     & (mergeStam_copy.CE == 1)   ])
        source_stam_noCE = ColumnDataSource(mergeStam_copy[(mergeStam_copy.Date_Fab_complet >= pd.to_datetime(date_debut))
                                                     & (mergeStam_copy.Date_Fab_complet <= pd.to_datetime(date_fin))
                                                     & (mergeStam_copy.CE == 0)   ])


        TOOLS = "xpan,xwheel_zoom,box_zoom,crosshair, reset,save"
        p = figure(x_axis_type='datetime', active_scroll='xwheel_zoom', tools=TOOLS,plot_width=900, plot_height=500)

        p.line(x='Date_Fab_complet', y='Num_Tombee', source=source_stam)

        noce = p.circle(x='Date_Fab_complet', y='Num_Tombee', size=3, line_color="green",
                 fill_color="white", line_width=1, source=source_stam_noCE, legend_label='pas de CE')
        ce = p.circle(x='Date_Fab_complet', y='Num_Tombee', size=3, line_color="red",
                 fill_color="white", line_width=1, source=source_stam_CE, legend_label='avec CE')

        #le mode vline c'est la barre verticale qui appelle la liste des points à cette date
        #le mode mouse est plus ciblé et plus performant
        hover = HoverTool(renderers=[ce, noce],tooltips=[('Date tombée','@Date_Fab_complet{%Y-%m-%d %H:%M:%S}'),
                                                         ('Date mesure','@Date_Mes{%Y-%m-%d %H:%M:%S}'),
                                                         ('Num tombée', '@Num_Tombee'), ('CE', '@CE')],
                      formatters={'@Date_Fab_complet':'datetime', '@Date_Mes':'datetime'}, mode='mouse')
        p.add_tools(hover)
        p.title.text = "Num_tombee en fonction de la date"
        p.legend.location = "top_left"
        p.legend.click_policy="hide"
        show(p)


import datetime
import time

def printDateRangeFromWeek(p_year,p_week):
    '''à partir d'une année et du numero de semaine (ex: 2019, 2)
    affiche les dates du lundi au dimanche.

    Examples
    --------
    >>> printDateRangeFromWeek(2019, 2)
    (2019-2) du 2019-01-07 au 2019-01-13
    (datetime.date(2019, 1, 7), datetime.date(2019, 1, 13))

    Returns
    -------
    tuple de string au format %Y-%m-%d
        les 2 dates entourant cette semaine
    '''

#     firstdayofweek = datetime.datetime.strptime(f'{p_year}-W{int(p_week )- 1}-1', "%Y-W%W-%w").date()
    firstdayofweek = datetime.date.fromisocalendar(p_year, p_week, 1)
    lastdayofweek = firstdayofweek + datetime.timedelta(days=6.9)
    print(f' ({p_year}-{p_week}) du {firstdayofweek} au {lastdayofweek}')
    return firstdayofweek.strftime("%Y-%m-%d"), lastdayofweek.strftime("%Y-%m-%d")