Make Plots

dashboard.make_plots

Functions

make_plots(env, date)

Crée et sauvegarde des graphiques représentant l'évolution des capacités en lits hospitaliers.

Cette fonction utilise une instance de DateTimeManager pour gérer les dates, charge et traite plusieurs jeux de données, avant de générer des barplots et carte
pour différentes catégories de lits (réanimation et surveillance continue) à la fois au niveau régional et national.

Parameters:
  • env (str) –

    L'environnement de connexion à la base de données pour l'extraction des données.

  • date (str) –

    La date à partir de laquelle les données doivent être analysées, au format 'YYYY-MM-DD'.

Returns:
  • None( None ) –

    La fonction ne retourne pas de valeur mais crée et enregistre des fichiers d'image correspondant aux graphiques générés.

Raises:
  • FileNotFoundError –

    Si les fichiers CSV nécessaires ne sont pas trouvés.

  • EmptyDataError –

    Si les fichiers CSV sont vides ou introuvables.

  • Exception –

    Pour toute autre erreur susceptible de se produire lors du traitement.

Notes
  • Assurez-vous que les fichiers CSV requis sont présents et correctement formatés avant d'exécuter cette fonction.
  • Les graphiques seront sauvegardés dans le répertoire spécifié par pictures_dir avec des noms définis pour chaque type de graphique.

Exemple d'utilisation: make_plots(env:str, "2023-10-01")

Source code in dashboard/make_plots.py
def make_plots(env:str, date:str) -> None:
    """
    Crée et sauvegarde des graphiques représentant l'évolution des capacités en lits hospitaliers.

    Cette fonction utilise une instance de DateTimeManager pour gérer les dates, 
    charge et traite plusieurs jeux de données, avant de générer des barplots et carte  
    pour différentes catégories de lits (réanimation et surveillance continue) 
    à la fois au niveau régional et national.

    Args:
        env (str): L'environnement de connexion à la base de données pour l'extraction des données.
        date (str): La date à partir de laquelle les données doivent être analysées, 
                    au format 'YYYY-MM-DD'.

    Returns:
        None: La fonction ne retourne pas de valeur mais crée et enregistre des fichiers 
              d'image correspondant aux graphiques générés.

    Raises:
        FileNotFoundError: Si les fichiers CSV nécessaires ne sont pas trouvés.
        Pandas.errors.EmptyDataError: Si les fichiers CSV sont vides ou introuvables.
        Exception: Pour toute autre erreur susceptible de se produire lors du traitement.

    Notes:
        - Assurez-vous que les fichiers CSV requis sont présents et correctement formatés 
          avant d'exécuter cette fonction.
        - Les graphiques seront sauvegardés dans le répertoire spécifié par `pictures_dir` 
          avec des noms définis pour chaque type de graphique.

    Exemple d'utilisation:
        make_plots(env:str, "2023-10-01")
    """

    # Création d'une instance par défaut pour exposer les constantes
    _dt_manager = DateTimeManager(date)

    # Variables à exporter pour compatibilité avec vos anciens imports
    hour_exec          = _dt_manager.execution_hour
    today              = _dt_manager.today
    today_Ymd_long     = _dt_manager.today_Ymd_long


    #%% ----------------- création tables --------------------
    loca_finess = pd.read_csv(f'{csv_dir}/GEOLOCALISATION_FINESS_12022021.csv', sep = ';')
    loca_finess = loca_finess[["finess","latitude","longitude"]].drop_duplicates()
    loca_finess["finess"] = ['{0:0>9}'.format(i) for i in loca_finess["finess"]]
    loca_finess["latitude"] = loca_finess["latitude"].str.replace(",", ".").astype(float)
    loca_finess["longitude"] = loca_finess["longitude"].str.replace(",", ".").astype(float)

    logger.info("Table GEOLOCALISATION_FINESS chargée et nettoyée")

    day0 = (today - timedelta(days = 14)).strftime("%Y-%m-%d")
    day15 = today_Ymd_long
    df = req2table(f"SELECT * FROM table_union WHERE capacite_extract_datetime::date BETWEEN '{day0}' AND '{day15}' AND h_exec='{hour_exec}'",
                    env)
    df = df[df["sous_categorie_lit"] != "rea_brules"]
    df["date"] = pd.to_datetime(df["capacite_extract_datetime"].dt.date)
    df = df[~df["lit_capacite"].isnull()]
    df = df[(df["region"] != "IDF") | (df["lit_capacite"] != 100)]
    df["new_cate"] = np.repeat(np.nan, df.shape[0])
    df.loc[df["categorie_lit"] == "reanimation", "new_cate"] = "Réanimation"
    df.loc[df["categorie_lit"] == "surveillance_continue", "new_cate"] = "Surveillance continue"
    df.loc[df["sous_categorie_lit"] == "usin", "new_cate"] = "USINV"
    df.loc[df["sous_categorie_lit"] == "usic", "new_cate"] = "USIC"
    df.loc[df["sous_categorie_lit"] == "autres_usi", "new_cate"] = "Autres USI"

    logger.info("Table table_union chargée et nettoyée")

    recap_dep = pd.read_csv(f"{csv_dir}/recap_dep.csv", dtype = {"departement" : "str"})
    logger.info("Table recap_dep chargée")

    mp_dep = mapping_departement.reset_index(drop = True)
    recap_dep = recap_dep.merge(mp_dep, left_on = "departement", right_on = "code_departement", how = 'left')
    recap_dep = recap_dep.merge(pop_dep, how = 'left', left_on = "departement", right_on = "code_departement")
    recap_dep["capa_hab"] = 100000 * recap_dep["lit_capacite_tot"] / recap_dep["nb_habitants"]

    logger.info("Table recap_dep fusionnée avec mapping_departement et pop_dep")

    recap_region = pd.read_csv(f"{csv_dir}/recap_region.csv")
    logger.info("Table recap_region chargée")

    mp_dep = mapping_departement.reset_index(drop = True)

    #%% ------------------- Barplots region ----------------------
    fig1 = barplot_reg(recap_region, "Réanimation")
    fig1.write_image(f"{pictures_dir}/barplot_reg_rea.png", height = 300, width = 800, engine="kaleido")

    logger.info("Barplot pour la réanimation par région créé et sauvegardé")

    fig2 = barplot_reg(recap_region, "Surveillance continue")
    fig2.write_image(f"{pictures_dir}/barplot_reg_usc.png", height = 300, width = 800, engine="kaleido")

    logger.info("Barplot pour la surveillance continue par région créé et sauvegardé")

    #%% ---------------- Barplots evolution --------------
    fig3 = barplot_evolution(df, "Réanimation", "national")
    fig3.write_image(f"{pictures_dir}/barplot_evol_rea.png", height = 300, width = 800, engine="kaleido")

    logger.info("Barplot d'évolution pour la réanimation créé et sauvegardé")

    fig4 = barplot_evolution(df, "Surveillance continue", "national")
    fig4.write_image(f"{pictures_dir}/barplot_evol_usc.png", height = 300, width = 800, engine="kaleido")

    logger.info("Barplot d'évolution pour la surveillance continue créé et sauvegardé")


    # Warnings


    #%% -------------- Barplot regions ----------------------------
    for reg in list(mapping_regions):
        if reg == "IDF":
            height = 290
        else:
            height = 310
        # logger.info(df.columns)
        if reg != "MAY":
            try:

                fig1 = barplot_evolution(df, "Réanimation", reg)
                fig1.write_image(f"{pictures_dir}/barplot_evol_rea_{reg}.png", height = height, width = 760, engine="kaleido")
                logger.success(f"Barplot d'évolution réanimation {reg} crée")
                fig2 = barplot_evolution(df, "Surveillance continue", reg)
                fig2.write_image(f"{pictures_dir}/barplot_evol_usc_{reg}.png", height = height, width = 760, engine="kaleido")
                logger.success(f"Barplot d'évolution surveillance continue {reg} crée")
            except:
                logger.exception(f"Erreur barplot evolution réanimation {reg} ")
                pass


    #%% ------------ Map National --------------------------
    lats = []
    lons = []

    geo_df = gpd.read_file(f'{geojson_dir}/regions-version-simplifiee.geojson')


    for feature, name in zip(geo_df.geometry, geo_df.nom):
        ft = feature.boundary

        if isinstance(ft, shapely.geometry.linestring.LineString):
            linestrings = [ft]
        elif isinstance(ft, shapely.geometry.multilinestring.MultiLineString):
            linestrings = ft.geoms
        else:
            continue    

        for linestring in linestrings:
            x, y = linestring.xy
            lats = np.append(lats, y)
            lons = np.append(lons, x)
            lats = np.append(lats, None)
            lons = np.append(lons, None)

    lats2 = []
    lons2 = []

    geo_df = gpd.read_file(f'{geojson_dir}/metropole-version-simplifiee.geojson')

    for feature in geo_df.geometry:
        ft = feature.boundary

        if isinstance(ft, shapely.geometry.linestring.LineString):
            linestrings = [ft]
        elif isinstance(ft, shapely.geometry.multilinestring.MultiLineString):
            linestrings = ft.geoms
        else:
            continue    

        for linestring in linestrings:
            x, y = linestring.xy
            lats2 = np.append(lats2, y)
            lons2 = np.append(lons2, x)
            lats2 = np.append(lats2, None)
            lons2 = np.append(lons2, None)


    with open(f'{geojson_dir}/departements-version-simplifiee.geojson') as json_file:
        geojson = json.load(json_file)

    for i in range(0, len(geojson["features"])):
        geojson["features"][i]['id'] = geojson["features"][i]['properties']['code']

    try:
        fig = map_national(recap_dep, "Réanimation", geojson, lats, lons, lats2, lons2)
        fig.write_image(f"{pictures_dir}/map_rea.png", engine="kaleido", width = 450, height = 600)
        logger.success(f"Map réanimation nationale crée")
    except:
        logger.exception(f"Erreur lors de la creation de la carte nationale de Réanimation")

    try:
        fig = map_national(recap_dep, "Surveillance continue", geojson, lats, lons, lats2, lons2)
        fig.write_image(f"{pictures_dir}/map_usc.png", engine="kaleido", width = 450, height = 600)
    except:
        logger.exception(f"Erreur lors de la création de la carte nationale pour la la Survaillance continue")

    dic_dep = dict(GUA = 971, MAR = 972, GUY = 973, REU = 974, MAY = 976)

    for i in ["GUA", "MAR", "GUY", "REU", "MAY"]:
        fig = map_outre_mer(recap_dep, "Réanimation", i, dic_dep[i])
        fig.write_image(f"{pictures_dir}/map_rea_{i}.png", engine="kaleido")
        try :
            fig = map_outre_mer(recap_dep, "Surveillance continue", i, dic_dep[i])
            fig.write_image(f"{pictures_dir}/map_usc_{i}.png", engine="kaleido")
            logger.success(f"Carte generée pour la region {i}")
        except:
            logger.exception(f"Erreur lors de la cration de la carte pour {i}")
            pass
    #%% -------------- Map regions + barplots tension ----------------
    for i in list(mapping_regions):
        try:
            if ~np.isin(i, ['MAY', 'IDF']):
                today = df["capacite_extract_datetime"].max()
                today = datetime(today.year, today.month, today.day)
                df["date"] = pd.to_datetime(df["date"])
                tmp = df[(df["region"] == i) & (df["date"] == today)]

                tmp_rea = tmp[tmp["new_cate"] == "Réanimation"]
                tmp_usc = tmp[tmp["new_cate"] == "Surveillance continue"]

                if np.isin(i, ["GUY", "REU", "MAR"]):
                    tmp_rea_frais = tmp_rea[tmp_rea["dispo_maj_fraicheur"] <= 48]
                    tmp_usc_frais = tmp_usc[tmp_usc["dispo_maj_fraicheur"] <= 48]
                else:
                    tmp_rea_frais = tmp_rea[tmp_rea["dispo_maj_fraicheur"] <= 24]
                    tmp_usc_frais = tmp_usc[tmp_usc["dispo_maj_fraicheur"] <= 24]

                tmp_rea_frais = tmp_rea_frais[tmp_rea_frais['lit_capacite'] >= tmp_rea_frais['lit_dispo']]
                tmp_usc_frais = tmp_usc_frais[tmp_usc_frais['lit_capacite'] >= tmp_usc_frais['lit_dispo']]

                # rea
                recap_rea = tmp_rea.groupby(["finess", "etablissement"])["lit_capacite"]\
                    .sum().reset_index(name = 'lit_capacite_tot')
                recap_frais = tmp_rea_frais.groupby(["finess", "etablissement"], as_index = False)\
                    [["lit_capacite", 'lit_dispo']].sum()
                recap_rea = recap_rea.merge(recap_frais, how = 'left', on = ["finess", "etablissement"])
                fraicheur = (tmp_rea_frais.groupby(["finess", "etablissement"])["lit_capacite"].sum() \
                    / tmp_rea.groupby(["finess", "etablissement"])["lit_capacite"].sum())\
                    .reset_index(name = 'fraicheur')
                recap_rea = recap_rea.merge(fraicheur, how = 'left', on = ["finess", "etablissement"])
                recap_rea["taux_occ"] = ((recap_rea["lit_capacite"] - recap_rea["lit_dispo"])\
                                            / recap_rea["lit_capacite"]).round(2)
                recap_rea.loc[recap_rea["fraicheur"].isnull(), "fraicheur"] = 0
                recap_rea = recap_rea.merge(loca_finess, on = "finess", how = "left")

                fig = map_region(recap_dep, "Réanimation", i, loca_finess, recap_rea)
                fig.write_image(f"{pictures_dir}/map_rea_region_{i}.png", engine="kaleido", width = 550, height = 450)

                # usc
                recap_usc = tmp_usc.groupby(["finess", "etablissement"])["lit_capacite"]\
                    .sum().reset_index(name = 'lit_capacite_tot')
                recap_frais = tmp_usc_frais.groupby(["finess", "etablissement"], as_index = False)\
                    [["lit_capacite", 'lit_dispo']].sum()
                recap_usc = recap_usc.merge(recap_frais, how = 'left', on = ["finess", "etablissement"])
                fraicheur = (tmp_usc_frais.groupby(["finess", "etablissement"])["lit_capacite"].sum() \
                    / tmp_usc.groupby(["finess", "etablissement"])["lit_capacite"].sum())\
                    .reset_index(name = 'fraicheur')
                recap_usc = recap_usc.merge(fraicheur, how = 'left', on = ["finess", "etablissement"])
                recap_usc["taux_occ"] = ((recap_usc["lit_capacite"] - recap_usc["lit_dispo"])\
                                            / recap_usc["lit_capacite"]).round(2)
                recap_usc.loc[recap_usc["fraicheur"].isnull(), "fraicheur"] = 0
                recap_usc = recap_usc.merge(loca_finess, on = "finess", how = "left")

                fig = map_region(recap_dep, "Surveillance continue", i, loca_finess, recap_usc)
                fig.write_image(f"{pictures_dir}/map_usc_region_{i}.png", engine="kaleido", width = 550, height = 450)
                logger.success(f"Barplot et map creé pour la région {i}")
        except:
            logger.exception(f"Erreur de creation map et barplot {i}")   
            pass
    try:

        today = df["capacite_extract_datetime"].max()
        today = datetime(today.year, today.month, today.day)
        df["date"] = pd.to_datetime(df["date"])
        tmp = df[(df["region"] == 'IDF') & (df["date"] == today)]

        tmp_rea = tmp[tmp["new_cate"] == "Réanimation"]
        tmp_usc = tmp[tmp["new_cate"] == "Surveillance continue"]

        tmp_rea_frais = tmp_rea[tmp_rea["dispo_maj_fraicheur"] <= 24]
        tmp_usc_frais = tmp_usc[tmp_usc["dispo_maj_fraicheur"] <= 24]

        tmp_rea_frais = tmp_rea_frais[tmp_rea_frais['lit_capacite'] >= tmp_rea_frais['lit_dispo']]
        tmp_usc_frais = tmp_usc_frais[tmp_usc_frais['lit_capacite'] >= tmp_usc_frais['lit_dispo']]

        # rea
        recap_rea = tmp_rea.groupby(["finess", "etablissement", "departement"])["lit_capacite"]\
            .sum().reset_index(name = 'lit_capacite_tot')
        recap_frais = tmp_rea_frais.groupby(["finess", "etablissement", "departement"], as_index = False)\
            [["lit_capacite", 'lit_dispo']].sum()
        recap_rea = recap_rea.merge(recap_frais, how = 'left', on = ["finess", "etablissement", "departement"])
        fraicheur = (tmp_rea_frais.groupby(["finess", "etablissement", "departement"])["lit_capacite"].sum() \
            / tmp_rea.groupby(["finess", "etablissement", "departement"])["lit_capacite"].sum())\
            .reset_index(name = 'fraicheur')
        recap_rea = recap_rea.merge(fraicheur, how = 'left', on = ["finess", "etablissement", "departement"])
        recap_rea["taux_occ"] = ((recap_rea["lit_capacite"] - recap_rea["lit_dispo"])\
                                    / recap_rea["lit_capacite"]).round(2)
        recap_rea.loc[recap_rea["fraicheur"].isnull(), "fraicheur"] = 0
        recap_rea = recap_rea.merge(loca_finess, on = "finess", how = "left")

        fig1, fig2 = map_idf(recap_dep, recap_rea, 'Réanimation')
        fig1.write_image(f"{pictures_dir}/map_rea_region_IDF.png", engine="kaleido", width = 450, height = 650)
        fig2.write_image(f"{pictures_dir}/map_rea_region_IDF_pcr.png", engine="kaleido", width = 450, height = 650) 
        logger.success(f"Map reanimation des regions crée")
    except:
        logger.exception(f"Erreur lors de la creation de maps des régions")
    # usc
    try:

        recap_usc = tmp_usc.groupby(["finess", "etablissement", "departement"])["lit_capacite"]\
            .sum().reset_index(name = 'lit_capacite_tot')
        recap_frais = tmp_usc_frais.groupby(["finess", "etablissement", "departement"], as_index = False)\
            [["lit_capacite", 'lit_dispo']].sum()
        recap_usc = recap_usc.merge(recap_frais, how = 'left', on = ["finess", "etablissement", "departement"])
        fraicheur = (tmp_usc_frais.groupby(["finess", "etablissement", "departement"])["lit_capacite"].sum() \
            / tmp_usc.groupby(["finess", "etablissement", "departement"])["lit_capacite"].sum())\
            .reset_index(name = 'fraicheur')
        recap_usc = recap_usc.merge(fraicheur, how = 'left', on = ["finess", "etablissement", "departement"])
        recap_usc["taux_occ"] = ((recap_usc["lit_capacite"] - recap_usc["lit_dispo"])\
                                    / recap_usc["lit_capacite"]).round(2)
        recap_usc.loc[recap_usc["fraicheur"].isnull(), "fraicheur"] = 0
        recap_usc = recap_usc.merge(loca_finess, on = "finess", how = "left")

        fig1, fig2 = map_idf(recap_dep, recap_rea, 'Surveillance continue')
        fig1.write_image(f"{pictures_dir}/map_usc_region_IDF.png", engine="kaleido", width = 450, height = 650)
        fig2.write_image(f"{pictures_dir}/map_usc_region_IDF_pcr.png", engine="kaleido", width = 450, height = 650) 
        logger.success(f"carte des usc region IDF crée")
    except:
        logger.exception(f"Erreur lors de la création de la cate usc IDF")