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: |
|
|---|
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: |
|
|---|
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.
- Formatage de la date (capacityUpdateDate)
- Filtrage nécessaire sur les colonnes
- 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.
- Source : pour plusieurs saisies différentes d'une ligne on garde la donnée la plus récente
- Fermeture (capacityClosingType) : pour des types de fermeture distincts, on les agrège ensemble
- Genre : pour des genres distincts, on les agrège ensemble
- Statut : calcul des lits installés et disponibles en fonction des statuts (installé = 01 - 05 + 06, disponible = 02)
| Parameters: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
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: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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.
- Traitement de l'extension RORLocationSupportedCapacity de Location (nommée resource.extension)
- Récupération de l'ID de Location présent dans resource.identifier (sans destructurer les données)
- Merge des informations de Location avec les informations de capacité des lits (pas correctement structurées)
- Structuration des champs de capacité des lits (status, type, date, nombre), via pivotage
- Merge des informations de Location et de Capacity (pivoté) et mise en forme du DataFrame
| Parameters: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
| Returns: |
|
|---|
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: |
|
|---|
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")