Update main.py

main.py

@@ -1,24 +1,35 @@
-import tempfile
+import logging
+import sys
 import os
 import json
+import tempfile
+from datetime import datetime
+
+# CORRECTION : Assurez-vous que 'Request' est bien présent dans cette ligne d'import
 from fastapi import FastAPI, Request, HTTPException, UploadFile, File, BackgroundTasks
+from fastapi.responses import JSONResponse
 from fastapi.concurrency import run_in_threadpool
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Optional
+from bson import ObjectId
 
+# --- Imports de vos services et classes ---
 from src.models import load_all_models
 from src.services.cv_service import CVParsingService
-from src.services.interview_service import InterviewProcessor
 from src.services.analysis_service import AnalysisService
-from services.graph_service import GraphInterviewProcessor 
-from fastapi.responses import JSONResponse
-from bson import ObjectId
+from services.graph_service import GraphInterviewProcessor
+
+# --- Configuration du logging ---
+logging.basicConfig(level=logging.INFO)
+# Le logger global est utilisé pour les messages au démarrage de l'application.
+logger = logging.getLogger(__name__)
 
-os.environ['HOME'] = '/tmp'
+# --- Configuration de l'environnement pour les fichiers temporaires ---
 os.makedirs('/tmp/feedbacks', exist_ok=True)
 
 
+# --- Initialisation de l'application FastAPI ---
 app = FastAPI(
     title="AIrh Interview Assistant",
     description="API pour l'analyse de CV et la simulation d'entretiens d'embauche avec analyse asynchrone.",
@@ -35,67 +46,46 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# --- Initialisation des services ---
+logger.info("Chargement des modèles et initialisation des services...")
 models = load_all_models()
 cv_service = CVParsingService(models)
-analysis_service = AnalysisService(models)
-class InterviewRequest(BaseModel):
-    user_id: str = Field(..., example="user_12345")
-    job_offer_id: str = Field(..., example="job_offer_abcde")
-    cv_document: Dict[str, Any]
-    job_offer: Dict[str, Any]
-    messages: List[Dict[str, Any]]
-    conversation_history: List[Dict[str, Any]]
+logger.info("Services initialisés.")
 
+
+# --- Définition des modèles Pydantic ---
 class Feedback(BaseModel):
     status: str
     feedback_data: Optional[Dict[str, Any]] = None
 
 class HealthCheck(BaseModel):
     status: str = "ok"
-    services: Dict[str, bool] = Field(default_factory=dict)
-    message: str = "API AIrh fonctionnelle"
-
-def background_analysis_task(user_id: str, conversation_history: list, job_description: str):
-    feedback_path = f"/tmp/feedbacks/{user_id}.json"
-    
-    with open(feedback_path, "w", encoding="utf-8") as f:
-        json.dump({"status": "processing"}, f, ensure_ascii=False, indent=4)
-    
-    result = analysis_service.run_analysis(conversation_history, job_description)
-    
-    with open(feedback_path, "w", encoding="utf-8") as f:
-        json.dump({"status": "completed", "feedback_data": result}, f, ensure_ascii=False, indent=4)
 
+# --- Endpoint de santé ---
 @app.get("/", response_model=HealthCheck, tags=["Status"])
 async def health_check():
-    services = {
-        "models_loaded": models.get("status", False),
-        "cv_parsing": True,
-        "interview_simulation": True,
-        "scoring_engine": True
-    }
-    return HealthCheck(services=services)
-
-class MongoJSONEncoder(json.JSONEncoder):
-    def default(self, o):
-        if isinstance(o, ObjectId):
-            return str(o)
-        return super().default(o)
-
-
-@app.post("/simulate-interview/")
+    return HealthCheck()
+
+# --- Endpoint principal pour la simulation d'entretien ---
+@app.post("/api/v1/simulate-interview/")
 async def simulate_interview(request: Request):
     """
     Ce endpoint reçoit les données de l'entretien, instancie le processeur de graphe
     et lance la conversation.
     """
+    # CORRECTION : Récupérer l'instance du logger pour garantir sa disponibilité dans le scope de la fonction.
+    logger = logging.getLogger(__name__)
     try:
         payload = await request.json()
+        
         if not all(k in payload for k in ["user_id", "job_offer_id", "cv_document", "job_offer"]):
             raise HTTPException(status_code=400, detail="Données manquantes dans le payload (user_id, job_offer_id, cv_document, job_offer).")
+            
         logger.info(f"Début de la simulation pour l'utilisateur : {payload['user_id']}")
+        
         processor = GraphInterviewProcessor(payload)
         result = processor.invoke(payload.get("messages", []))
+        
         return JSONResponse(content=result)
 
     except ValueError as ve:
@@ -108,61 +98,43 @@ async def simulate_interview(request: Request):
             status_code=500
         )
 
+# --- Endpoint pour l'analyse de CV ---
 @app.post("/parse-cv/", tags=["CV Parsing"])
 async def parse_cv(file: UploadFile = File(...)):
+    """
+    Analyse un fichier CV (PDF) et retourne les données extraites.
+    """
     if file.content_type != "application/pdf":
         raise HTTPException(status_code=400, detail="Fichier PDF requis")
-
+    
     contents = await file.read()
     
     with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
         tmp.write(contents)
         tmp_path = tmp.name
     
-    result = await run_in_threadpool(cv_service.parse_cv, tmp_path)
-    
-    if os.path.exists(tmp_path):
-        os.remove(tmp_path)
-    
+    try:
+        result = await run_in_threadpool(cv_service.parse_cv, tmp_path)
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+            
+    if not result:
+        raise HTTPException(status_code=500, detail="Échec de l'extraction des données du CV.")
+        
     return result
-'''
-@app.post("/simulate-interview/", tags=["Interview"])
-async def simulate_interview(request: InterviewRequest, background_tasks: BackgroundTasks):
-    processor = InterviewProcessor(
-    request.cv_document,
-    request.job_offer,
-    request.conversation_history
-)
 
-    result = await run_in_threadpool(
-        processor.run,
-        request.messages
-    )
-    response_content = result["messages"][-1].content
-    
-    if "nous allons maintenant passer a l'analyse" in response_content.lower():
-        job_description = request.job_offer.get('description', '')
-        background_tasks.add_task(
-            background_analysis_task,
-            request.user_id,
-            request.conversation_history + request.messages,
-            job_description
-        )
-    
-    return {"response": response_content}
-'''
+# --- Endpoint pour récupérer le feedback ---
 @app.get("/get-feedback/{user_id}", response_model=Feedback, tags=["Analysis"])
 async def get_feedback(user_id: str):
     feedback_path = f"/tmp/feedbacks/{user_id}.json"
-    
     if not os.path.exists(feedback_path):
         raise HTTPException(status_code=404, detail="Feedback non trouvé ou non encore traité.")
-    
     with open(feedback_path, "r", encoding="utf-8") as f:
         data = json.load(f)
-    
     return Feedback(**data)
 
+# --- Démarrage de l'application (pour un test local) ---
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=8000)