Connector
src.Process.Utils.Connector
Classes
DBConnector
Source code in src/Process/Utils/Connector.py
class DBConnector:
def __init__(self, env: Literal["recette", "production"], config_file_dir=None):
"""
Initialise le client ROR avec l'environnement spécifié.
Args:
env (Literal["recette", "production"]): L'environnement cible (recette ou production).
"""
self.env = env
self.config = self.load_config(config_file_dir)
self.conn = None
def load_config(self,config_file_dir ):
"""
Charge la configuration depuis un fichier YAML.
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.
"""
if config_file_dir:
acces_config_path = config_file_dir / "acces.yaml"
current_dir = os.path.dirname(os.path.abspath(__file__))
current_dir = Path(current_dir)
acces_config_path = current_dir.parent.parent.parent.absolute() / "Config" / "acces.yaml"
logger.info(acces_config_path)
try:
with open(acces_config_path, 'r') as f:
acces_config = yaml.safe_load(f)
logger.info(f"Acces config file readed from {acces_config_path}")
return acces_config[self.env]["DB_CONFIG"]
except Exception as e:
logger.error(f"Erreur lors du chargement du fichier de configuration : {e}")
raise
def connect(self):
try:
self.conn = psycopg2.connect(**self.config)
logger.success("Successfully connected to the database!")
except psycopg2.Error as e:
logger.error(f"Failed to connect to the database: {e}")
def close(self):
if self.conn:
self.conn.close()
logger.info("Database connection closed.")
def execute_query(self, query, params=None):
try:
if not self.conn or self.conn.closed:
self.connect()
with self.conn.cursor() as cursor:
cursor.execute(query, params or ())
self.conn.commit()
logger.info("Query executed successfully.")
except psycopg2.Error as e:
logger.error(f"Failed to execute query: {e}")
if self.conn:
self.conn.rollback()
Functions
__init__(env, config_file_dir=None)
Initialise le client ROR avec l'environnement spécifié.
| Parameters: |
|
|---|
Source code in src/Process/Utils/Connector.py
def __init__(self, env: Literal["recette", "production"], config_file_dir=None):
"""
Initialise le client ROR avec l'environnement spécifié.
Args:
env (Literal["recette", "production"]): L'environnement cible (recette ou production).
"""
self.env = env
self.config = self.load_config(config_file_dir)
self.conn = None
load_config(config_file_dir)
Charge la configuration depuis un fichier YAML.
| Returns: |
|
|---|
| Raises: |
|
|---|
Source code in src/Process/Utils/Connector.py
def load_config(self,config_file_dir ):
"""
Charge la configuration depuis un fichier YAML.
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.
"""
if config_file_dir:
acces_config_path = config_file_dir / "acces.yaml"
current_dir = os.path.dirname(os.path.abspath(__file__))
current_dir = Path(current_dir)
acces_config_path = current_dir.parent.parent.parent.absolute() / "Config" / "acces.yaml"
logger.info(acces_config_path)
try:
with open(acces_config_path, 'r') as f:
acces_config = yaml.safe_load(f)
logger.info(f"Acces config file readed from {acces_config_path}")
return acces_config[self.env]["DB_CONFIG"]
except Exception as e:
logger.error(f"Erreur lors du chargement du fichier de configuration : {e}")
raise
RORClient
Client pour interagir avec un service ROR via des requêtes sécurisées.
| Attributes: |
|
|---|
Source code in src/Process/Utils/Connector.py
class RORClient:
"""
Client pour interagir avec un service ROR via des requêtes sécurisées.
Attributes:
env (Literal["recette", "production"]): L'environnement cible (recette ou production).
config (dict): La configuration chargée depuis un fichier YAML.
session (requests.Session): Session HTTP configurée avec un adaptateur SSL.
"""
def __init__(self, env: Literal["recette", "production"], config_file_dir=None):
"""
Initialise le client ROR avec l'environnement spécifié.
Args:
env (Literal["recette", "production"]): L'environnement cible (recette ou production).
"""
self.env = env
self.config = self.load_config(config_file_dir)
self.session = requests.Session()
self.setup_ssl_adapter()
self.request_filters = generate_request_filter()
def load_config(self, config_file_dir):
"""
Charge la configuration depuis un fichier YAML.
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.
"""
if config_file_dir:
acces_config_path = config_file_dir / "acces.yaml"
else:
current_dir = os.path.dirname(os.path.abspath(__file__))
current_dir = Path(current_dir)
acces_config_path = current_dir.parent.parent.parent.absolute() / "Config" / "acces.yaml"
# logger.info(acces_config_path)
try:
with open(acces_config_path, 'r') as f:
acces_config = yaml.safe_load(f)
logger.info(f"Acces config file readed from {acces_config_path}")
return acces_config[self.env]
except Exception as e:
logger.error(f"Erreur lors du chargement du fichier de configuration : {e}")
raise
def setup_ssl_adapter(self):
"""
Configure l'adaptateur SSL avec les paramètres fournis.
Raises:
ValueError: Si la passphrase n'est pas définie dans les variables d'environnement.
"""
cert_file = self.config['cert_file']
key_file = self.config['key_file']
ca_cert = self.config['ca_cert']
passphrase = os.getenv("CERT_PASSPHRASE")
if not passphrase:
logger.error("La passphrase [CERT_PASSPHRASE] n'est pas définie dans les variables d'environnement.")
raise ValueError("Passphrase manquante dans l'environnement.")
adapter = SSLAdapter(cert_file, key_file, passphrase, ca_cert)
self.session.mount('https://', adapter)
def get_mtls_token(self):
"""
Obtient un token d'authentification via mTLS.
Returns:
dict: La réponse contenant le token ou une erreur.
Raises:
requests.exceptions.RequestException: Si une erreur survient lors de la requête.
"""
token_url = self.config['TOKEN_URL']
data = self.config['data']
try:
response = self.session.post(
token_url,
data=data,
headers={'Content-Type': 'application/x-www-form-urlencoded'}
)
response.raise_for_status()
logger.info("Token obtained successfully.")
return response.json()
except requests.exceptions.RequestException as e:
logger.error(f"Erreur lors de l'obtention du token : {e}")
return {"error": str(e)}
def make_request(self, endpoint: str, request_filter: str) :
"""
Effectue une requête GET sécurisée avec un token Bearer et des filtres.
Args:
endpoint (str): : Le type d'entité pour la requête.
request_filter (dict, optional): Les filtres à appliquer. Par défaut, aucun filtre.
Returns:
dict: La réponse JSON de l'API ou une erreur.
Raises:
requests.exceptions.RequestException: Si une erreur survient lors de la requête.
"""
if endpoint == "Location":
api_url = self.config['LOCATION_URL'] + f"/{endpoint}"
else:
api_url = self.config['API_URL'] + f"/{endpoint}" + "?_include=HealthcareService:organization&_include:iterate=Organization:partof"
header_config = self.config['header_config']
if endpoint=="HealthcareService":
params = {"_filter": request_filter}
else :
params = None
# logger.debug(params)
token_response = self.get_mtls_token()
if "error" in token_response:
return token_response
token = token_response.get('access_token')
header_config['Authorization'] = f'Bearer {token}'
try:
response = self.session.get(api_url, headers = header_config, params = params)
response.raise_for_status()
logger.info("GET request successful.")
return response
except requests.exceptions.RequestException as e:
logger.error(f"Erreur lors de la requête GET : {e}")
return {"error": str(e)}
def make_request_next(self, next_page=None) :
"""
Effectue une requête GET sécurisée avec un token Bearer et des filtres.
Args:
next_page (str): : URL de la page next
Returns:
dict: La réponse JSON de l'API ou une erreur.
Raises:
requests.exceptions.RequestException: Si une erreur survient lors de la requête.
"""
api_url = next_page
header_config = self.config['header_config']
token_response = self.get_mtls_token()
if "error" in token_response:
return token_response
token = token_response.get('access_token')
header_config['Authorization'] = f'Bearer {token}'
try:
response = self.session.get(api_url, headers = header_config, params = None)
response.raise_for_status()
logger.info("GET request successful.")
return response
except requests.exceptions.RequestException as e:
logger.error(f"Erreur lors de la requête GET : {e}")
return {"error": str(e)}
@staticmethod
def get_next_url(response)->Union[str, None]:
"""
Vérifie la présence d'une URL next et la renvoie si elle existe.
Args:
response (dict): La réponse JSON de l'API.
Returns:
str: Lien de la page suivante (next), None si pas de lien
"""
try:
link = response.json().get("link")
# Vérification de l'existence du lien
if link:
i = next((i for i, dico_value in enumerate(link) if dico_value.get("relation") == "next"), None)
if i:
return link[i]["url"]
else :
return None
except AttributeError as e:
logger.error(f"Erreur lors de la requête du next, lien incorrect {e}")
return None
def request_all_pages(self, endpoint: Literal["HealthcareService", "Location", "Organization"], request_filter:str=None, test_mode: bool = False):
"""
Parcours l'ensemble des pages d'un endpoint. Si `test` est True, ne récupère que les deux premières pages.
Args:
endpoint (Literal["HealthcareService", "Location", "Organization"]): Le type d'entité pour la requête.
request_filter (dict, optional): Les filtres à appliquer. Par défaut, aucun filtre.
test (bool, optional): Si True, limite la récupération à deux pages. Par défaut, False.
Returns:
list: Liste contenant une page JSON pour chacun de ses éléments
int: Nombre de pages parcourues
"""
logger.info(f"Request of {endpoint} ")
page = 0
list_jsons = []
url_next = None
while True:
if page == 0: # Première page
logger.info(f"Récupération de la page {page + 1} (première page)")
# response = self.make_request_next(endpoint, next_page="https://api.ror.esante.gouv.fr/ws-diffusion-fhir?_getpages=d7c72717-6717-4bdb-97db-10df69765e42&_getpagesoffset=10000&_count=200&_bundletype=searchset")
# url_next = None
response = self.make_request(endpoint, request_filter=request_filter)
url_next = self.get_next_url(response)
elif url_next: # Deuxième -> Avant-dernière
logger.info(f"Récupération de la page {page + 1}")
response = self.make_request_next(next_page=url_next)
url_next = self.get_next_url(response)
else: # Dernière page
# logger.success(f"Pas de page suivante : fin de la boucle. Total des pages : {page}")
break
if response:
list_jsons.append(response.json())
page += 1
# Si test est True et que nous avons récupéré deux pages, on sort de la boucle
if test_mode and page >= 1:
logger.info("Mode test activé : récupération d'une page seulement.")
break
return list_jsons, page
Functions
__init__(env, config_file_dir=None)
Initialise le client ROR avec l'environnement spécifié.
| Parameters: |
|
|---|
Source code in src/Process/Utils/Connector.py
def __init__(self, env: Literal["recette", "production"], config_file_dir=None):
"""
Initialise le client ROR avec l'environnement spécifié.
Args:
env (Literal["recette", "production"]): L'environnement cible (recette ou production).
"""
self.env = env
self.config = self.load_config(config_file_dir)
self.session = requests.Session()
self.setup_ssl_adapter()
self.request_filters = generate_request_filter()
get_mtls_token()
Obtient un token d'authentification via mTLS.
| Returns: |
|
|---|
| Raises: |
|
|---|
Source code in src/Process/Utils/Connector.py
def get_mtls_token(self):
"""
Obtient un token d'authentification via mTLS.
Returns:
dict: La réponse contenant le token ou une erreur.
Raises:
requests.exceptions.RequestException: Si une erreur survient lors de la requête.
"""
token_url = self.config['TOKEN_URL']
data = self.config['data']
try:
response = self.session.post(
token_url,
data=data,
headers={'Content-Type': 'application/x-www-form-urlencoded'}
)
response.raise_for_status()
logger.info("Token obtained successfully.")
return response.json()
except requests.exceptions.RequestException as e:
logger.error(f"Erreur lors de l'obtention du token : {e}")
return {"error": str(e)}
get_next_url(response)
staticmethod
Vérifie la présence d'une URL next et la renvoie si elle existe.
| Parameters: |
|
|---|
| Returns: |
|
|---|
Source code in src/Process/Utils/Connector.py
@staticmethod
def get_next_url(response)->Union[str, None]:
"""
Vérifie la présence d'une URL next et la renvoie si elle existe.
Args:
response (dict): La réponse JSON de l'API.
Returns:
str: Lien de la page suivante (next), None si pas de lien
"""
try:
link = response.json().get("link")
# Vérification de l'existence du lien
if link:
i = next((i for i, dico_value in enumerate(link) if dico_value.get("relation") == "next"), None)
if i:
return link[i]["url"]
else :
return None
except AttributeError as e:
logger.error(f"Erreur lors de la requête du next, lien incorrect {e}")
return None
load_config(config_file_dir)
Charge la configuration depuis un fichier YAML.
| Returns: |
|
|---|
| Raises: |
|
|---|
Source code in src/Process/Utils/Connector.py
def load_config(self, config_file_dir):
"""
Charge la configuration depuis un fichier YAML.
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.
"""
if config_file_dir:
acces_config_path = config_file_dir / "acces.yaml"
else:
current_dir = os.path.dirname(os.path.abspath(__file__))
current_dir = Path(current_dir)
acces_config_path = current_dir.parent.parent.parent.absolute() / "Config" / "acces.yaml"
# logger.info(acces_config_path)
try:
with open(acces_config_path, 'r') as f:
acces_config = yaml.safe_load(f)
logger.info(f"Acces config file readed from {acces_config_path}")
return acces_config[self.env]
except Exception as e:
logger.error(f"Erreur lors du chargement du fichier de configuration : {e}")
raise
make_request(endpoint, request_filter)
Effectue une requête GET sécurisée avec un token Bearer et des filtres.
| Parameters: |
|
|---|
| Returns: |
|
|---|
| Raises: |
|
|---|
Source code in src/Process/Utils/Connector.py
def make_request(self, endpoint: str, request_filter: str) :
"""
Effectue une requête GET sécurisée avec un token Bearer et des filtres.
Args:
endpoint (str): : Le type d'entité pour la requête.
request_filter (dict, optional): Les filtres à appliquer. Par défaut, aucun filtre.
Returns:
dict: La réponse JSON de l'API ou une erreur.
Raises:
requests.exceptions.RequestException: Si une erreur survient lors de la requête.
"""
if endpoint == "Location":
api_url = self.config['LOCATION_URL'] + f"/{endpoint}"
else:
api_url = self.config['API_URL'] + f"/{endpoint}" + "?_include=HealthcareService:organization&_include:iterate=Organization:partof"
header_config = self.config['header_config']
if endpoint=="HealthcareService":
params = {"_filter": request_filter}
else :
params = None
# logger.debug(params)
token_response = self.get_mtls_token()
if "error" in token_response:
return token_response
token = token_response.get('access_token')
header_config['Authorization'] = f'Bearer {token}'
try:
response = self.session.get(api_url, headers = header_config, params = params)
response.raise_for_status()
logger.info("GET request successful.")
return response
except requests.exceptions.RequestException as e:
logger.error(f"Erreur lors de la requête GET : {e}")
return {"error": str(e)}
make_request_next(next_page=None)
Effectue une requête GET sécurisée avec un token Bearer et des filtres.
| Parameters: |
|
|---|
| Returns: |
|
|---|
| Raises: |
|
|---|
Source code in src/Process/Utils/Connector.py
def make_request_next(self, next_page=None) :
"""
Effectue une requête GET sécurisée avec un token Bearer et des filtres.
Args:
next_page (str): : URL de la page next
Returns:
dict: La réponse JSON de l'API ou une erreur.
Raises:
requests.exceptions.RequestException: Si une erreur survient lors de la requête.
"""
api_url = next_page
header_config = self.config['header_config']
token_response = self.get_mtls_token()
if "error" in token_response:
return token_response
token = token_response.get('access_token')
header_config['Authorization'] = f'Bearer {token}'
try:
response = self.session.get(api_url, headers = header_config, params = None)
response.raise_for_status()
logger.info("GET request successful.")
return response
except requests.exceptions.RequestException as e:
logger.error(f"Erreur lors de la requête GET : {e}")
return {"error": str(e)}
request_all_pages(endpoint, request_filter=None, test_mode=False)
Parcours l'ensemble des pages d'un endpoint. Si test est True, ne récupère que les deux premières pages.
| Parameters: |
|
|---|
| Returns: |
|
|---|
Source code in src/Process/Utils/Connector.py
def request_all_pages(self, endpoint: Literal["HealthcareService", "Location", "Organization"], request_filter:str=None, test_mode: bool = False):
"""
Parcours l'ensemble des pages d'un endpoint. Si `test` est True, ne récupère que les deux premières pages.
Args:
endpoint (Literal["HealthcareService", "Location", "Organization"]): Le type d'entité pour la requête.
request_filter (dict, optional): Les filtres à appliquer. Par défaut, aucun filtre.
test (bool, optional): Si True, limite la récupération à deux pages. Par défaut, False.
Returns:
list: Liste contenant une page JSON pour chacun de ses éléments
int: Nombre de pages parcourues
"""
logger.info(f"Request of {endpoint} ")
page = 0
list_jsons = []
url_next = None
while True:
if page == 0: # Première page
logger.info(f"Récupération de la page {page + 1} (première page)")
# response = self.make_request_next(endpoint, next_page="https://api.ror.esante.gouv.fr/ws-diffusion-fhir?_getpages=d7c72717-6717-4bdb-97db-10df69765e42&_getpagesoffset=10000&_count=200&_bundletype=searchset")
# url_next = None
response = self.make_request(endpoint, request_filter=request_filter)
url_next = self.get_next_url(response)
elif url_next: # Deuxième -> Avant-dernière
logger.info(f"Récupération de la page {page + 1}")
response = self.make_request_next(next_page=url_next)
url_next = self.get_next_url(response)
else: # Dernière page
# logger.success(f"Pas de page suivante : fin de la boucle. Total des pages : {page}")
break
if response:
list_jsons.append(response.json())
page += 1
# Si test est True et que nous avons récupéré deux pages, on sort de la boucle
if test_mode and page >= 1:
logger.info("Mode test activé : récupération d'une page seulement.")
break
return list_jsons, page
setup_ssl_adapter()
Configure l'adaptateur SSL avec les paramètres fournis.
| Raises: |
|
|---|
Source code in src/Process/Utils/Connector.py
def setup_ssl_adapter(self):
"""
Configure l'adaptateur SSL avec les paramètres fournis.
Raises:
ValueError: Si la passphrase n'est pas définie dans les variables d'environnement.
"""
cert_file = self.config['cert_file']
key_file = self.config['key_file']
ca_cert = self.config['ca_cert']
passphrase = os.getenv("CERT_PASSPHRASE")
if not passphrase:
logger.error("La passphrase [CERT_PASSPHRASE] n'est pas définie dans les variables d'environnement.")
raise ValueError("Passphrase manquante dans l'environnement.")
adapter = SSLAdapter(cert_file, key_file, passphrase, ca_cert)
self.session.mount('https://', adapter)
SSLAdapter
Bases: HTTPAdapter
Adaptateur personnalisé pour ajouter un certificat avec passphrase.
| Attributes: |
|
|---|
Source code in src/Process/Utils/Connector.py
class SSLAdapter(HTTPAdapter):
"""
Adaptateur personnalisé pour ajouter un certificat avec passphrase.
Attributes:
cert_file (str): Chemin du fichier de certificat.
key_file (str): Chemin de la clé privée.
passphrase (str): Passphrase pour le certificat.
ca_cert (str): Chemin du certificat de l'autorité de certification.
"""
def __init__(self, cert_file, key_file, passphrase, ca_cert):
"""
Initialise l'adaptateur SSL avec les paramètres fournis.
Args:
cert_file (str): Chemin du fichier de certificat.
key_file (str): Chemin de la clé privée.
passphrase (str): Passphrase pour le certificat.
ca_cert (str): Chemin du certificat de l'autorité de certification.
"""
self.cert_file = cert_file
self.key_file = key_file
self.passphrase = passphrase
self.ca_cert = ca_cert
super().__init__()
def init_poolmanager(self, *args, **kwargs):
"""
Personnalise le gestionnaire de pool pour charger le certificat avec passphrase.
Returns:
urllib3.PoolManager: Le gestionnaire de pool configuré.
"""
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(certfile=self.cert_file, keyfile=self.key_file, password=self.passphrase)
context.load_verify_locations(cafile=self.ca_cert)
kwargs['ssl_context'] = context
return super().init_poolmanager(*args, **kwargs)
Functions
__init__(cert_file, key_file, passphrase, ca_cert)
Initialise l'adaptateur SSL avec les paramètres fournis.
| Parameters: |
|
|---|
Source code in src/Process/Utils/Connector.py
def __init__(self, cert_file, key_file, passphrase, ca_cert):
"""
Initialise l'adaptateur SSL avec les paramètres fournis.
Args:
cert_file (str): Chemin du fichier de certificat.
key_file (str): Chemin de la clé privée.
passphrase (str): Passphrase pour le certificat.
ca_cert (str): Chemin du certificat de l'autorité de certification.
"""
self.cert_file = cert_file
self.key_file = key_file
self.passphrase = passphrase
self.ca_cert = ca_cert
super().__init__()
init_poolmanager(*args, **kwargs)
Personnalise le gestionnaire de pool pour charger le certificat avec passphrase.
| Returns: |
|
|---|
Source code in src/Process/Utils/Connector.py
def init_poolmanager(self, *args, **kwargs):
"""
Personnalise le gestionnaire de pool pour charger le certificat avec passphrase.
Returns:
urllib3.PoolManager: Le gestionnaire de pool configuré.
"""
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(certfile=self.cert_file, keyfile=self.key_file, password=self.passphrase)
context.load_verify_locations(cafile=self.ca_cert)
kwargs['ssl_context'] = context
return super().init_poolmanager(*args, **kwargs)
Functions
convert_to_list(value)
Convertit une chaîne de caractères en liste.
| Parameters: |
|
|---|
| Returns: |
|
|---|
Source code in src/Process/Utils/Connector.py
def convert_to_list(value):
"""
Convertit une chaîne de caractères en liste.
Args:
value (str): La valeur à convertir.
Returns:
List[str]: Une liste de chaînes de caractères.
"""
if pd.isna(value): # Vérifie si la valeur est NaN
return []
else:
return literal_eval(value)
generate_request_filter()
Génère des filtres de requête à partir d'un fichier de mapping d'API.
Cette fonction lit un fichier CSV contenant des informations de mapping d'API, puis génère des filtres de requête basés sur les codes et les âges spécifiés.
| Returns: |
|
|---|
Source code in src/Process/Utils/Connector.py
def generate_request_filter() -> Tuple[List[str], List[str]]:
"""
Génère des filtres de requête à partir d'un fichier de mapping d'API.
Cette fonction lit un fichier CSV contenant des informations de mapping d'API,
puis génère des filtres de requête basés sur les codes et les âges spécifiés.
Returns:
Tuple[List[str], List[str]]: Un tuple contenant deux listes :
- La première liste contient les regroupements.
- La seconde liste contient les filtres générés.
"""
# current_dir = os.path.dirname(os.path.abspath(__file__))
# current_dir = Path(current_dir)
# api_mapping_file = current_dir.parent.absolute() / "Metadata" / "mapping_regroupement.csv"
# logger.info("Mapping api file succefully readed")
STATIC_CONDITION = {
"> =": "age-range-high ge",
"< =": "age-range-high le",
">": "age-range-high gt",
"<": "age-range-high lt",
}
df = load_mapping_file("mapping_regroupement.csv")
df["Code"] = df["Code"].apply(convert_to_list)
df["Exclusion_OA"] = df["Exclusion_OA"].apply(convert_to_list)
df["filter"] = None
# if df["filter"].dtype != object:
# df["filter"] = df["filter"].astype(object)
for i in df.index:
age = df["Age_Max"][i]
codes = df["Code"][i]
if codes:
c_0 = codes[0]
filter = f"((specialty eq https://mos.esante.gouv.fr/NOS/TRE_R211-ActiviteOperationnelle/FHIR/TRE-R211-ActiviteOperationnelle|{c_0})"
for c in codes[1:]:
if "] et" in df["Activite_operationnelle"][i]:
filter = (
filter
+ f" and (specialty eq https://mos.esante.gouv.fr/NOS/TRE_R211-ActiviteOperationnelle/FHIR/TRE-R211-ActiviteOperationnelle|{c})"
)
else:
filter = (
filter
+ f" or (specialty eq https://mos.esante.gouv.fr/NOS/TRE_R211-ActiviteOperationnelle/FHIR/TRE-R211-ActiviteOperationnelle|{c})"
)
if age != "-":
symbole = age.split("18")[0].strip()
condition = reduce(
lambda t, k: t.replace(k, STATIC_CONDITION[k]),
STATIC_CONDITION,
symbole,
)
condition += " 18"
filter = (
filter + f" and ({condition}|https://unitsofmeasure.org|a))"
)
else:
filter = filter + ")"
df.loc[i, "filter"] = filter
return df
load_mapping_file(file_name)
Charge un fichier de mapping depuis le répertoire Metadata.
Cette fonction charge un fichier CSV de mapping en utilisant le chemin relatif depuis l'emplacement du script courant. Le fichier doit être situé dans le dossier 'Metadata' parent.
Paramètres
file_name : str Nom du fichier de mapping à charger (doit être un fichier CSV)
Retourne
pandas.DataFrame DataFrame contenant les données du fichier de mapping
Lève
FileNotFoundError Si le fichier spécifié n'existe pas dans le répertoire Metadata pd.errors.EmptyDataError Si le fichier est vide Exception Pour toute autre erreur lors du chargement du fichier
Notes
- Le fichier CSV doit utiliser le point-virgule (;) comme séparateur
- Le chemin du fichier est construit de manière relative à partir de l'emplacement du script
Exemple
df = load_mapping_file("mapping_categories.csv") print(df.shape) (100, 4)
Source code in src/Process/Utils/Connector.py
def load_mapping_file(file_name:str):
"""
Charge un fichier de mapping depuis le répertoire Metadata.
Cette fonction charge un fichier CSV de mapping en utilisant le chemin relatif
depuis l'emplacement du script courant. Le fichier doit être situé dans le
dossier 'Metadata' parent.
Paramètres
----------
file_name : str
Nom du fichier de mapping à charger (doit être un fichier CSV)
Retourne
-------
pandas.DataFrame
DataFrame contenant les données du fichier de mapping
Lève
-----
FileNotFoundError
Si le fichier spécifié n'existe pas dans le répertoire Metadata
pd.errors.EmptyDataError
Si le fichier est vide
Exception
Pour toute autre erreur lors du chargement du fichier
Notes
-----
- Le fichier CSV doit utiliser le point-virgule (;) comme séparateur
- Le chemin du fichier est construit de manière relative à partir de l'emplacement du script
Exemple
-------
>>> df = load_mapping_file("mapping_categories.csv")
>>> print(df.shape)
(100, 4)
"""
try:
current_dir = os.path.dirname(os.path.abspath(__file__))
current_dir = Path(current_dir)
api_mapping_file = current_dir.parent.absolute() / "Metadata" / file_name
mapping_df = pd.read_csv(api_mapping_file, sep=";")
logger.info("Mapping api file succefully readed")
return mapping_df
except Exception as e:
logger.error(f"Erreur lors du chargement du fichier de configuration : {e}")
raise