Upload folder using huggingface_hub

.dockerignore

@@ -9,6 +9,7 @@ tests/
 *.md
 *.txt
 notebooks/
+data/
 .env
 *.csv
 .gitignore

README.md

@@ -186,7 +186,7 @@ Response:
 - [x] CI/CD pipeline with GitLab
 - [x] Automated deployment to Hugging Face Spaces
 - [x] Test coverage reporting with pytest-cov and Cobertura
-- [ ] Add a database layer (Alembic + SQLAlchemy) for logging predictions
+- [x] Add a database layer (Alembic + SQLAlchemy) for logging predictions
 - [ ] Add a Gradio or Streamlit user interface for non-technical users
 - [ ] Implement model versioning and A/B testing
 

pyproject.toml

@@ -12,6 +12,7 @@ dependencies = [
     "joblib==1.5.3",
     "numpy==2.3.5",
     "pandas==2.3.3",
+    "psycopg2-binary==2.9.12",
     "pydantic==2.12.5",
     "scikit-learn==1.8.0",
     "sqlalchemy==2.0.46",

src/api/main.py

@@ -8,13 +8,25 @@ Contenu:
 - Point d'entrée de l'application
 """
 
+import logging
+
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import Response
 
 from src.api.schemas import DonneesEmploye, ResultatPrediction
+from src.db.logger_db import (
+    log_api_operation,
+    log_prediction_input,
+    log_prediction_output,
+)
 from src.utils.model_loader import get_modele
 from src.utils.transformer import transformer_donnees
 
+# CONFIGURATION DU LOGGER
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
 # APPLICATION FASTAPI
 
 tags_metadata = [
@@ -145,6 +157,22 @@ def predire(employe: DonneesEmploye):
     """
     donnees = employe.model_dump(exclude_none=True)
     resultat = predire_churn(donnees)
+
+    # Logging dans la base de données (optionnel, ne bloque pas l'API)
+    input_id = log_prediction_input(donnees)
+    log_prediction_output(
+        input_id=input_id,
+        prediction=resultat["prediction"],
+        probabilite=resultat["probabilite"],
+        classe=resultat["classe"],
+    )
+    log_api_operation(
+        operation="PREDICT",
+        table_cible="prediction_inputs",
+        details=f"id_employee={donnees.get('id_employee')}, prediction={resultat['prediction']}",
+        statut="SUCCESS",
+    )
+
     return ResultatPrediction(**resultat)
 
 

src/api/schemas.py

@@ -21,13 +21,15 @@ class DonneesEmploye(BaseModel):
 
     # INFORMATIONS PERSONNELLES
 
+    id_employee: int = Field(..., ge=1, description="ID unique de l'employé")
+
     age: int = Field(
         ..., ge=18, le=65, description="Âge de l'employé (entre 18 et 65 ans)"
     )
 
     genre: Literal["M", "F"] = Field(..., description="Genre: M=Homme, F=Femme")
 
-    revenu_mensuel: float = Field(
+    revenu_mensuel: int = Field(
         ..., gt=0, lt=20000, description="Salaire mensuel en euros"
     )
 

src/db/create_db.py

@@ -0,0 +1,181 @@
+"""
+Script de création de la base de données PostgreSQL et d'insertion du dataset.
+"""
+
+from pathlib import Path
+
+import pandas as pd
+from sqlalchemy.exc import IntegrityError
+
+from src.db.database import SessionLocal, engine
+from src.db.models import Base, Employee
+
+
+def racine_projet() -> Path:
+    """Remonte l'arborescence jusqu'à trouver la racine du projet."""
+    courant = Path(__file__).resolve()
+    for parent in courant.parents:
+        if (parent / "pyproject.toml").exists():
+            return parent
+    raise FileNotFoundError("Racine du projet non trouvée")
+
+
+PROJECT_ROOT = racine_projet()
+RAW_DIR = PROJECT_ROOT / "data" / "raw"
+PROCESSED_DIR = PROJECT_ROOT / "data" / "processed"
+
+CSV_SIRH = RAW_DIR / "extrait_sirh.csv"
+CSV_EVAL = RAW_DIR / "extrait_eval.csv"
+CSV_SONDAGE = RAW_DIR / "extrait_sondage.csv"
+CSV_EMPLOYES = PROCESSED_DIR / "employees.csv"
+
+COLONNES_EMPLOYEES = [
+    "id_employee",
+    "age",
+    "genre",
+    "revenu_mensuel",
+    "statut_marital",
+    "departement",
+    "poste",
+    "annee_experience_totale",
+    "annees_dans_l_entreprise",
+    "satisfaction_employee_environnement",
+    "note_evaluation_precedente",
+    "satisfaction_employee_nature_travail",
+    "satisfaction_employee_equipe",
+    "satisfaction_employee_equilibre_pro_perso",
+    "note_evaluation_actuelle",
+    "heure_supplementaires",
+    "augementation_salaire_precedente",
+    "nombre_participation_pee",
+    "nb_formations_suivies",
+    "distance_domicile_travail",
+    "niveau_education",
+    "frequence_deplacement",
+    "annees_depuis_la_derniere_promotion",
+    "a_quitte_l_entreprise",
+]
+
+
+def fusionner_csv() -> pd.DataFrame:
+    """
+    Charge les 3 CSV et les fusionne sur la colonne id_employee.
+
+    Reproduit les étapes du notebook :
+    1. Renomme eval_number en id_employee dans df_eval
+    2. Retire le préfixe 'E_' et convertit en int
+    3. Renomme code_sondage en id_employee dans df_sondage
+    4. Inner merge des 3 DataFrames
+
+    Returns:
+        DataFrame fusionné (32 colonnes, 1470 lignes)
+    """
+    df_sirh = pd.read_csv(CSV_SIRH)
+    df_eval = pd.read_csv(CSV_EVAL)
+    df_sondage = pd.read_csv(CSV_SONDAGE)
+
+    df_eval = df_eval.rename(columns={"eval_number": "id_employee"})
+    df_eval["id_employee"] = df_eval["id_employee"].str[2:].astype("int64")
+
+    df_sondage = df_sondage.rename(columns={"code_sondage": "id_employee"})
+
+    df_central = pd.merge(df_sirh, df_eval, on="id_employee", how="inner")
+    df_central = pd.merge(df_central, df_sondage, on="id_employee", how="inner")
+
+    print(
+        f"DataFrame fusionné : {df_central.shape[0]} lignes, {df_central.shape[1]} colonnes"
+    )
+    return df_central
+
+
+def nettoyer_dataframe(df_central: pd.DataFrame) -> pd.DataFrame:
+    """
+    Nettoie le DataFrame fusionné pour ne garder que les colonnes utilisées par le modèle.
+
+    Étapes :
+    1. Retire le '%' de augementation_salaire_precedente et convertit en int
+    2. Sélectionne uniquement les 23 colonnes du modèle
+
+    Args:
+        df_central: DataFrame fusionné (32 colonnes)
+
+    Returns:
+        DataFrame nettoyé (23 colonnes)
+    """
+    df_central["augementation_salaire_precedente"] = (
+        df_central["augementation_salaire_precedente"].str[:-2].astype("int64")
+    )
+
+    df_employees = df_central.loc[:, COLONNES_EMPLOYEES].copy()
+
+    print(
+        f"DataFrame nettoyé : {df_employees.shape[0]} lignes, {df_employees.shape[1]} colonnes"
+    )
+    return df_employees
+
+
+def sauvegarder_csv(df_employees: pd.DataFrame) -> None:
+    """
+    Sauvegarde le DataFrame nettoyé au format CSV.
+
+    Args:
+        df_employees: DataFrame nettoyé (23 colonnes)
+    """
+    PROCESSED_DIR.mkdir(parents=True, exist_ok=True)
+    df_employees.to_csv(CSV_EMPLOYES, index=False)
+    print(f"CSV sauvegardé : {CSV_EMPLOYES}")
+
+
+def creer_tables() -> None:
+    """Crée les tables dans PostgreSQL à partir des modèles ORM."""
+    Base.metadata.create_all(engine)
+    print("Tables créées avec succès")
+
+
+def inserer_donnees(df_employees: pd.DataFrame) -> None:
+    """
+    Insère les données du DataFrame dans la table employees.
+
+    Args:
+        df_employees: DataFrame nettoyé (23 colonnes, 1470 lignes)
+    """
+    session = SessionLocal()
+    try:
+        employees = [Employee(**row.to_dict()) for _, row in df_employees.iterrows()]
+        session.add_all(employees)
+        session.commit()
+        print(f"{len(employees)} employés insérés avec succès")
+    except IntegrityError as e:
+        session.rollback()
+        print(f"Erreur d'intégrité : {e}")
+        print("Les données existent peut-être déjà. Vider la table avant de réinsérer.")
+    except Exception as e:
+        session.rollback()
+        print(f"Erreur lors de l'insertion : {e}")
+    finally:
+        session.close()
+
+
+def main() -> None:
+    """Point d'entrée principal du script."""
+
+    # 1. Chargement et fusion des CSV
+    df_central = fusionner_csv()
+
+    # 2. Nettoyage du DataFrame"
+    df_employees = nettoyer_dataframe(df_central)
+
+    # 3. Sauvegarde du CSV nettoyé
+    sauvegarder_csv(df_employees)
+
+    # 4. Création des tables
+    creer_tables()
+
+    # 5. Insertion des données
+    inserer_donnees(df_employees)
+
+    print("Base de données créée avec succès")
+
+
+if __name__ == "__main__":
+    main()

src/db/database.py

@@ -0,0 +1,60 @@
+"""
+Configuration de la connexion à la base de données PostgreSQL.
+Utilise SQLAlchemy comme ORM et lit l'URL depuis le fichier .env.
+
+Si DATABASE_URL n'est pas définie (ex: conteneur Docker sans PostgreSQL),
+le module ne génère pas d'erreur. Les fonctions de logging détecteront
+l'absence de DB et fonctionneront en mode dégradé.
+"""
+
+import logging
+import os
+
+from dotenv import load_dotenv
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
+
+logger = logging.getLogger(__name__)
+
+# Charge les variables d'environnement depuis le fichier .env
+load_dotenv()
+
+# URL de connexion à la base de données
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+if DATABASE_URL is None:
+    logger.warning(
+        "DATABASE_URL n'est pas définie. "
+        "La base de données ne sera pas disponible. "
+        "L'API fonctionnera sans logging en base de données."
+    )
+    engine = None
+    SessionLocal = None
+else:
+    # Engine SQLAlchemy = connexion vers PostgreSQL
+    engine = create_engine(DATABASE_URL)
+    # SessionLocal = fabrique de sessions (une session = une transaction DB)
+    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+# Base = classe de base pour tous les modèles ORM
+class Base(DeclarativeBase):
+    pass
+
+
+def get_db():
+    """
+    Générateur qui fournit une session de base de données.
+
+    Yields:
+        Session SQLAlchemy ou None si la DB n'est pas configurée
+    """
+    if SessionLocal is None:
+        yield None
+        return
+
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

src/db/logger_db.py

@@ -0,0 +1,180 @@
+"""
+Module de logging des prédictions dans la base de données PostgreSQL.
+
+Si la base de données n'est pas disponible (ex: conteneur Docker sans PostgreSQL),
+les fonctions ne lèvent pas d'erreur et laissent un avertissement dans les logs.
+"""
+
+import logging
+import os
+
+from dotenv import load_dotenv
+
+logger = logging.getLogger(__name__)
+
+# Vérifie si la DB est configurée
+load_dotenv()
+DATABASE_URL = os.getenv("DATABASE_URL")
+DB_AVAILABLE = DATABASE_URL is not None
+
+
+def _get_session():
+    """
+    Ouvre une session SQLAlchemy si la DB est disponible.
+
+    Returns:
+        Session SQLAlchemy ou None si la DB n'est pas configurée
+    """
+    if not DB_AVAILABLE:
+        return None
+
+    try:
+        from src.db.database import SessionLocal
+
+        return SessionLocal()
+    except Exception as e:
+        logger.warning(f"Impossible de se connecter à la base de données : {e}")
+        return None
+
+
+def log_prediction_input(donnees: dict) -> int | None:
+    """
+    Enregistre les données brutes d'un employé dans prediction_inputs.
+
+    Args:
+        donnees: Dict avec les données de l'employé (validées par Pydantic)
+
+    Returns:
+        ID de l'input inséré, ou None si la DB n'est pas disponible
+    """
+    if not DB_AVAILABLE:
+        logger.info("DB non configurée : log_prediction_input ignoré")
+        return None
+
+    try:
+        from src.db.models import PredictionInput
+    except Exception:
+        logger.warning("Impossible d'importer les modèles DB")
+        return None
+
+    session = _get_session()
+    if session is None:
+        return None
+
+    try:
+        prediction_input = PredictionInput(**donnees)
+        session.add(prediction_input)
+        session.commit()
+        session.refresh(prediction_input)
+        input_id: int = prediction_input.id  # type: ignore[assignment]
+        logger.info(f"Input inséré en DB (id={input_id})")
+        return input_id
+    except Exception as e:
+        session.rollback()
+        logger.warning(f"Erreur lors de l'insertion input : {e}")
+        return None
+    finally:
+        session.close()
+
+
+def log_prediction_output(
+    input_id: int | None, prediction: str, probabilite: float, classe: int
+) -> bool:
+    """
+    Enregistre le résultat d'une prédiction dans prediction_outputs.
+
+    Args:
+        input_id: ID de l'input dans prediction_inputs
+        prediction: "Oui" ou "Non"
+        probabilite: Probabilité de départ (entre 0 et 1)
+        classe: 0 ou 1
+
+    Returns:
+        True si l'insertion a réussi, False sinon
+    """
+    if not DB_AVAILABLE or input_id is None:
+        logger.info(
+            "DB non configurée ou input_id manquant : log_prediction_output ignoré"
+        )
+        return False
+
+    try:
+        from src.db.models import PredictionOutput
+    except Exception:
+        logger.warning("Impossible d'importer les modèles DB")
+        return False
+
+    session = _get_session()
+    if session is None:
+        return False
+
+    try:
+        prediction_output = PredictionOutput(
+            input_id=input_id,
+            prediction=prediction,
+            probabilite=probabilite,
+            classe=classe,
+        )
+        session.add(prediction_output)
+        session.commit()
+        logger.info(f"Output inséré en DB (input_id={input_id})")
+        return True
+    except Exception as e:
+        session.rollback()
+        logger.warning(f"Erreur lors de l'insertion output : {e}")
+        return False
+    finally:
+        session.close()
+
+
+def log_api_operation(
+    operation: str,
+    table_cible: str,
+    details: str | None = None,
+    statut: str = "SUCCESS",
+) -> bool:
+    """
+    Enregistre une opération API dans api_logs.
+
+    Args:
+        operation: Type d'opération (ex: "INSERT", "SELECT")
+        table_cible: Table concernée (ex: "prediction_inputs")
+        details: Détails optionnels de l'opération
+        statut: "SUCCESS" ou "ERROR"
+
+    Returns:
+        True si l'insertion a réussi, False sinon
+    """
+    if not DB_AVAILABLE:
+        logger.info(
+            f"DB non configurée : log_api_operation ignoré ({operation} {table_cible})"
+        )
+        return False
+
+    try:
+        from src.db.models import ApiLog
+    except Exception:
+        logger.warning("Impossible d'importer les modèles DB")
+        return False
+
+    session = _get_session()
+    if session is None:
+        return False
+
+    try:
+        api_log = ApiLog(
+            operation=operation,
+            table_cible=table_cible,
+            details=details,
+            statut=statut,
+        )
+        session.add(api_log)
+        session.commit()
+        logger.info(f"Log API inséré : {operation} {table_cible} ({statut})")
+        return True
+    except Exception as e:
+        session.rollback()
+        logger.warning(f"Erreur lors de l'insertion log API : {e}")
+        return False
+    finally:
+        session.close()

src/db/models.py

@@ -0,0 +1,110 @@
+"""
+Modèles ORM SQLAlchemy pour la base de données PostgreSQL.
+
+Contient les 4 tables du schéma :
+- employees : dataset brut d'entraînement (1470 lignes)
+- prediction_inputs : données brutes envoyées à l'API
+- prediction_outputs : résultat de la prédiction
+- api_logs : traçabilité des échanges API ↔ DB
+"""
+
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Float, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+
+from src.db.database import Base
+
+
+class Employee(Base):
+    """Table du dataset brut (1470 employés)."""
+
+    __tablename__ = "employees"
+
+    id_employee = Column(Integer, primary_key=True)
+    age = Column(Integer, nullable=False)
+    genre = Column(String(1), nullable=False)
+    revenu_mensuel = Column(Integer, nullable=False)
+    statut_marital = Column(String(20), nullable=False)
+    departement = Column(String(20), nullable=False)
+    poste = Column(String(30), nullable=False)
+    annee_experience_totale = Column(Integer, nullable=False)
+    annees_dans_l_entreprise = Column(Integer, nullable=False)
+    satisfaction_employee_environnement = Column(Integer, nullable=False)
+    note_evaluation_precedente = Column(Integer, nullable=False)
+    satisfaction_employee_nature_travail = Column(Integer, nullable=False)
+    satisfaction_employee_equipe = Column(Integer, nullable=False)
+    satisfaction_employee_equilibre_pro_perso = Column(Integer, nullable=False)
+    note_evaluation_actuelle = Column(Integer, nullable=False)
+    heure_supplementaires = Column(String(5), nullable=False)
+    augementation_salaire_precedente = Column(Integer, nullable=False)
+    nombre_participation_pee = Column(Integer, nullable=False)
+    nb_formations_suivies = Column(Integer, nullable=False)
+    distance_domicile_travail = Column(Integer, nullable=False)
+    niveau_education = Column(Integer, nullable=False)
+    frequence_deplacement = Column(String(20), nullable=False)
+    annees_depuis_la_derniere_promotion = Column(Integer, nullable=False)
+    a_quitte_l_entreprise = Column(String(5), nullable=False)
+
+
+class PredictionInput(Base):
+    """Données brutes envoyées à l'API (avant transformation)."""
+
+    __tablename__ = "prediction_inputs"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    id_employee = Column(Integer, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    age = Column(Integer, nullable=False)
+    genre = Column(String(1), nullable=False)
+    revenu_mensuel = Column(Integer, nullable=False)
+    statut_marital = Column(String(20), nullable=False)
+    departement = Column(String(20), nullable=False)
+    poste = Column(String(30), nullable=False)
+    annee_experience_totale = Column(Integer, nullable=False)
+    annees_dans_l_entreprise = Column(Integer, nullable=False)
+    satisfaction_employee_environnement = Column(Integer, nullable=False)
+    note_evaluation_precedente = Column(Integer, nullable=False)
+    satisfaction_employee_nature_travail = Column(Integer, nullable=False)
+    satisfaction_employee_equipe = Column(Integer, nullable=False)
+    satisfaction_employee_equilibre_pro_perso = Column(Integer, nullable=False)
+    note_evaluation_actuelle = Column(Integer, nullable=False)
+    heure_supplementaires = Column(String(5), nullable=False)
+    augementation_salaire_precedente = Column(Integer, nullable=False)
+    nombre_participation_pee = Column(Integer, nullable=False)
+    nb_formations_suivies = Column(Integer, nullable=False)
+    distance_domicile_travail = Column(Integer, nullable=False)
+    niveau_education = Column(Integer, nullable=False)
+    frequence_deplacement = Column(String(20), nullable=False)
+    annees_depuis_la_derniere_promotion = Column(Integer, nullable=False)
+
+    output = relationship("PredictionOutput", back_populates="input", uselist=False)
+
+
+class PredictionOutput(Base):
+    """Résultat de la prédiction du modèle."""
+
+    __tablename__ = "prediction_outputs"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    input_id = Column(
+        Integer, ForeignKey("prediction_inputs.id"), nullable=False, unique=True
+    )
+    prediction = Column(String(5), nullable=False)
+    probabilite = Column(Float, nullable=False)
+    classe = Column(Integer, nullable=False)
+
+    input = relationship("PredictionInput", back_populates="output")
+
+
+class ApiLog(Base):
+    """Traçabilité des échanges entre l'API et la base de données."""
+
+    __tablename__ = "api_logs"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    operation = Column(String(30), nullable=False)
+    table_cible = Column(String(20), nullable=False)
+    details = Column(String(255), nullable=True)
+    statut = Column(String(10), nullable=False)

src/db/schema.md

@@ -0,0 +1,76 @@
+```mermaid
+erDiagram
+  employees {
+    int id_employee PK
+    int age
+    varchar genre
+    int revenu_mensuel
+    varchar statut_marital
+    varchar departement
+    varchar poste
+    int annee_experience_totale
+    int annees_dans_l_entreprise
+    int satisfaction_employee_environnement
+    int note_evaluation_precedente
+    int satisfaction_employee_nature_travail
+    int satisfaction_employee_equipe
+    int satisfaction_employee_equilibre_pro_perso
+    int note_evaluation_actuelle
+    varchar heure_supplementaires
+    int augementation_salaire_precedente
+    int nombre_participation_pee
+    int nb_formations_suivies
+    int distance_domicile_travail
+    int niveau_education
+    varchar frequence_deplacement
+    int annees_depuis_la_derniere_promotion
+    varchar a_quitte_l_entreprise
+  }
+    
+  prediction_inputs {
+    int id PK
+    timestamp created_at
+    int id_employee
+    int age
+    varchar genre
+    int revenu_mensuel
+    varchar statut_marital
+    varchar departement
+    varchar poste
+    int annee_experience_totale
+    int annees_dans_l_entreprise
+    int satisfaction_employee_environnement
+    int note_evaluation_precedente
+    int satisfaction_employee_nature_travail
+    int satisfaction_employee_equipe
+    int satisfaction_employee_equilibre_pro_perso
+    int note_evaluation_actuelle
+    varchar heure_supplementaires
+    int augementation_salaire_precedente
+    int nombre_participation_pee
+    int nb_formations_suivies
+    int distance_domicile_travail
+    int niveau_education
+    varchar frequence_deplacement
+    int annees_depuis_la_derniere_promotion
+  }
+
+  prediction_inputs ||--|| prediction_outputs : "1:1"
+  
+  prediction_outputs {
+    int id PK
+    int input_id FK
+    varchar prediction
+    float probabilite
+    int classe
+  }
+    
+  api_logs {
+    int id PK
+    timestamp created_at
+    varchar operation
+    varchar table_cible
+    varchar details
+    varchar statut
+  }
+```

src/utils/transformer.py

@@ -92,6 +92,9 @@ def transformer_donnees(donnees_employe: dict) -> pd.DataFrame:
     # Créer un DataFrame pandas
     df = pd.DataFrame([donnees_employe])
 
+    # Supprimer l'ID avant toute transformation (non utilisé par le modèle)
+    df = df.drop(columns=["id_employee"], errors="ignore")
+
     # ÉTAPE 1: CALCULS PRÉLIMINAIRES
     # Ces calculs utilisent les colonnes brutes avant suppression
 

uv.lock

@@ -2012,6 +2012,7 @@ dependencies = [
     { name = "joblib" },
     { name = "numpy" },
     { name = "pandas" },
+    { name = "psycopg2-binary" },
     { name = "pydantic" },
     { name = "scikit-learn" },
     { name = "sqlalchemy" },
@@ -2041,6 +2042,7 @@ requires-dist = [
     { name = "joblib", specifier = "==1.5.3" },
     { name = "numpy", specifier = "==2.3.5" },
     { name = "pandas", specifier = "==2.3.3" },
+    { name = "psycopg2-binary", specifier = "==2.9.12" },
     { name = "pydantic", specifier = "==2.12.5" },
     { name = "scikit-learn", specifier = "==1.8.0" },
     { name = "sqlalchemy", specifier = "==2.0.46" },
@@ -2308,6 +2310,47 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
 ]
 
+[[package]]
+name = "psycopg2-binary"
+version = "2.9.12"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/60/a3624f79acea344c16fbef3a94d28b89a8042ddfb8f3e4ca83f538671409/psycopg2_binary-2.9.12.tar.gz", hash = "sha256:5ac9444edc768c02a6b6a591f070b8aae28ff3a99be57560ac996001580f294c", size = 379686, upload-time = "2026-04-21T09:40:34.304Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/9f/ef4ef3c8e15083df90ca35265cfd1a081a2f0cc07bb229c6314c6af817f4/psycopg2_binary-2.9.12-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5cdc05117180c5fa9c40eea8ea559ce64d73824c39d928b7da9fb5f6a9392433", size = 3712459, upload-time = "2026-04-20T23:34:30.549Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/01/3dd14e46ba48c1e1a6ec58ee599fa1b5efa00c246d5046cd903d0eeb1af1/psycopg2_binary-2.9.12-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3227a3bc228c10d21011a99245edca923e4e8bf461857e869a507d9a41fe9f6", size = 3822936, upload-time = "2026-04-20T23:34:32.77Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/f7/0640e4901119d8a9f7a1784b927f494e2198e213ceb593753d1f2c8b1b30/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:995ce929eede89db6254b50827e2b7fd61e50d11f0b116b29fffe4a2e53c4580", size = 4578676, upload-time = "2026-04-20T23:34:35.18Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/55/44df3965b5f297c50cc0b1b594a31c67d6127a9d133045b8a66611b14dfb/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9fe06d93e72f1c048e731a2e3e7854a5bfaa58fc736068df90b352cefe66f03f", size = 4274917, upload-time = "2026-04-20T23:34:37.982Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/4b/74535248b1eac0c9336862e8617c765ac94dac76f9e25d7c4a79588c8907/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40e7b28b63aaf737cb3a1edc3a9bbc9a9f4ad3dcb7152e8c1130e4050eddcb7d", size = 5894843, upload-time = "2026-04-20T23:34:40.856Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/ba/f1bf8d2ae71868ad800b661099086ee52bc0f8d9f05be1acd8ebb06757cc/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:89d19a9f7899e8eb0656a2b3a08e0da04c720a06db6e0033eab5928aabe60fa9", size = 4110556, upload-time = "2026-04-20T23:34:44.016Z" },
+    { url = "https://files.pythonhosted.org/packages/45/46/c15706c338403b7c420bcc0c2905aad116cc064545686d8bf85f1999ea00/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:612b965daee295ae2da8f8218ce1d274645dc76ef3f1abf6a0a94fd57eff876d", size = 3655714, upload-time = "2026-04-20T23:34:46.233Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/7c/a2d5dc09b64a4564db242a0fe418fde7d33f6f8259dd2c5b9d7def00fb5a/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b9a339b79d37c1b45f3235265f07cdeb0cb5ad7acd2ac7720a5920989c17c24e", size = 3301154, upload-time = "2026-04-20T23:34:49.528Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/e8/cc8c9a4ce71461f9ec548d38cadc41dc184b34c73e6455450775a9334ccd/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:3471336e1acfd9c7fe507b8bad5af9317b6a89294f9eb37bd9a030bb7bebcdc6", size = 3048882, upload-time = "2026-04-20T23:34:51.86Z" },
+    { url = "https://files.pythonhosted.org/packages/19/6a/31e2296bc0787c5ab75d3d118e40b239db8151b5192b90b77c72bc9256e9/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7af18183109e23502c8b2ae7f6926c0882766f35b5175a4cd737ad825e4d7a1b", size = 3351298, upload-time = "2026-04-20T23:34:54.124Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/a8/75f4e3e11203b590150abed2cf7794b9c9c9f7eceddae955191138b44dde/psycopg2_binary-2.9.12-cp312-cp312-win_amd64.whl", hash = "sha256:398fcd4db988c7d7d3713e2b8e18939776fd3fb447052daae4f24fa39daede4c", size = 2757230, upload-time = "2026-04-20T23:34:56.242Z" },
+    { url = "https://files.pythonhosted.org/packages/91/bb/4608c96f970f6e0c56572e87027ef4404f709382a3503e9934526d7ba051/psycopg2_binary-2.9.12-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7c729a73c7b1b84de3582f73cdd27d905121dc2c531f3d9a3c32a3011033b965", size = 3712419, upload-time = "2026-04-20T23:34:58.754Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/af/48f76af9d50d61cf390f8cd657b503168b089e2e9298e48465d029fcc713/psycopg2_binary-2.9.12-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4413d0caef93c5cf50b96863df4c2efe8c269bf2267df353225595e7e15e8df7", size = 3822990, upload-time = "2026-04-20T23:35:00.821Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/df/aba0f99397cd811d32e06fc0cc781f1f3ce98bc0e729cb423925085d781a/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4dfcf8e45ebb0c663be34a3442f65e17311f3367089cd4e5e3a3e8e62c978777", size = 4578696, upload-time = "2026-04-20T23:35:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/eaa74021ac4e4d5c2f83d82fc6615a63f4fe6c94dc4e94c3990427053f67/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c41321a14dd74aceb6a9a643b9253a334521babfa763fa873e33d89cfa122fb5", size = 4274982, upload-time = "2026-04-20T23:35:05.583Z" },
+    { url = "https://files.pythonhosted.org/packages/35/ed/c25deff98bd26187ba48b3b250a3ffc3037c46c5b89362534a15d200e0db/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83946ba43979ebfdc99a3cd0ee775c89f221df026984ba19d46133d8d75d3cd9", size = 5894867, upload-time = "2026-04-20T23:35:07.902Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/8d0e21ca77373c6c9589e5c4528f6e8f0c08c62cafc76fb0bddb7a2cee22/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:411e85815652d13560fbe731878daa5d92378c4995a22302071890ec3397d019", size = 4110578, upload-time = "2026-04-20T23:35:10.149Z" },
+    { url = "https://files.pythonhosted.org/packages/00/fc/f481e2435bd8f742d0123309174aae4165160ad3ef17c1b99c3622c241d2/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c8ad4c08e00f7679559eaed7aff1edfffc60c086b976f93972f686384a95e2c", size = 3655816, upload-time = "2026-04-20T23:35:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/53/79/b9f46466bdbe9f239c96cde8be33c1aace4842f06013b47b730dc9759187/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:00814e40fa23c2b37ef0a1e3c749d89982c73a9cb5046137f0752a22d432e82f", size = 3301307, upload-time = "2026-04-20T23:35:15.029Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/19/7dc003b32fe35024df89b658104f7c8538a8b2dcbde7a4e746ce929742e7/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:98062447aebc20ed20add1f547a364fd0ef8933640d5372ff1873f8deb9b61be", size = 3048968, upload-time = "2026-04-20T23:35:16.757Z" },
+    { url = "https://files.pythonhosted.org/packages/91/58/2dbd7db5c604d45f4950d988506aae672a14126ec22998ced5021cbb76bb/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:66a7685d7e548f10fb4ce32fb01a7b7f4aa702134de92a292c7bd9e0d3dbd290", size = 3351369, upload-time = "2026-04-20T23:35:18.933Z" },
+    { url = "https://files.pythonhosted.org/packages/42/ee/dee8dcaad07f735824de3d6563bc67119fa6c28257b17977a8d624f02fab/psycopg2_binary-2.9.12-cp313-cp313-win_amd64.whl", hash = "sha256:b6937f5fe4e180aeee87de907a2fa982ded6f7f15d7218f78a083e4e1d68f2a0", size = 2757347, upload-time = "2026-04-20T23:35:21.283Z" },
+    { url = "https://files.pythonhosted.org/packages/13/1b/708c0dca874acfad6d65314271859899a79007686f3a1f74e82a2ed4b645/psycopg2_binary-2.9.12-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6f3b3de8a74ef8db215f22edffb19e32dc6fa41340456de7ec99efdc8a7b3ec2", size = 3712428, upload-time = "2026-04-20T23:35:23.453Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/39/ddbea9d4b4de6aca9431b6ed253f530f8a02d3b8f9bcfd0dbfe2b3de6fe4/psycopg2_binary-2.9.12-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1006fb62f0f0bc5ce256a832356c6262e91be43f5e4eb15b5eaf38079464caf2", size = 3823184, upload-time = "2026-04-20T23:35:25.92Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/a0/bc2fef74b106fa345567122a0659e6d94512ed7dc0131ec44c9e5aba3725/psycopg2_binary-2.9.12-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:840066105706cd2eb29b9a1c2329620056582a4bf3e8169dec5c447042d0869f", size = 4579157, upload-time = "2026-04-20T23:35:28.542Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d7/d4e3b2005d3de607ca4fbb0e8742e248056e52184a6b94ebda3c1c2c329b/psycopg2_binary-2.9.12-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:863f5d12241ebe1c76a72a04c2113b6dc905f90b9cef0e9be0efd994affd9354", size = 4274970, upload-time = "2026-04-20T23:35:30.418Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/42/c9853f8db3967fe08bcde11f53d53b85d351750cae726ce001cb68afa9c1/psycopg2_binary-2.9.12-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a99eaab34a9010f1a086b126de467466620a750634d114d20455f3a824aae033", size = 5895175, upload-time = "2026-04-20T23:35:33.584Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/fd/b82b5601a97630308bef079f545ffec481bbbc795c2ba5ec416a01d03f60/psycopg2_binary-2.9.12-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ffdd7dc5463ccd61845ac37b7012d0f35a1548df9febe14f8dd549be4a0bc81e", size = 4110658, upload-time = "2026-04-20T23:35:35.638Z" },
+    { url = "https://files.pythonhosted.org/packages/62/8c/32ca69b0389ef25dd22937bf9e8fbe2ce27aea20b05ded48c4ce4cb42475/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:54a0dfecab1b48731f934e06139dfe11e24219fb6d0ceb32177cf0375f14c7b5", size = 3656251, upload-time = "2026-04-20T23:35:37.854Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/29/96992a2b59e3b9d730fcf9612d0a387305025dc867a9fc490a9e496e074e/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:96937c9c5d891f772430f418a7a8b4691a90c3e6b93cf72b5bd7cad8cbca32a5", size = 3301810, upload-time = "2026-04-20T23:35:39.927Z" },
+    { url = "https://files.pythonhosted.org/packages/56/ad/44b06659949b243ae10112cd3b20a197f9bf3e81d5651379b9eb889bfaad/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:77b348775efd4cdab410ec6609d81ccecd1139c90265fa583a7255c8064bc03d", size = 3048977, upload-time = "2026-04-20T23:35:41.806Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/f2/10a1bcebadb6aa55e280e1f58975c36a7b560ea525184c7aa4064c466633/psycopg2_binary-2.9.12-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:527e6342b3e44c2f0544f6b8e927d60de7f163f5723b8f1dfa7d2a84298738cd", size = 3351466, upload-time = "2026-04-20T23:35:43.993Z" },
+    { url = "https://files.pythonhosted.org/packages/20/be/b732c8418ffa5bcfda002890f5dc4c869fc17db66ff11f53b17cfe44afc0/psycopg2_binary-2.9.12-cp314-cp314-win_amd64.whl", hash = "sha256:f12ae41fcafadb39b2785e64a40f9db05d6de2ac114077457e0e7c597f3af980", size = 2848762, upload-time = "2026-04-20T23:35:46.421Z" },
+]
+
 [[package]]
 name = "ptyprocess"
 version = "0.7.0"