Update main.py

main.py

@@ -2,17 +2,37 @@ import tempfile
 import requests
 import os
 import logging
-from fastapi import FastAPI, UploadFile, File, HTTPException
+import json
+from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks
 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
+
 os.environ['HOME'] = '/tmp'
-# Configuration du logging
+os.makedirs('/tmp/feedbacks', exist_ok=True)
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Imports avec gestion d'erreurs robuste
+
+try:
+    from src.deep_learning_analyzer import MultiModelInterviewAnalyzer
+    from src.rag_handler import get_rag_handler
+    from src.crew.crew_pool import run_interview_analysis  
+    
+    analyzer_model = MultiModelInterviewAnalyzer()
+    rag_handler_instance = get_rag_handler()
+    MODELS_AVAILABLE = True
+    logger.info("✅ Modèles d'analyse et RAG pré-chargés avec succès")
+except Exception as e:
+    logger.error(f"❌ Erreur lors du pré-chargement des modèles: {e}")
+    MODELS_AVAILABLE = False
+    analyzer_model = None
+    rag_handler_instance = None
+    run_interview_analysis = None
+
+
 try:
     from src.cv_parsing_agents import CvParserAgent, create_fallback_cv_data
     CV_PARSING_AVAILABLE = True
@@ -41,16 +61,14 @@ except Exception as e:
     SCORING_AVAILABLE = False
     ContextualScoringEngine = None
 
-# Application FastAPI
 app = FastAPI(
     title="AIrh Interview Assistant",
-    description="API pour l'analyse de CV et la simulation d'entretiens d'embauche",
-    version="1.3.0",
+    description="API pour l'analyse de CV et la simulation d'entretiens d'embauche avec analyse asynchrone.",
+    version="2.0.0",
     docs_url="/docs",
     redoc_url="/redoc"
 )
 
-# Configuration CORS pour HF Spaces
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -59,10 +77,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Configuration API Celery
-CELERY_API_URL = os.getenv("CELERY_API_URL", "https://celery-7as1.onrender.com")
-
-# Modèles Pydantic
 class InterviewRequest(BaseModel):
     user_id: str = Field(..., example="user_12345")
     job_offer_id: str = Field(..., example="job_offer_abcde")
@@ -71,81 +85,76 @@ class InterviewRequest(BaseModel):
     messages: List[Dict[str, Any]]
     conversation_history: List[Dict[str, Any]]
 
-class AnalysisRequest(BaseModel):
-    conversation_history: List[Dict[str, Any]]
-    job_description_text: str
-    candidate_id: Optional[str] = None
-
-class TaskResponse(BaseModel):
-    task_id: str
+class Feedback(BaseModel):
     status: str
-    result: Any = None
-    message: Optional[str] = None
+    feedback_data: Optional[Dict[str, Any]] = None
 
 class HealthCheck(BaseModel):
     status: str = "ok"
-    celery_api_status: Optional[str] = None
     services: Dict[str, bool] = Field(default_factory=dict)
     message: str = "API AIrh fonctionnelle"
 
-# Endpoints
+def analysis_in_background(user_id: str, conversation_history: list, job_description_text: str):
+    """
+    Fonction exécutée en arrière-plan pour analyser l'entretien
+    et sauvegarder le résultat.
+    """
+    logger.info(f"Démarrage de l'analyse en arrière-plan pour l'utilisateur: {user_id}")
+    try:
+        if not MODELS_AVAILABLE:
+            raise RuntimeError("Les modèles d'analyse ne sont pas disponibles.")
+            
+        report = run_interview_analysis(
+            conversation_history,
+            job_description_text,
+            analyzer_model,
+            rag_handler_instance
+        )
+        
+        feedback_path = f"/tmp/feedbacks/{user_id}.json"
+        with open(feedback_path, "w", encoding="utf-8") as f:
+            json.dump({"status": "completed", "feedback_data": report}, f, ensure_ascii=False, indent=4)
+        
+        logger.info(f"✅ Analyse terminée et sauvegardée pour l'utilisateur: {user_id}")
+    except Exception as e:
+        logger.error(f"❌ Erreur durant l'analyse en arrière-plan pour {user_id}: {e}")
+        feedback_path = f"/tmp/feedbacks/{user_id}.json"
+        with open(feedback_path, "w", encoding="utf-8") as f:
+            json.dump({"status": "error", "feedback_data": str(e)}, f, ensure_ascii=False, indent=4)
+
 @app.get("/", response_model=HealthCheck, tags=["Status"])
 async def health_check():
-    """Health check de l'API avec test de connectivité Celery."""
-    
-    # Test connexion Celery
-    celery_status = "unknown"
-    try:
-        response = requests.get(f"{CELERY_API_URL}/", timeout=5)
-        celery_status = "connected" if response.status_code == 200 else "error"
-    except Exception:
-        celery_status = "disconnected"
-    
+    """Health check de l'API."""
     services = {
+        "models_loaded": MODELS_AVAILABLE,
         "cv_parsing": CV_PARSING_AVAILABLE,
         "interview_simulation": INTERVIEW_AVAILABLE,
-        "scoring_engine": SCORING_AVAILABLE,
-        "celery_api": celery_status == "connected"
+        "scoring_engine": SCORING_AVAILABLE
     }
-    
-    return HealthCheck(
-        celery_api_status=celery_status,
-        services=services
-    )
+    return HealthCheck(services=services)
 
 @app.post("/parse-cv/", tags=["CV Parsing"])
 async def parse_cv(file: UploadFile = File(...)):
     """Analyse un CV PDF et extrait les informations structurées."""
-    
     if not CV_PARSING_AVAILABLE:
-        # Fallback si le parsing n'est pas disponible
-        return create_fallback_cv_data() if create_fallback_cv_data else {
-            "error": "Service de parsing de CV temporairement indisponible",
-            "candidat": {
-                "informations_personnelles": {"nom": "Test User"},
-                "compétences": {"hard_skills": [], "soft_skills": []}
-            }
-        }
+        return create_fallback_cv_data() if create_fallback_cv_data else {"error": "Service de parsing indisponible"}
     
     if file.content_type != "application/pdf":
         raise HTTPException(status_code=400, detail="Fichier PDF requis")
-    
+
     tmp_path = None
     try:
-        # Sauvegarder le fichier temporairement
         contents = await file.read()
         with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
             tmp.write(contents)
             tmp_path = tmp.name
         
-        # Traiter le CV
         cv_agent = CvParserAgent(pdf_path=tmp_path)
         parsed_data = await run_in_threadpool(cv_agent.process)
         
         if not parsed_data and create_fallback_cv_data:
             parsed_data = create_fallback_cv_data(tmp_path)
         
-        # Scoring si disponible
         if SCORING_AVAILABLE and ContextualScoringEngine and parsed_data:
             try:
                 scoring_engine = ContextualScoringEngine(parsed_data)
@@ -165,20 +174,16 @@ async def parse_cv(file: UploadFile = File(...)):
     
     finally:
         if tmp_path and os.path.exists(tmp_path):
-            try:
-                os.remove(tmp_path)
-            except Exception:
-                pass
+            os.remove(tmp_path)
 
 @app.post("/simulate-interview/", tags=["Interview"])
-async def simulate_interview(request: InterviewRequest):
-    """Gère une conversation d'entretien d'embauche."""
-    
-    if not INTERVIEW_AVAILABLE:
-        raise HTTPException(
-            status_code=503, 
-            detail="Service de simulation d'entretien indisponible"
-        )
+async def simulate_interview(request: InterviewRequest, background_tasks: BackgroundTasks):
+    """
+    Gère une conversation d'entretien. Si la conversation se termine,
+    lance une analyse en arrière-plan.
+    """
+    if not INTERVIEW_AVAILABLE or not MODELS_AVAILABLE:
+        raise HTTPException(status_code=503, detail="Service de simulation ou modèles indisponibles")
     
     try:
         processor = InterviewProcessor(
@@ -188,82 +193,45 @@ async def simulate_interview(request: InterviewRequest):
         )
         
         result = await run_in_threadpool(processor.run, messages=request.messages)
-        return {"response": result["messages"][-1].content}
         
-    except Exception as e:
-        logger.error(f"Erreur simulation entretien: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/trigger-analysis/", response_model=TaskResponse, status_code=202, tags=["Analysis"])
-async def trigger_analysis(request: AnalysisRequest):
-    """Déclenche une analyse asynchrone via l'API Celery."""
-    
-    try:
-        response = requests.post(
-            f"{CELERY_API_URL}/trigger-analysis",
-            json=request.dict(),
-            headers={"Content-Type": "application/json"},
-            timeout=30
-        )
+        response_content = result["messages"][-1].content
         
-        if response.status_code == 202:
-            data = response.json()
-            return TaskResponse(
-                task_id=data["task_id"],
-                status=data["status"],
-                message="Analyse démarrée"
-            )
-        else:
-            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
+        # Déclencher l'analyse si l'entretien est terminé
+        if "nous allons maintenant passer a l'analyse" in response_content.lower():
+            logger.info(f"Fin d'entretien détectée pour {request.user_id}. Lancement de l'analyse en arrière-plan.")
             
-    except requests.RequestException:
-        raise HTTPException(status_code=503, detail="API Celery inaccessible")
+            # Sauvegarder un statut initial
+            feedback_path = f"/tmp/feedbacks/{request.user_id}.json"
+            with open(feedback_path, "w", encoding="utf-8") as f:
+                json.dump({"status": "processing"}, f, ensure_ascii=False, indent=4)
+            
+            job_description = request.job_offer.get('description', '')
+            background_tasks.add_task(
+                analysis_in_background,
+                request.user_id,
+                request.conversation_history + request.messages,
+                job_description
+            )
+        
+        return {"response": response_content}
+        
     except Exception as e:
+        logger.error(f"Erreur simulation entretien: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/analysis-status/{task_id}", response_model=TaskResponse, tags=["Analysis"])
-async def get_analysis_status(task_id: str):
-    """Récupère le statut d'une analyse."""
+@app.get("/get-feedback/{user_id}", response_model=Feedback, tags=["Analysis"])
+async def get_feedback(user_id: str):
+    """Récupère le résultat de l'analyse post-entretien."""
+    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é.")
     
     try:
-        response = requests.get(f"{CELERY_API_URL}/task-status/{task_id}", timeout=10)
-        
-        if response.status_code == 200:
-            data = response.json()
-            return TaskResponse(
-                task_id=task_id,
-                status=data["status"],
-                result=data.get("result"),
-                message=data.get("progress", "Statut récupéré")
-            )
-        else:
-            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
-            
-    except requests.RequestException:
-        raise HTTPException(status_code=503, detail="API Celery inaccessible")
+        with open(feedback_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return Feedback(**data)
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-# Endpoint de debug pour HF Spaces
-@app.get("/debug", tags=["Debug"])
-async def debug_info():
-    """Informations de debug pour le déploiement."""
-    return {
-        "environment": {
-            "HF_HOME": os.getenv("HF_HOME"),
-            "CELERY_API_URL": CELERY_API_URL,
-            "PYTHONPATH": os.getenv("PYTHONPATH")
-        },
-        "services": {
-            "cv_parsing": CV_PARSING_AVAILABLE,
-            "interview_simulation": INTERVIEW_AVAILABLE,
-            "scoring_engine": SCORING_AVAILABLE
-        },
-        "cache_dirs": {
-            "/tmp/cache": os.path.exists("/tmp/cache"),
-            "/app/cache": os.path.exists("/app/cache")
-        }
-    }
+        raise HTTPException(status_code=500, detail=f"Erreur à la lecture du feedback: {e}")
 
 if __name__ == "__main__":
     import uvicorn