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:
  • env (Literal['recette', 'production']) –

    L'environnement cible (recette ou production).

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:
  • 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/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:
  • env (Literal['recette', 'production']) –

    L'environnement cible (recette ou production).

  • config (dict) –

    La configuration chargée depuis un fichier YAML.

  • session (Session) –

    Session HTTP configurée avec un adaptateur SSL.

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:
  • env (Literal['recette', 'production']) –

    L'environnement cible (recette ou production).

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:
  • dict –

    La réponse contenant le token ou une erreur.

Raises:
  • RequestException –

    Si une erreur survient lors de la requête.

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:
  • response (dict) –

    La réponse JSON de l'API.

Returns:
  • str( Union[str, None] ) –

    Lien de la page suivante (next), None si pas de lien

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:
  • 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/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:
  • endpoint (str) –

    : Le type d'entité pour la requête.

  • request_filter (dict) –

    Les filtres à appliquer. Par défaut, aucun filtre.

Returns:
  • dict –

    La réponse JSON de l'API ou une erreur.

Raises:
  • RequestException –

    Si une erreur survient lors de la requête.

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:
  • next_page (str, default: None ) –

    : URL de la page next

Returns:
  • dict –

    La réponse JSON de l'API ou une erreur.

Raises:
  • RequestException –

    Si une erreur survient lors de la requête.

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:
  • endpoint (Literal['HealthcareService', 'Location', 'Organization']) –

    Le type d'entité pour la requête.

  • request_filter (dict, default: None ) –

    Les filtres à appliquer. Par défaut, aucun filtre.

  • test (bool) –

    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

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:
  • ValueError –

    Si la passphrase n'est pas définie dans les variables d'environnement.

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:
  • 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.

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:
  • 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.

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:
  • –

    urllib3.PoolManager: Le gestionnaire de pool configuré.

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:
  • value (str) –

    La valeur à convertir.

Returns:
  • –

    List[str]: Une liste de chaînes de caractères.

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:
  • Tuple[List[str], List[str]] –

    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.

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