Data Management

src.Process.Utils.Datamanagement

Functions

add_datetime_cols(df, col_date_extract, col_date_update='last_update')

Création des colonnes relatifs aux dates de mises à jour (last_update), fraicheur (dispo_maj_fraicheur) et date d'extraction (dispo_extract_datetime, capacite_extract_datetime)

Args : df (pd.DataFrame): DataFrame contenant la colonne de la date de dernière MAJ des données. col_date_extract (datetime): Nom de la colonne de la date du lancement du process col_date_update (str) : Nom de la colonne de la date de dernière MAJ des données. (par défaut "last_update").

Returns : df_result (DataFrame): DataFrame avec les colonnes dates ajoutées (dispo_extract_datetime, capacite_extract_datetime, dispo_maj_fraicheur)

Source code in src/Process/Utils/Datamanagement.py
def add_datetime_cols(df:pd.DataFrame, col_date_extract:str, col_date_update:str = "last_update")-> pd.DataFrame :
    """
    Création des colonnes relatifs aux dates de mises à jour (last_update), fraicheur (dispo_maj_fraicheur) et date d'extraction (dispo_extract_datetime, capacite_extract_datetime)

    Args :
    df (pd.DataFrame): DataFrame contenant la colonne de la date de dernière MAJ des données.
    col_date_extract (datetime): Nom de la colonne de la date du lancement du process
    col_date_update (str) : Nom de la colonne de la date de dernière MAJ des données. (par défaut "last_update").

    Returns :
    df_result (DataFrame): DataFrame avec les colonnes dates ajoutées (dispo_extract_datetime, capacite_extract_datetime, dispo_maj_fraicheur)
    """ 
    df_result = df.copy()
    df_result["dispo_extract_datetime"] = df_result[col_date_extract]
    df_result["dispo_maj_fraicheur"] = pd.to_datetime(df_result[col_date_extract],format="%Y-%m-%d %H:%M:%S") - pd.to_datetime(df_result[col_date_update],format="%Y-%m-%d %H:%M:%S")
    df_result["dispo_maj_fraicheur"] = df_result["dispo_maj_fraicheur"] / pd.Timedelta(1, "h")
    return df_result

age_max_anomalie(age_AO, age_anomalie, modeprisecharge=False)

Vérification de la cohérence de l'age de l'offre opérationnelle et des activités opérationnelles considérés comme pédia ou néonat.

Parameters:
  • age_AO (list) –

    Age maximum de l'offre opérationnelle.

  • age_anomalie (list) –

    Restriction d'age relatif aux anomalies.

  • modeprisecharge (bool, default: False ) –

    Option qui permet d'éviter la redondance des anomalies, si les anomalies relatives à une prise en charge (<>28) sont déjà existente.

Source code in src/Process/Utils/Datamanagement.py
def age_max_anomalie(age_AO: list, age_anomalie: list, modeprisecharge: bool = False)-> bool:
    """
    Vérification de la cohérence de l'age de l'offre opérationnelle et des activités opérationnelles considérés comme pédia ou néonat.

    Args:
        age_AO (list): Age maximum de l'offre opérationnelle.
        age_anomalie (list): Restriction d'age relatif aux anomalies.
        modeprisecharge (bool): Option qui permet d'éviter la redondance des anomalies, si les anomalies relatives à une prise en charge (<>28) sont déjà existente.
    """
    if modeprisecharge != True:
        if (age_AO > 18) and ("> 18 ans" in age_anomalie) :
            return True
    return False

anomalies(df)

Vérification de la présence d'anomalie pour chaque offre opérationnelle.

Parameters:
  • df (DataFrame) –

    Table de HealthcareService où l'on vérifie la présence d'anomalie

Return

df_result (pd.DataFrame): Table contenant les offres opérationnelles en anomalies (1 offre peut avoir plusieurs anomalies)

Source code in src/Process/Utils/Datamanagement.py
def anomalies(df:pd.DataFrame) -> pd.DataFrame:
    """
    Vérification de la présence d'anomalie pour chaque offre opérationnelle.

    Args:
        df (pd.DataFrame): Table de HealthcareService où l'on vérifie la présence d'anomalie

    Return:
        df_result (pd.DataFrame): Table contenant les offres opérationnelles en anomalies (1 offre peut avoir plusieurs anomalies)
    """
    # Importation du fichier de mapping des anomalies
    # current_dir = os.path.dirname(os.path.abspath(__file__))
    # current_dir = Path(current_dir)
    # api_mapping_file = current_dir.parent.absolute() / "Metadata" / "mapping_anomalies.csv"

    mapping_anomalies = load_mapping_file("mapping_anomalies.csv")
    columns_to_convert = ["Code", "Mode_prise_en_charge", "AO_incompatibles", "Exclusion_AO"]
    for col in columns_to_convert:
        mapping_anomalies[col] = mapping_anomalies[col].map(convert_to_list)

    # Produit cartésien entre les offres opérationnelles et les anomalies potentielles
    df_result = pd.merge(df, mapping_anomalies, how = 'cross')

    # Création de colonnes de check des anomalies
    anomalie_checks = {
        "has_anomalie_code": lambda row: contains_anomalie_code(row["activiteOperationnelle"], row["Code"], modeprisecharge=False),
        "has_diff_care_mode": lambda row: care_mode_anomalie(row["ModePriseEnCharge"], row["Mode_prise_en_charge"]),
        "has_anomalie_incomp": lambda row: contains_anomalie_code(row["activiteOperationnelle"], row["AO_incompatibles"], modeprisecharge=row["has_diff_care_mode"]),
        "has_anomalie_exclusion": lambda row: contains_anomalie_code(row["activiteOperationnelle"], row["Exclusion_AO"], modeprisecharge=row["has_diff_care_mode"]),
        "has_age_max_restrict": lambda row: age_max_anomalie(row["age_max"], row["Age_Max"], row["has_diff_care_mode"]),
        "has_diff_care_mode_final": lambda row: care_mode_anomalie(row["ModePriseEnCharge"], row["Mode_prise_en_charge"], modeprisecharge_anomalie=True)
    }
    df_result["has_diff_care_mode"] = ""
    for col, func in anomalie_checks.items():
        df_result[col] = df_result.apply(func, axis=1)

    # Critère d'exclusion des anomalies
    mask = (
            (df_result["has_anomalie_code"] == True) & 
            ((df_result["has_diff_care_mode_final"] == True) | 
            (df_result["has_age_max_restrict"] == True) | 
            ((df_result["has_anomalie_incomp"] == True) & (df_result["has_anomalie_exclusion"] == False)))
            )

    df_result = df_result.loc[mask, ["HCS_id", "nomOffre", "activiteOperationnelle", "ModePriseEnCharge", "age_max", "Nom_Anomalie", "Critere_Anomalie"]] 
    df_result.reset_index(drop = True, inplace = True)

    return df_result

calcul_bed_capacity(df)

Fonction de de calcul des capacités des lits pour chaque Location, selon les règles de calculs.

  1. Formatage de la date (capacityUpdateDate)
  2. Filtrage nécessaire sur les colonnes
  3. Création d'un ID de groupement comportant : location + status + temporaire + genre. L'ID n'est pas unique, il permet de réaliser des aggrégations en fonction des différents critères.
  4. Source : pour plusieurs saisies différentes d'une ligne on garde la donnée la plus récente
  5. Fermeture (capacityClosingType) : pour des types de fermeture distincts, on les agrège ensemble
  6. Genre : pour des genres distincts, on les agrège ensemble
  7. Statut : calcul des lits installés et disponibles en fonction des statuts (installé = 01 - 05 + 06, disponible = 02)
Parameters:
  • df (DataFrame) –

    DataFrame contenant les données de Location nettoyées

Returns:
  • df_result( DataFrame ) –

    DataFrame les capacités des lits aggregées par Location et par statut. Normalement, 1 ligne par Location et par TemporaryAssignement.

Source code in src/Process/Utils/Datamanagement.py
def calcul_bed_capacity(df: pd.DataFrame) -> pd.DataFrame:
    """
    Fonction de de calcul des capacités des lits pour chaque Location, selon les règles de calculs.

    1. Formatage de la date (capacityUpdateDate)
    2. Filtrage nécessaire sur les colonnes
    3. Création d'un ID de groupement comportant : location + status + temporaire + genre. L'ID n'est pas unique, il permet de réaliser des aggrégations en fonction des différents critères. 
    4. Source : pour plusieurs saisies différentes d'une ligne on garde la donnée la plus récente
    5. Fermeture (capacityClosingType) : pour des types de fermeture distincts, on les agrège ensemble 
    6. Genre : pour des genres distincts, on les agrège ensemble 
    7. Statut : calcul des lits installés et disponibles en fonction des statuts (installé = 01 - 05 + 06, disponible = 02)


    Args:
        df (DataFrame): DataFrame contenant les données de Location nettoyées

    Returns:
        df_result (DataFrame): DataFrame les capacités des lits aggregées par Location et par statut. Normalement, 1 ligne par Location et par TemporaryAssignement.
    """
    df_result = df.copy()


    # 1. Formatage de la date
    df_result["capacityUpdateDate"] = df_result["capacityUpdateDate"].dt.strftime('%Y-%m-%d')

    # 2. Filtrage : capacityType == 01  + capacityStatus == ['01' ou '02' ou '05' ou '06'] + crisisType == nan + temporalityCapacity == 01 + additionalBedType == ['01' ou nan]
    capacity_bed_filter = get_columns(table="Location", col_list="location_capacity_bed_filter")
    df_result = df_result.loc[(df_result["capacityType"].isin(capacity_bed_filter["capacityType"])) &  
                                (df_result["capacityStatus"].isin(capacity_bed_filter["capacityStatus"])) & 
                                (df_result["crisisType"].isna()) &
                                (df_result["temporalityCapacity"].isin(capacity_bed_filter["temporalityCapacity"])) &
                                (~df_result["additionalBedType"].isin(capacity_bed_filter["additionalBedType"]))]

    # 3. Création de l'ID de groupement
    df_result["groupe"] = (df_result["location"] + df_result["capacityStatus"] + df_result["temporaryAssignement"] + df_result["genderCapacityAvailable"].fillna("00")) + df_result["additionalBedType"].fillna("00") + df_result["capacityClosingType"].fillna("00")

    # 4. Gestion des sources (01 : Saisie manuelle, 02 : Bed management (automatique), 03 : GAM, 04 : DPI): 
    # Pour plusieurs saisies communes d'une ligne on garde la donnée la plus récente 
    df_result = sort_drop_group(df_result)

    # Elimination des lignes avec des dates antérieurs si, pour une location) :
    # - status = 02 et plus anciennes que les autres status 02
    # - status = 05 et plus anciennes que celle à status 01 
    # - status = 05 et plus anciennes qu'une autre 05 (si plus récente que status 01)
    date_max_by_status = df_result.groupby(['location', 'temporaryAssignement', 'capacityStatus'])['capacityUpdateDate'].max().unstack()
    df_result = df_result.merge(date_max_by_status, on=['location', 'temporaryAssignement'], how='left')

    df_result = df_result.drop(df_result[
        (df_result["capacityStatus"] == "05") & 
        ((df_result["capacityUpdateDate"] < df_result["01"]) |
        (df_result["capacityUpdateDate"] < df_result["05"]))].index)

    df_result = df_result.drop(df_result[
        (df_result["capacityStatus"] == "02") & 
        (df_result["capacityUpdateDate"] < df_result["02"])].index)

    df_result = df_result.drop(columns = date_max_by_status.columns)

    # 5. Agrégation des types de fermeture 
    # On agrège les genres ensembles (01 : Réactivable, 02 : Non réactivable, 03 : Indéterminé)
    df_result["groupe"] = df_result["groupe"].str[:-2]
    df_result = groupby_merge_group(df_result, ["groupe"], ["nbCapacity"])
    df_result = sort_drop_group(df_result)

    # 6. Agrégation des genres (fusion des genres par groupe) 
    # On aggrège les genres ensembles (01 : Femme, 02 : Homme, 03 : Indifférencié, 04 : Indéterminé, 05 : NaN)
    df_result["groupe"] = df_result["groupe"].str[:-4]
    df_result = groupby_merge_group(df_result, ["groupe"], ["nbCapacity"])
    df_result = sort_drop_group(df_result)

    # 7. Calculs des capacités de lits via les statuts 
    # Soustraction des lits fermés (05) et addition des lits supplémentaires à la capacité installée (01 : Installé, 02 : Disponible, 05 : Fermé, 06 : Supplémentaire)
    df_status = df_result.loc[:, ['location', 'capacityStatus', 'temporaryAssignement', 'nbCapacity']] # On garde que les champs à garder
    df_status = df_status.pivot(index = ['location', 'temporaryAssignement'], columns = 'capacityStatus', values = 'nbCapacity') # Pivoter les champs

    # Si des status n'existent pas
    for col in capacity_bed_filter["capacityStatus"]:
        if col not in df_status.columns:
            df_status[col] = 0

    df_status["lit_capacite"] = df_status["01"].astype(float).fillna(0) - df_status["05"].astype(float).fillna(0) + df_status["06"].astype(float).fillna(0) # Calcul des capacités lits
    df_status["lit_dispo"] = df_status["02"].astype(float).fillna(0)

    df_result = df_result[['location', 'temporaryAssignement', 'last_update', 'name_location', 'postal_code', 'location_id_key']].drop_duplicates()
    df_result = df_result.merge(df_status[["lit_capacite", "lit_dispo"]], on = ['location', 'temporaryAssignement'], how = 'right')

    return df_result

care_mode_anomalie(modeprisecharge, mode_anomalie, modeprisecharge_anomalie=False)

Vérification du mode de prise en charge supposé à '28'.

Parameters:
  • modeprisecharge (list) –

    Mode_prise_en_charge de l'offre opérationnelle.

  • mode_anomalie (list) –

    Restriction du mode de prise en charge relatif aux anomalies.

  • modeprisecharge_anomalie (bool, default: False ) –

    option qui permet d'éviter la redondance des anomalies relative à la prise en charge (<>28) et les autres.

Source code in src/Process/Utils/Datamanagement.py
def care_mode_anomalie(modeprisecharge: list, mode_anomalie: list, modeprisecharge_anomalie: bool = False)-> bool:
    """
    Vérification du mode de prise en charge supposé à '28'.

    Args:
        modeprisecharge (list): Mode_prise_en_charge de l'offre opérationnelle.
        mode_anomalie (list): Restriction du mode de prise en charge relatif aux anomalies.
        modeprisecharge_anomalie (bool): option qui permet d'éviter la redondance des anomalies relative à la prise en charge (<>28) et les autres.
    """
    if modeprisecharge_anomalie:
        if (modeprisecharge != '28') & ("autre" in mode_anomalie):
            return True
    else:
        if modeprisecharge != '28':
            return True
    return False

contains_anomalie_code(activites, anomalies, modeprisecharge=False)

Vérification de la présence d'activités opérationnelles parmis les codes relatifs aux anomalies.

Parameters:
  • activites (list) –

    Activités opérationnelles dont on cherche la présence.

  • anomalies (list) –

    Codes des activités opérationnelles relatifs à une anomalie.

  • modeprisecharge (bool, default: False ) –

    Option qui permet d'éviter la redondance des anomalies, si les anomalies relatives à une prise en charge (<>28) sont déjà existente.

Source code in src/Process/Utils/Datamanagement.py
def contains_anomalie_code(activites: list, anomalies: list, modeprisecharge: bool = False)-> bool:
    """
    Vérification de la présence d'activités opérationnelles parmis les codes relatifs aux anomalies.

    Args:
        activites (list): Activités opérationnelles dont on cherche la présence.
        anomalies (list): Codes des activités opérationnelles relatifs à une anomalie.
        modeprisecharge (bool): Option qui permet d'éviter la redondance des anomalies, si les anomalies relatives à une prise en charge (<>28) sont déjà existente.
    """
    if modeprisecharge != True:
        return any(i in anomalies for i in activites)
    else:
        return False

conversion_list(df)

Convertisseur de dataframe dont les colonnes contiennent des listes / dictionnaires (pour les fichiers JSON). Pour l'ensemble des colonnes contenant une liste, le dataframe sera déstructuré autant de fois que nécessaire pour obtenir les valeurs atomiques (1 seul valeur par observation). Les clés des dictionnaires deviennent de nouvelles colonnes.

Parameters:
  • df (DataFrame) –

    JSON à destructurer (pas nécessairement l'ensemble du JSON)

Returns:
  • df( DataFrame ) –

    Dataframe déstructuré avec des observations atomiques

Source code in src/Process/Utils/Datamanagement.py
def conversion_list(df: pd.DataFrame) -> pd.DataFrame:
    """
    Convertisseur de dataframe dont les colonnes contiennent des listes / dictionnaires (pour les fichiers JSON).
    Pour l'ensemble des colonnes contenant une liste, le dataframe sera déstructuré autant de fois que nécessaire pour obtenir les valeurs atomiques (1 seul valeur par observation).
    Les clés des dictionnaires deviennent de nouvelles colonnes.

    Args:
        df (DataFrame): JSON à destructurer (pas nécessairement l'ensemble du JSON)

    Returns:
        df: Dataframe déstructuré avec des observations atomiques
    """ 
    # Tant qu'il y a des colonnes avec des listes, le traitement continue
    while any(df[col].apply(lambda x: isinstance(x, list) or pd.isna(x)).all() for col in df.columns):
        for var in df.columns:

            # Si la colonne contient une liste, alors traitement
            if df[var].apply(lambda x: isinstance(x, list) or pd.isna(x)).all() :

                # Gestion des colonnes de listes (soit liste, soit NA)
                if df.loc[~ pd.isna(df[var]), var].apply(lambda x: isinstance(x[0], dict)).all() : # Liste de dictionnaires
                    df = exploded_var(df, var)

                else : # Liste de valeurs (seulement pour la col resource.address.line)
                    df[var] = df[var].apply(lambda x : ', '.join(map(str, x)) if isinstance(x, list) else x)
    return df

count_dub(df, col)

Créer une variable qui compte le nombre de doublons via un groupe by et ajouter cette colonne au dataframe

Parameters:
  • df (pd.DataFrame) ) –

    Dataframe sur lequel créer la colonne de comptage est créée

  • col (list) ) –

    Liste des colonnes sur lesquels faire l'agrégation

Return

pd.DataFrame: df avec la colonne size en supplément

Source code in src/Process/Utils/Datamanagement.py
def count_dub(df: pd.DataFrame, col: list)->pd.DataFrame:
    """
    Créer une variable qui compte le nombre de doublons via un groupe by et ajouter cette colonne au dataframe

    Args:
        df (pd.DataFrame) : Dataframe sur lequel créer la colonne de comptage est créée
        col (list) : Liste des colonnes sur lesquels faire l'agrégation

    Return:
        pd.DataFrame: df avec la colonne size en supplément
    """
    df_agg = df.groupby(col, as_index=False).size().reset_index(drop = True)
    df_result = df.merge(df_agg, on=col, how='left')
    return df_result

exclude_by_length(lst, condition)

Vérifie si une liste respecte une condition de longueur donnée ou contient NaN.

Parameters:
  • lst (List) –

    Liste à vérifier (peut contenir des float NaN)

  • condition (str) –

    Condition de longueur (">=2", "2", "1", "0")

Returns:
  • bool( bool ) –

    True si la condition est respectée ou si NaN est présent, False sinon

Source code in src/Process/Utils/Datamanagement.py
def exclude_by_length(lst: List, condition: str) -> bool:
    """
    Vérifie si une liste respecte une condition de longueur donnée ou contient NaN.

    Args:
        lst: Liste à vérifier (peut contenir des float NaN)
        condition: Condition de longueur (">=2", "2", "1", "0")

    Returns:
        bool: True si la condition est respectée ou si NaN est présent, False sinon
    """
    liste_AO = [
        "122", "123", "124", "125", "126", "127", "129", "128", "130", "121",
        "351", "352", "353", "354", "356", "357", "360", "361", "362", "363",
        "364", "365", "366", "367", "368", "371", "372", "369", "370", "355",
        "359", "373", "374", "375", "376", "377", "378", "380", "381", "382",
        "383", "384", "385", "386", "387", "388", "389", "390", "391", "379"
    ]

    try:
        # Vérification si l'entrée est un float
        if isinstance(lst, float):
            return math.isnan(lst)

        # Vérification de la présence de NaN dans la liste
        try:
            has_nan = any(isinstance(x, float) and math.isnan(x) for x in lst)
            if has_nan:
                logger.warning("NaN trouvé dans la liste, retourne True")
                return True
        except TypeError as e:
            logger.warning(f"Erreur lors de la vérification de NaN: {e}")
            return False

        # Si condition est "0", retourne directement False
        if condition == "0":
            # logger.debug(f"Condition '0': retourne False pour la liste {lst}")
            return False

        commun = list(set(lst) & set(liste_AO))
        list_length = len(commun)
        result = False

        # Vérification des conditions
        if condition == ">=2" and list_length < 2:
            result = True
        elif condition == "2" and list_length != 2:
            result = True
        elif condition == "1" and list_length > 1:
            result = True

        # logger.debug(
        #     "Vérification longueur: liste={}, longueur={}, condition={}, résultat={}",
        #     lst, list_length, condition, result
        # )
        return result

    except Exception as e:
        logger.error("Erreur lors de la vérification: {}", str(e))
        raise

exclude_by_list(lst, elements_to_check)

Vérifie si aucun élément de la liste elements_to_check n'est présent dans la liste lst.

Parameters:
  • lst (list) –

    La liste principale dans laquelle vérifier la présence des éléments.

  • elements_to_check (list) –

    La liste des éléments à vérifier.

Returns:
  • bool –

    False si aucun élément de elements_to_check n'est présent dans lst, sinon True.

Source code in src/Process/Utils/Datamanagement.py
def exclude_by_list(lst, elements_to_check):
    """
    Vérifie si aucun élément de la liste `elements_to_check` n'est présent dans la liste `lst`.

    Args:
        lst (list): La liste principale dans laquelle vérifier la présence des éléments.
        elements_to_check (list): La liste des éléments à vérifier.

    Returns:
        bool: `False` si aucun élément de `elements_to_check` n'est présent dans `lst`, sinon `True`.
    """
    # Vérifie si tous les éléments ne sont pas dans la liste
    # logger.debug(lst)

    # Si elements_to_check est vide, retourne False
    if not elements_to_check:
        # logger.debug("elements_to_check is empty, returning False")
        return False

    # Si lst est vide mais elements_to_check ne l'est pas
    if not lst and elements_to_check:
        # logger.debug("lst is empty but elements_to_check is not, returning True")
        return True

    # Vérifie si au moins un élément de elements_to_check est dans lst
    result = any(element in lst for element in elements_to_check)
    return result

exclude_by_niveauexpertise_actespecifique(str_value, expected_str, subgroupe)

Vérifie si le niveau d'expertise et l'acte spécifique sont égaux à 30 et 1399, dans le cas spécifiques des regroupements R4.1 et R4.2

Parameters:
  • lst –

    Liste à vérifier (peut contenir des float NaN)

  • expected_str –

    Niveau d'expertise attendu ou acte spécifique attendu

  • subgroupe (str) –

    Code de sous-regroupement

Returns:
  • bool –

    True si la condition est respectée ou si NaN est présent, False sinon

Source code in src/Process/Utils/Datamanagement.py
def exclude_by_niveauexpertise_actespecifique(str_value, expected_str, subgroupe: str):
    """
    Vérifie si le niveau d'expertise et l'acte spécifique sont égaux à 30 et 1399, dans le cas spécifiques des regroupements R4.1 et R4.2

    Args:
        lst: Liste à vérifier (peut contenir des float NaN)
        expected_str: Niveau d'expertise attendu ou acte spécifique attendu
        subgroupe: Code de sous-regroupement

    Returns:
        bool: True si la condition est respectée ou si NaN est présent, False sinon
    """
    if isinstance(str_value, float) and math.isnan(str_value):
        if subgroupe == "R4.1":
            return False
        elif subgroupe == "R4.2":
            return True
        #logger.debug("NaN trouvé dans la liste, retourne True")
    else :
        if subgroupe == "R4.1":
            if str_value == expected_str:
                return True
        elif subgroupe == "R4.2":
            if str_value != expected_str:
                return True
    return False

exclude_by_typeoffre(str_value, expected_str)

Vérifie si le type d'offre correspond à celui attendu

Parameters:
  • lst –

    Liste à vérifier (peut contenir des float NaN)

  • expected_str –

    Type d'offre attendu (soit 122, 139, 123 ou NaN)

Returns:
  • bool –

    True si la condition est respectée ou si NaN est présent, False sinon

Source code in src/Process/Utils/Datamanagement.py
def exclude_by_typeoffre(str_value, expected_str):
    """
    Vérifie si le type d'offre correspond à celui attendu

    Args:
        lst: Liste à vérifier (peut contenir des float NaN)
        expected_str: Type d'offre attendu (soit 122, 139, 123 ou NaN)

    Returns:
        bool: True si la condition est respectée ou si NaN est présent, False sinon
    """
    if isinstance(expected_str, float) and math.isnan(expected_str):
        if isinstance(str_value, float) and math.isnan(str_value):
            return False
        else :
            return True 
    else:
        if isinstance(str_value, float) and math.isnan(str_value):
            return True
        elif str_value != expected_str:
            return True
        else:
            return False

exploded_var(df, var)

Fonction d'explosion des listes vers un format 1 lignes par élément de la liste. Création d'une colonne id associée aux éléments de la liste.

Parameters:
  • df (DataFrame) –

    Dataframe de la liste à exploser

  • var (str) ) –

    Nom de la variable contenant la liste à exploser

Returns:
  • df( DataFrame ) –

    Dataframe avec une ligne par élément de la liste (sans perdre les autres informations) et ajout d'une colonne id

Source code in src/Process/Utils/Datamanagement.py
def exploded_var(df: pd.DataFrame, var: str) -> pd.DataFrame:
    """
    Fonction d'explosion des listes vers un format 1 lignes par élément de la liste.
    Création d'une colonne id associée aux éléments de la liste.

    Args:
        df (DataFrame): Dataframe de la liste à exploser
        var (str) : Nom de la variable contenant la liste à exploser

    Returns:
        df: Dataframe avec une ligne par élément de la liste (sans perdre les autres informations) et ajout d'une colonne id
    """  
    df_copy = df.copy()
    # Ajout d'un id pour chaque liste (chaque élément de la liste aura le même identifiant)
    #if len(df_copy.explode(var, ignore_index = True)) != len(df_copy) : # Création de l'id si l'éclatement créer de nouvelles lignes 
    df_copy[str('id.' + var)] = df_copy.index.copy()

    # Création de nouvelles lignes pour chaque élément des listes
    df_exploded = df_copy.explode(var, ignore_index = True)
    df_exploded[var] = df_exploded[var].apply(lambda x: x if isinstance(x, dict) else {})

    # Restructuration des clés (dictionnaire) comme colonnes
    temp_normalized = pd.json_normalize(df_exploded[var]).add_prefix(str(var + '.'))

    # Ajout des modification au df
    df_result = pd.concat([df_exploded.loc[:, :var].merge(temp_normalized, how = 'left', left_index = True, right_index = True), df_exploded.loc[:, var:]], axis = 1)

    # Suppression de la colonne déstructurée
    df_result.drop(columns=[var], inplace=True)

    return df_result

find_finess_organization(df)

Remonte la hiérarchie des organisations pour trouver le FINESS pour chacune. S'arrête lorsque que l'organisation est EG ou parent (si non EG).

Parameters:
  • df (DataFrame) –

    dataframe organization contenant les ID organization, les FINESS et les ID organization parent.

Returns:
  • DataFrame –

    pd.DataFrame: dataframe contenant les ID organization et les FINESS.

Source code in src/Process/Utils/Datamanagement.py
def find_finess_organization(df: pd.DataFrame)-> pd.DataFrame:
    """Remonte la hiérarchie des organisations pour trouver le FINESS pour chacune. S'arrête lorsque que l'organisation est EG ou parent (si non EG).

    Args:
        df (pd.DataFrame): dataframe organization contenant les ID organization, les FINESS et les ID organization parent.

    Returns:
        pd.DataFrame: dataframe contenant les ID organization et les FINESS.
    """
    ORGA_ID_COL = "resource.id"
    FINESS_COL = "resource.identifier.value"
    ORGA_PARTOF_COL = "resource.partOf.id"
    ORGA_PROVIDEDBY_COL = "provided_by"
    ORGA_NAME_COL = "resource.name"
    ORGA_TYPE_COL = "resource.type.coding.code"

    # Dataframe contenant les FINESS
    finess_df = df.loc[df[FINESS_COL].notna(), [ORGA_ID_COL, FINESS_COL, ORGA_NAME_COL]]

    # Liste contenant les EG (entités géographiques)
    EG_list = list(df.loc[df[ORGA_TYPE_COL] == "EG", ORGA_ID_COL])

    # Dataframe de hiérarchie des ID organization
    i = 1 
    part_of_df = df.loc[df[ORGA_ID_COL].notna(), [ORGA_ID_COL, ORGA_PARTOF_COL]]
    part_of = part_of_df.rename(columns={ORGA_ID_COL: ORGA_PROVIDEDBY_COL, ORGA_PARTOF_COL: ORGA_PARTOF_COL + str(i)})
    part_of["is_EG"] = part_of[ORGA_PROVIDEDBY_COL].isin(EG_list)

    # Boucle d'incrémentation de hiérachie : s'arrête lorsque que toutes les organizations sont des EG (entités géographiques)
    col_prev = ORGA_PROVIDEDBY_COL
    while True:
        col_current = ORGA_PARTOF_COL + str(i)
        col_next = ORGA_PARTOF_COL + str(i + 1)

        # Remplissage des ID de niveau supérieur
        part_of.loc[pd.isna(part_of[col_current]), "is_EG"] = True
        part_of.loc[part_of["is_EG"] == True, col_current] = part_of.loc[part_of["is_EG"] == True, col_prev]
        part_of.loc[part_of["is_EG"] == False, col_current] = part_of.loc[part_of["is_EG"] == False, col_current]

        # Merge l'ID de la hiérarchie parent avec le dataframe de hiérarchie
        part_of = part_of.merge(part_of_df, left_on=col_current, right_on=ORGA_ID_COL, how="left").drop(columns=[ORGA_ID_COL])
        part_of.rename(columns={ORGA_PARTOF_COL: col_next}, inplace=True)

        # Mise à jour de `is_EG` : si l'ID parent est un EG, alors l'enfant devient aussi EG
        part_of["is_EG"] |= part_of[col_current].isin(EG_list)

        # Arrêt de la boucle lorsqu'il n'y a plus de hiérarchie parent (lorsque la colonne est entièrement vide)
        if part_of["is_EG"].all():
            part_of.drop(columns=[col_next], inplace=True)
            break
        col_prev = col_current
        i += 1

    # Merge des FINESS avec la hiérarchie parent
    df_result = part_of.merge(finess_df, left_on=col_current, right_on=ORGA_ID_COL, how="left") #[[ORGA_PROVIDEDBY_COL, FINESS_COL, ORGA_NAME_COL]]
    return df_result

format_postal_code(df, col_postal_code='postal_code')

Formate la colonne des codes postaux : - Remplace les NaN par '00000'. - Assure que les codes postaux ont une longueur de 5 chiffres. - Simplifie les codes pour la Corse (3 premiers chiffres si '20') et les DOM-TOM (3 premiers chiffres si '97'). - Garde les 2 premiers chiffres pour les autres régions.

Args : df (pd.DataFrame): DataFrame contenant la colonne des codes postaux. col_postal_code (str) : Nom de la colonne à traiter (par défaut "postal_code").

Returns : df_result (DataFrame): DataFrame avec la colonne formatée.

Source code in src/Process/Utils/Datamanagement.py
def format_postal_code(df: pd.DataFrame, col_postal_code:str ="postal_code")-> pd.DataFrame:
    """
    Formate la colonne des codes postaux :
    - Remplace les NaN par '00000'.
    - Assure que les codes postaux ont une longueur de 5 chiffres.
    - Simplifie les codes pour la Corse (3 premiers chiffres si '20') et les DOM-TOM (3 premiers chiffres si '97').
    - Garde les 2 premiers chiffres pour les autres régions.

    Args :
    df (pd.DataFrame): DataFrame contenant la colonne des codes postaux.
    col_postal_code (str) : Nom de la colonne à traiter (par défaut "postal_code").

    Returns :
    df_result (DataFrame): DataFrame avec la colonne formatée.
    """
    try :
        df["departement"] = df[col_postal_code].fillna(0).astype(int).astype(str).str.zfill(5)
        df["departement"] = df["departement"].apply(lambda x: x[:3] if x.startswith(("20", "97")) else x[:2])
        df["departement"] = df["departement"].apply(lambda x: "2A" if x in ["200", "201"] else ("2B" if x in ["202", "206"] else x))
        df["departement"] = df["departement"].apply(lambda x: "" if x == "00" else x)
        return df
    except KeyError as e:
        logger.error(f"An error occurred: colonne {col_postal_code} non existante")

formating_location_id(column)

Extrait la valeur 'reference' du premier élément de la liste si elle existe, sinon '/'.

Source code in src/Process/Utils/Datamanagement.py
def formating_location_id(column):
    """
    Extrait la valeur 'reference' du premier élément de la liste si elle existe, sinon '/'.
    """
    try:
        return column[0]['reference']
    except Exception as e:
        logger.warning(f"Erreur une valeur resource.location {column} ne contient pas d'élément 'reference' : {str(e)}")
    return "/"

get_code(var)

Récupération des "codes" situés dans des dictionnaires contenant des listes

Parameters:
  • var –

    variable dans laquelle les codes sont situées

Returns:
  • code –

    valeur du code

Source code in src/Process/Utils/Datamanagement.py
def get_code(var) :
    """
    Récupération des "codes" situés dans des dictionnaires contenant des listes

    Args:
        var : variable dans laquelle les codes sont situées

    Returns:
        code : valeur du code
    """ 
    if isinstance(var, list): 
        return [
            code.get("code") 
            for coding in var if isinstance(coding, dict) 
            for code in coding.get("coding", []) if isinstance(code, dict)
        ][0]
    return ""

get_columns(table, col_list)

Charge le fichier répertoriant le nom des colonnes des tables.

Arg

table (str): table pour laquelle on vaut modifier les colonnes col_list (str): nom de la liste des colonnes

Returns: dict: La configuration pour l'environnement spécifié.

Raises:
  • Exception –

    Si le fichier de configuration ne peut pas être chargé ou contient des erreurs.

Source code in src/Process/Utils/Datamanagement.py
def get_columns(table:str, col_list:str):
    """
    Charge le fichier répertoriant le nom des colonnes des tables.

    Arg:
        table (str): table pour laquelle on vaut modifier les colonnes
        col_list (str): nom de la liste des colonnes
    Returns:
        dict: La configuration pour l'environnement spécifié.

    Raises:
        Exception: Si le fichier de configuration ne peut pas être chargé ou contient des erreurs.
    """
    current_dir = os.path.dirname(os.path.abspath(__file__))
    current_dir = Path(current_dir)
    metadata_config_path = current_dir.parent.parent.parent.absolute() / "Config" / "metadata.yaml"

    try:
        with open(metadata_config_path, 'r') as f:
            metadata = yaml.safe_load(f)
            logger.info(f"Acces config file readed from {metadata_config_path}")
            return metadata[table][col_list]
    except Exception as e:
        logger.warning(f"Erreur lors du chargement du fichier de configuration : {e}")
        raise

groupby_merge_group(df, groupby, agg)

Fonction d'agrégation (somme) par groupe, et ajoutant l'agrégation au dataframe de traitement

Parameters:
  • df (DataFrame) –

    DataFrame nécessitant la transformation

  • groupby (list) –

    Liste des colonnes à grouper

  • agg (list) –

    Liste des colonnes à aggréger

Returns:
  • df_result( DataFrame ) –

    DataFrame comprenant l'aggrégation par groupe

Source code in src/Process/Utils/Datamanagement.py
def groupby_merge_group(df: pd.DataFrame, groupby: list, agg: list) -> pd.DataFrame:
    """
    Fonction d'agrégation (somme) par groupe, et ajoutant l'agrégation au dataframe de traitement

    Args:
        df (DataFrame): DataFrame nécessitant la transformation
        groupby (list): Liste des colonnes à grouper
        agg (list): Liste des colonnes à aggréger

    Returns:
        df_result (DataFrame): DataFrame comprenant l'aggrégation par groupe
    """  
    df_result = df.drop(columns=agg).merge(
        df.groupby(groupby, as_index = False)[agg].sum(),
        left_on=groupby,
        right_on=groupby,
        how="right")
    return df_result

healthcareservice_data_management(df)

Fonction principale de traitement des données HealthcareService.

Source code in src/Process/Utils/Datamanagement.py
def healthcareservice_data_management(df: pd.DataFrame) -> pd.DataFrame:
    """
    Fonction principale de traitement des données HealthcareService.
    """
    try:
        logger.info("Début du traitement healthcareservice_data_management")
        df_result = df.copy()


        # --- Récupération des Activités Opérationnelles ---
        if "id.resource.specialty" not in df_result.columns:
            logger.warning("Création de la colonne id.resource.specialty")
            df_result["id.resource.specialty"] = df_result.index

        df_AO = conversion_list(df_result[["resource.specialty"]])

        df_AO = df_AO.groupby('id.resource.specialty')['resource.specialty.coding.code'].apply(list).to_frame()
        df_result = merge_try_error(
            df_result, 
            df_AO, 
            left_on="id.resource.specialty",
            right_on="id.resource.specialty"
        )

        # --- Récupération des ages (min-max) ---
        if "id.resource.extension" not in df_result.columns:
            logger.warning("Création de la colonne id.resource.extension")
            df_result["id.resource.extension"] = df_result.index

        df_age = conversion_list(df_result[["resource.extension"]])
        df_age = df_age[df_age["resource.extension.extension.url"] == "ageRange"]

        df_result = merge_try_error(
            df_result, 
            df_age, 
            left_on="id.resource.extension",
            right_on="id.resource.extension"
        )

        # --- Récupération de type offre ---
        df_result = verif_col(df_result, ["resource.category"])
        df_result["resource.category"] = df_result["resource.category"].apply(get_code).apply(lambda x: x if x in ["122", "123", "139"] else np.nan)

        # --- Traitement des caractéristiques ---
        # Vérifie si la colonne id.resource.characteristic existe, sinon la crée
        if "id.resource.characteristic" not in df_result.columns:
            logger.warning("Création de la colonne id.resource.characteristic")
            df_result["id.resource.characteristic"] = df_result.index

        df_add_other = conversion_list(df_result[["resource.characteristic"]])
        df_add_other = process_characteristic_data(df_add_other)

        # Vérification avant la fusion
        df_result = merge_try_error(
            df_result, 
            df_add_other, 
            left_on="id.resource.characteristic",
            right_on="id.resource.characteristic"
        )

        # --- Formatage des clés de jointure ---
        df_result["resource.providedBy.reference"] = df_result["resource.providedBy.reference"].apply(id_split)
        df_result["resource.location"] = df_result["resource.location"].apply(formating_location_id)
        df_result["resource.location"] = df_result["resource.location"].apply(id_split)


        # Selection et renommer les colonnes
        col_healthcareservice = get_columns(table="HealthcareService", col_list="healthcareservice_col_name")
        df_result = df_result[list(col_healthcareservice.keys())]
        df_result.rename(columns=col_healthcareservice, inplace=True) 
        # df_result = df_result[list(col_healthcareservice_keep)]
        # df_result.columns = final_healthcareservice_col_name
        logger.info("Traitement healthcareservice_data_management terminé avec succès")

        return df_result

    except Exception as e:
        logger.error(f"Erreur dans healthcareservice_data_management: {str(e)}")
        raise

id_split(id_value)

Formatage des id du format (Location/xxxx) vers (xxxx)

Source code in src/Process/Utils/Datamanagement.py
def id_split(id_value:str) :
    """
    Formatage des id du format (Location/xxxx) vers (xxxx)
    """
    return str(id_value).split('/')[-1]

location_anomalies(df)

Fonction de gestion des anomalies pour les données de Location : soit les codes postaux manquants, soit les lits installés négatifs.

Source code in src/Process/Utils/Datamanagement.py
def location_anomalies(df: pd.DataFrame) -> pd.DataFrame:
    """
    Fonction de gestion des anomalies pour les données de Location : soit les codes postaux manquants, soit les lits installés négatifs.
    """
    liste_col = ["location", "last_update", "name_location", "postal_code", "lit_capacite", "lit_dispo"]
    df_result = df.copy()
    df_anomalies = df.loc[(pd.isna(df["postal_code"])) | (df["lit_capacite"] < 0), liste_col]

    df_result.loc[df_result["lit_capacite"] < 0, "lit_capacite"] = 0
    return df_result, df_anomalies

location_data_management(df)

Fonction de traitement et de structuration des données de Location requêtées.

  1. Traitement de l'extension RORLocationSupportedCapacity de Location (nommée resource.extension)
  2. Récupération de l'ID de Location présent dans resource.identifier (sans destructurer les données)
  3. Merge des informations de Location avec les informations de capacité des lits (pas correctement structurées)
  4. Structuration des champs de capacité des lits (status, type, date, nombre), via pivotage
  5. Merge des informations de Location et de Capacity (pivoté) et mise en forme du DataFrame
Parameters:
  • df (DataFrame) –

    DataFrame contenant les données de Location

Returns:
  • df_result( DataFrame ) –

    DataFrame traité contenant les informations de Location (id, nom, code postal) et les informations de capacité des lits (status, type, date, nombre)

Source code in src/Process/Utils/Datamanagement.py
def location_data_management(df: pd.DataFrame) -> pd.DataFrame:
    """
    Fonction de traitement et de structuration des données de Location requêtées.

    1. Traitement de l'extension RORLocationSupportedCapacity de Location (nommée resource.extension)
    2. Récupération de l'ID de Location présent dans resource.identifier (sans destructurer les données)
    3. Merge des informations de Location avec les informations de capacité des lits (pas correctement structurées)
    4. Structuration des champs de capacité des lits (status, type, date, nombre), via pivotage
    5. Merge des informations de Location et de Capacity (pivoté) et mise en forme du DataFrame

    Args:
        df (DataFrame): DataFrame contenant les données de Location

    Returns:
        df_result (DataFrame): DataFrame traité contenant les informations de Location (id, nom, code postal) et les informations de capacité des lits (status, type, date, nombre)
    """  
    # 1. Traitement de l'extension RORLocationSupportedCapacity ----------------------------------------------
    # Déstructuration
    if "id.resource.extension" not in df.columns:
        logger.warning("Création de la colonne id.resource.extension")
        df["id.resource.extension"] = df.index

    df_capacity = conversion_list(df[["resource.extension"]])

    # Création de la colonne value (contenant les valeurs des champs)
    df_capacity["value"] = df_capacity["resource.extension.extension.valueInteger"].fillna(df_capacity["resource.extension.extension.valueDateTime"].fillna(df_capacity["resource.extension.extension.valueCodeableConcept.coding.code"]))
    df_capacity.dropna(subset=['value'], axis = 0, inplace = True) # Suppression des NA de value


    # 2. Récupération de l'ID de Location présent dans resource.identifier ----------------------------------------------
    df["location_id_key"] = df["resource.identifier"].apply(
        lambda ID_loc: [type_loc.get("value") for type_loc in ID_loc][0] if isinstance(ID_loc, list) else np.nan
    )

    # 3. Merge de Location avec df Capacity ----------------------------------------------
    df_result = df.merge(df_capacity, left_index = True, right_on = "id.resource.extension", how = 'right')
    df_result = merge_try_error(
        df, 
        df_capacity, 
        left_on = "id.resource.extension",
        right_on = "id.resource.extension"
    )

    # df_result = df_result[col_location_keep + col_capacity_keep]
    col_location = get_columns(table="Location", col_list="location_col_name")
    df_result = df_result[list(col_location.keys())]
    df_result.rename(columns=col_location, inplace=True)    

    # 4. Pivoter les champs de df Capacity ----------------------------------------------
    capacity_col = get_columns(table="Location", col_list="capacity_col")
    df_capacity = df_result.loc[df_result["capacity_col"].isin(capacity_col), ['id_unite', 'capacity_col', 'value']] # On garde que les champs à garder
    df_capacity = df_capacity.pivot(index = ['id_unite'], columns = 'capacity_col', values = 'value') # Pivoter les champs
    df_capacity["capacityUpdateDate"] = pd.to_datetime(df_capacity["capacityUpdateDate"]).dt.tz_localize(None)

    # 5. Merge les informations de Location et de Capacity (pivoté) ----------------------------------------------
    df_result = df_result[['id_unite', 'location', 'name_location', 'last_update', 'postal_code', 'location_id_key']].drop_duplicates()
    df_result["location_id_key"] = df_result["location_id_key"].apply(id_split)
    df_result = df_result.merge(df_capacity, on = 'id_unite', how = 'right')
    df_result["last_update"] = pd.to_datetime(df_result["last_update"]).dt.tz_localize(None)
    df_result.drop(columns = ['id_unite'], inplace = True)

    return df_result

mapping_dep(df, col_key_on='departement')

Merge du dataframe Location avec le mapping des régions et départements

Args : df (DataFrame) : DataFrame avec une colonne département

Returns : df_result (DataFrame): DataFrame avec joint avec les informations des régions

Source code in src/Process/Utils/Datamanagement.py
def mapping_dep(df: pd.DataFrame, col_key_on:str = "departement")-> pd.DataFrame:
    """
    Merge du dataframe Location avec le mapping des régions et départements

    Args :
    df (DataFrame) : DataFrame avec une colonne département

    Returns :
    df_result (DataFrame): DataFrame avec joint avec les informations des régions
    """
    mapping_df = load_mapping_file("mapping_reg_dep.csv")
    mapping_df["departement"] = mapping_df["departement"].astype(str).apply(lambda x: x.zfill(2) if len(x) < 2 else x)

    logger.info("Mapping reg-dep api file succefully readed")

    mapping_df["region_code"] = mapping_df["region_code"].astype(str)
    df_result = df.merge(mapping_df, left_on = col_key_on, right_on = "departement", how  = 'left')
    return df_result

merge_try_error(df1, df2, left_on, right_on)

Vérifie la présence des colonnes de fusion et réalise la fusion

Parameters:
  • df1 (DataFrame) –

    Premier DataFrame

  • df2 (DataFrame) –

    Second DataFrame

  • left_on (str) –

    Colonne de fusion du premier DataFrame

  • right_on (str) –

    Colonne de fusion du second DataFrame

Source code in src/Process/Utils/Datamanagement.py
def merge_try_error(df1: pd.DataFrame, df2: pd.DataFrame, left_on: str, right_on: str) -> pd.DataFrame:
    """
    Vérifie la présence des colonnes de fusion et réalise la fusion

    Args:
        df1 (pd.DataFrame): Premier DataFrame
        df2 (pd.DataFrame): Second DataFrame
        left_on (str): Colonne de fusion du premier DataFrame
        right_on (str): Colonne de fusion du second DataFrame
    """
    verify_merge_columns(
        df1, 
        df2, 
        left_on=left_on,
        right_on=right_on
    )

    # Fusion avec gestion d'erreur
    try:
        if df2.index.name == right_on :
            df_result = df1.merge(
                df2,
                left_on=left_on,
                right_index=True,  # Si df2 utilise right_on comme index
                how='left'
            )
        else :
            df_result = df1.merge(
                df2,
                left_on=left_on,
                right_on=right_on,  # Si df2 utilise right_on comme index
                how='left'
            )
        return df_result
    except Exception as merge_error:
        logger.error(f"Erreur lors de la fusion: {str(merge_error)}")
        raise

organization_anomalies(df)

Fonction de gestion des anomalies pour les données de Organization : soit les établissements sont manquant, soit le FINESS est incorrect.

Source code in src/Process/Utils/Datamanagement.py
def organization_anomalies(df: pd.DataFrame) -> pd.DataFrame:
    """
    Fonction de gestion des anomalies pour les données de Organization : soit les établissements sont manquant, soit le FINESS est incorrect.
    """
    liste_col = ["provided_by", "etablissement", "finess"]
    df_anomalies = df.loc[(pd.isna(df["etablissement"])) | (df["finess"] == "888888888"), liste_col]
    return df_anomalies

process_characteristic_data(df_add_other)

Traite les données caractéristiques avec gestion d'erreurs.

Parameters:
  • df_add_other (DataFrame) –

    DataFrame source

Returns:
  • DataFrame –

    pd.DataFrame: DataFrame traité

Source code in src/Process/Utils/Datamanagement.py
def process_characteristic_data(df_add_other: pd.DataFrame) -> pd.DataFrame:
    """
    Traite les données caractéristiques avec gestion d'erreurs.

    Args:
        df_add_other (pd.DataFrame): DataFrame source

    Returns:
        pd.DataFrame: DataFrame traité
    """
    try:
        # Vérification de la présence des colonnes nécessaires
        required_columns = [
            "id.resource.characteristic",
            "resource.characteristic.coding.system",
            "resource.characteristic.extension.valueCode",
            "resource.characteristic.coding.display",
            "resource.characteristic.coding.code"
        ]

        df_add_other = verif_col(df_add_other, required_columns)

        # Création de la colonne ModePriseEnCharge
        mode_prise_en_charge = (df_add_other.loc[df_add_other["resource.characteristic.coding.system"].str.contains("ModePriseEnCharge", na=False), 
                ["resource.characteristic.coding.code", "id.resource.characteristic"]]
                .rename(columns={"resource.characteristic.coding.code": "ModePriseEnCharge"})
                )

        # Application des filtres
        mask = (
            (df_add_other["resource.characteristic.extension.valueCode"] == "specificAct") |
            (df_add_other["resource.characteristic.coding.display"] == "Unité de réanimation pédiatrique de recours")
        )

        filtered_df = df_add_other[mask]

        # Agrégation
        result_df = filtered_df.groupby('id.resource.characteristic').agg({
            "resource.characteristic.coding.code": lambda x: "1399" if "1399" in x.tolist() else np.nan,
            "resource.characteristic.coding.display": lambda x: "30" if "Unité de réanimation pédiatrique de recours" in x.tolist() else np.nan
        })

        result_df = merge_try_error(
            mode_prise_en_charge, 
            result_df, 
            left_on="id.resource.characteristic",
            right_on="id.resource.characteristic"
        ).set_index("id.resource.characteristic")

        logger.info(f"Données caractéristiques traitées. Shape: {result_df.shape}")
        return result_df
    except Exception as e:
        logger.error(f"Erreur dans process_characteristic_data: {str(e)}")
        # logger.debug(f"Shape du DataFrame: {df_add_other.shape}")
        # logger.debug(f"Colonnes: {df_add_other.columns.tolist()}")
        raise

safe_column_access(df, columns)

Vérifie en toute sécurité si les colonnes existent dans le DataFrame.

Parameters:
  • df (DataFrame) –

    DataFrame source

  • columns (list) –

    Liste des colonnes à vérifier

Returns:
  • DataFrame –

    pd.DataFrame: DataFrame avec les colonnes manquantes ajoutées (avec des valeurs None)

Source code in src/Process/Utils/Datamanagement.py
def safe_column_access(df: pd.DataFrame, columns: list) -> pd.DataFrame:
    """
    Vérifie en toute sécurité si les colonnes existent dans le DataFrame.

    Args:
        df (pd.DataFrame): DataFrame source
        columns (list): Liste des colonnes à vérifier

    Returns:
        pd.DataFrame: DataFrame avec les colonnes manquantes ajoutées (avec des valeurs None)
    """
    df_copy = df.copy()
    for col in columns:
        if col not in df_copy.columns:
            logger.warning(f"Colonne manquante '{col}' ajoutée avec des valeurs None")
            df_copy[col] = np.nan
    return df_copy

sort_drop_group(df)

Fonction de tri puis de suppression des doublons des regroupements

Parameters:
  • df (DataFrame) –

    DataFrame nécessitant la transformation

Returns:
  • df_result( DataFrame ) –

    DataFrame trié et sans doublons

Source code in src/Process/Utils/Datamanagement.py
def sort_drop_group(df: pd.DataFrame) -> pd.DataFrame:
    """
    Fonction de tri puis de suppression des doublons des regroupements 

    Args:
        df (DataFrame): DataFrame nécessitant la transformation

    Returns:
        df_result (DataFrame): DataFrame trié et sans doublons
    """  
    df_result = df.sort_values(by = ['groupe', 'capacityUpdateDate'], ascending = [True, False]).drop_duplicates(subset = ['groupe'], keep = 'first')
    return df_result

verif_col(df, required_columns)

Vérification de la présence de la colonne, et création en valeur manquantes si vide

Source code in src/Process/Utils/Datamanagement.py
def verif_col(df: pd.DataFrame, required_columns: list) -> pd.DataFrame:
    """
    Vérification de la présence de la colonne, et création en valeur manquantes si vide
    """
    # Ajout des colonnes manquantes avec des valeurs None
    for col in required_columns:
        if col not in df.columns:
            logger.warning(f"Ajout de la colonne manquante: {col}")
            df[col] = np.nan
    return df

verify_merge_columns(df1, df2, left_on, right_on)

Vérifie la présence des colonnes de fusion et log les informations utiles.

Parameters:
  • df1 (DataFrame) –

    Premier DataFrame

  • df2 (DataFrame) –

    Second DataFrame

  • left_on (str) –

    Colonne de fusion du premier DataFrame

  • right_on (str) –

    Colonne de fusion du second DataFrame

Source code in src/Process/Utils/Datamanagement.py
def verify_merge_columns(df1: pd.DataFrame, df2: pd.DataFrame, left_on: str, right_on: str) -> None:
    """
    Vérifie la présence des colonnes de fusion et log les informations utiles.

    Args:
        df1 (pd.DataFrame): Premier DataFrame
        df2 (pd.DataFrame): Second DataFrame
        left_on (str): Colonne de fusion du premier DataFrame
        right_on (str): Colonne de fusion du second DataFrame
    """

    if left_on not in df1.columns:
        logger.error(f"Colonne '{left_on}' non trouvée dans le premier DataFrame")
        raise KeyError(f"Colonne de fusion '{left_on}' manquante")

    if right_on not in df2.index.names and right_on not in df2.columns:
        logger.error(f"Colonne '{right_on}' non trouvée dans le second DataFrame")
        raise KeyError(f"Colonne de fusion '{right_on}' manquante")