Upload folder using huggingface_hub

app/database.py

@@ -1,3 +1,5 @@
+
+
 import os
 from dotenv import load_dotenv
 from sqlalchemy import create_engine
@@ -12,6 +14,8 @@ RUNNING_TESTS = os.getenv("ENV") == "test"
 if RUNNING_IN_HF or RUNNING_TESTS:
     # Use SQLite for HuggingFace and for tests
     DATABASE_URL = "sqlite:///./futurisys.db"
+    print("DATABASE_URL =", DATABASE_URL)
+
 else:
     # Normal PostgreSQL configuration
     DB_USER = os.getenv("DB_USER")
@@ -31,3 +35,4 @@ engine = create_engine(
 
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 Base = declarative_base()
+

app/main.py

@@ -1,13 +1,17 @@
 # app/main.py
+
 from fastapi import FastAPI
 from pydantic import BaseModel
 from typing import Literal
 import pandas as pd
 from joblib import load
 from app.database import Base, engine, SessionLocal
-from app.models import Input, Output
+from app.models import Input, Output, Employe
 import datetime
 from app.feature_engineering import transform_fe
+from fastapi import Query
+
+from app.database import DATABASE_URL
 
 
 # Création automatique des tables
@@ -60,12 +64,14 @@ class PredictionRawData(BaseModel):
 
 app = FastAPI(title="API Futurisys")
 
+
+
 @app.get("/")
 def read_root():
     return {
         "message": "Bienvenue dans l'API Futurisys",
         "documentation": "/docs",
-        "info": "Accedez au Swagger : https://huggingface.co/spaces/PCelia/futurisys-api"
+        "info": "Accedez au Swagger : https://pcelia-futurisys-api.hf.space/docs"
         
     }
 
@@ -88,10 +94,10 @@ def predict(data: PredictionRawData):
     proba = pipeline.predict_proba(df)[0][1]
     pred = bool(proba >= threshold)
 
-    # --- Enregistrement dans la DB ---
+    # Enregistrement dans la DB 
     db = SessionLocal()
 
-    # 1) Input
+    # Input
 
     new_input = Input(
     timestamp_input=datetime.datetime.now(),
@@ -102,18 +108,81 @@ def predict(data: PredictionRawData):
     db.commit()
     db.refresh(new_input)
 
-    # 2) Output
+    # Output
     new_output = Output(
         id_input = new_input.id_input,
         prediction = int(pred),
-        probability = float(proba)
+        probabilite = float(proba)
+
     )
     db.add(new_output)
     db.commit()
-    # --- FIN enregistrement ---
+    #  FIN enregistrement 
 
     return {
         "probabilité": round(float(proba), 3),
         "prédiction": pred
     }
+from sqlalchemy import text
+
+@app.get("/test_ids")
+def test_ids():
+    db = SessionLocal()
+    from sqlalchemy import text
+    result = db.execute(text("SELECT employee_id FROM employes LIMIT 20;")).fetchall()
+    return {"ids": result}
+
+
 
+import traceback
+
+
+@app.post("/predict_from_db_employe")
+def predict_from_db_employe(
+    employee_id: int = Query(..., ge=1)
+):
+    try:
+        db = SessionLocal()
+
+        employe = db.query(Employe).filter(Employe.employee_id == employee_id).first()
+        if not employe:
+            return {"message": f"Aucun employé trouvé avec l'id {employee_id}"}
+
+        data = employe.__dict__.copy()
+        data.pop("_sa_instance_state", None)
+
+        df = pd.DataFrame([data])
+        df = transform_fe(df)
+
+        proba = pipeline.predict_proba(df)[0][1]
+        pred = proba >= threshold
+
+        new_input = Input(
+            timestamp_input=datetime.datetime.now(),
+            employee_id=employee_id,
+            age=employe.age
+        )
+        db.add(new_input)
+        db.commit()
+        db.refresh(new_input)
+
+        new_output = Output(
+            id_input=new_input.id_input,
+            prediction=int(pred),
+            probabilite=float(proba)
+
+        )
+        db.add(new_output)
+        db.commit()
+
+        return {
+            "params": data,
+            "probabilité": round(float(proba), 3),
+            "prédiction": bool(pred)
+
+        }
+
+    except Exception as e:
+        print("ERROR PREDICT_FROM_DB:", e)
+        traceback.print_exc()
+        return {"error": str(e)}

app/models.py

@@ -17,6 +17,39 @@ class Output(Base):
     id_output = Column(Integer, primary_key=True, index=True)
     id_input = Column(Integer, ForeignKey("inputs.id_input"))
     prediction = Column(Integer)
-    probability = Column(Float)
+    probabilite = Column("probabilite", Float)
+
 
     input = relationship("Input", back_populates="outputs")
+
+class Employe(Base):
+    __tablename__ = "employes"
+
+    employee_id = Column(Integer, primary_key=True)
+
+
+
+    age = Column(Integer)
+    revenu_mensuel = Column(Float)
+    statut_marital = Column(String)
+    departement = Column(String)
+    poste = Column(String)
+
+    annee_experience_totale = Column(Integer)
+    annees_dans_l_entreprise = Column(Integer)
+    annees_dans_le_poste_actuel = Column(Integer)
+
+    satisfaction_employee_environnement = Column(Integer)
+    note_evaluation_precedente = Column(Float)
+    satisfaction_employee_nature_travail = Column(Integer)
+    satisfaction_employee_equipe = Column(Integer)
+    satisfaction_employee_equilibre_pro_perso = Column(Integer)
+    note_evaluation_actuelle = Column(Float)
+
+    heure_supplementaires = Column(String)
+    augementation_salaire_precedente = Column(Float)
+    nombre_participation_pee = Column(Integer)
+    frequence_deplacement = Column(String)
+
+    annes_sous_responsable_actuel = Column(Integer)
+