Update main.py

main.py

@@ -1,48 +1,73 @@
 import tempfile
 import requests
-from fastapi import FastAPI, UploadFile, File, HTTPException, Body
+import os
+import logging
+from fastapi import FastAPI, UploadFile, File, HTTPException
 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 datetime import datetime
-import uvicorn
-import os
-import logging
 
+# Configuration du logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-from src.cv_parsing_agents import CvParserAgent
-from src.interview_simulator.entretient_version_prod import InterviewProcessor
-from src.scoring_engine import ContextualScoringEngine
-from src.rag_handler import RAGHandler
+# Imports avec gestion d'erreurs robuste
+try:
+    from src.cv_parsing_agents import CvParserAgent, create_fallback_cv_data
+    CV_PARSING_AVAILABLE = True
+    logger.info("✅ CV Parsing disponible")
+except Exception as e:
+    logger.error(f"❌ CV Parsing indisponible: {e}")
+    CV_PARSING_AVAILABLE = False
+    CvParserAgent = None
+    create_fallback_cv_data = None
+
+try:
+    from src.interview_simulator.entretient_version_prod import InterviewProcessor
+    INTERVIEW_AVAILABLE = True
+    logger.info("✅ Interview Simulator disponible")
+except Exception as e:
+    logger.error(f"❌ Interview Simulator indisponible: {e}")
+    INTERVIEW_AVAILABLE = False
+    InterviewProcessor = None
+
+try:
+    from src.scoring_engine import ContextualScoringEngine
+    SCORING_AVAILABLE = True
+    logger.info("✅ Scoring Engine disponible")
+except Exception as e:
+    logger.error(f"❌ Scoring Engine indisponible: {e}")
+    SCORING_AVAILABLE = False
+    ContextualScoringEngine = None
 
+# Application FastAPI
 app = FastAPI(
-    title="API d'IA pour la RH",
-    description="Une API pour le parsing de CV et la simulation d'entretiens avec analyse asynchrone.",
-    version="1.3.0"
+    title="AIrh Interview Assistant",
+    description="API pour l'analyse de CV et la simulation d'entretiens d'embauche",
+    version="1.3.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
 )
 
-# Configuration de l'API Celery externe
-CELERY_API_URL = os.getenv("CELERY_API_URL", "https://celery-7as1.onrender.com")
+# Configuration CORS pour HF Spaces
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-# Initialisation des services au démarrage
-try:
-    logger.info("Initialisation du RAG Handler...")
-    rag_handler = RAGHandler()
-    if rag_handler.vector_store:
-        logger.info(f"Vector store chargé avec {rag_handler.vector_store.index.ntotal} vecteurs.")
-    else:
-        logger.warning("Le RAG Handler n'a pas pu être initialisé (pas de documents ?). Le feedback contextuel sera désactivé.")
-except Exception as e:
-    logger.error(f"Erreur critique lors de l'initialisation du RAG Handler: {e}", exc_info=True)
-    rag_handler = None
+# 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="google_user_12345")
+    user_id: str = Field(..., example="user_12345")
     job_offer_id: str = Field(..., example="job_offer_abcde")
-    cv_document: Dict[str, Any] = Field(..., example={"candidat": {"nom": "John Doe", "compétences": {"hard_skills": ["Python", "FastAPI"]}}})
-    job_offer: Dict[str, Any] = Field(..., example={"poste": "Développeur Python", "description": "Recherche développeur expérimenté..."})
+    cv_document: Dict[str, Any]
+    job_offer: Dict[str, Any]
     messages: List[Dict[str, Any]]
     conversation_history: List[Dict[str, Any]]
 
@@ -58,181 +83,188 @@ class TaskResponse(BaseModel):
     message: Optional[str] = None
 
 class HealthCheck(BaseModel):
-    status: str = Field(default="ok", example="ok")
+    status: str = "ok"
     celery_api_status: Optional[str] = None
+    services: Dict[str, bool] = Field(default_factory=dict)
+    message: str = "API AIrh fonctionnelle"
 
-@app.get("/", tags=["Status"], summary="Vérification de l'état de l'API")
-async def read_root() -> HealthCheck:
-    """Vérifie que l'API est en cours d'exécution et teste la connexion à l'API Celery."""
+# Endpoints
+@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)
-        if response.status_code == 200:
-            celery_status = "connected"
-        else:
-            celery_status = "error"
-    except Exception as e:
-        logger.warning(f"Impossible de se connecter à l'API Celery: {e}")
+        celery_status = "connected" if response.status_code == 200 else "error"
+    except Exception:
         celery_status = "disconnected"
     
-    return HealthCheck(status="ok", celery_api_status=celery_status)
+    services = {
+        "cv_parsing": CV_PARSING_AVAILABLE,
+        "interview_simulation": INTERVIEW_AVAILABLE,
+        "scoring_engine": SCORING_AVAILABLE,
+        "celery_api": celery_status == "connected"
+    }
+    
+    return HealthCheck(
+        celery_api_status=celery_status,
+        services=services
+    )
 
-# --- Endpoint du parser de CV ---
-@app.post("/parse-cv/", tags=["CV Parsing"], summary="Analyser un CV au format PDF avec scoring contextuel")
-async def parse_cv_endpoint(file: UploadFile = File(...)):
+@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": []}
+            }
+        }
+    
     if file.content_type != "application/pdf":
-        raise HTTPException(status_code=400, detail="Le fichier doit être au format PDF.")
-    tmp_path = None  
+        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.flush()
             tmp_path = tmp.name
         
-        logger.info(f"Début du parsing du CV temporaire : {tmp_path}")
+        # Traiter le CV
         cv_agent = CvParserAgent(pdf_path=tmp_path)
         parsed_data = await run_in_threadpool(cv_agent.process)
-        if not parsed_data:
-            raise HTTPException(status_code=500, detail="Échec du parsing du CV.")
-        logger.info("Parsing du CV réussi. Lancement du scoring contextuel.")
-        scoring_engine = ContextualScoringEngine(parsed_data)
-        scored_skills_data = await run_in_threadpool(scoring_engine.calculate_scores)
-        if parsed_data.get("candidat"):
-            parsed_data["candidat"].update(scored_skills_data)
-        else:
-            parsed_data.update(scored_skills_data)
-
-        logger.info("Scoring terminé. Retour de la réponse complète.")
+        
+        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)
+                scored_data = await run_in_threadpool(scoring_engine.calculate_scores)
+                if parsed_data.get("candidat"):
+                    parsed_data["candidat"].update(scored_data)
+            except Exception as e:
+                logger.warning(f"Scoring échoué: {e}")
+        
         return parsed_data
-
+        
     except Exception as e:
-        logger.error(f"Erreur lors du parsing ou du scoring du CV : {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Erreur interne du serveur : {e}")
+        logger.error(f"Erreur parsing CV: {e}")
+        if create_fallback_cv_data:
+            return create_fallback_cv_data(tmp_path)
+        raise HTTPException(status_code=500, detail=str(e))
+    
     finally:
         if tmp_path and os.path.exists(tmp_path):
             try:
                 os.remove(tmp_path)
-                logger.info(f"Fichier temporaire supprimé : {tmp_path}")
-            except Exception as cleanup_error:
-                logger.warning(f"Erreur lors de la suppression du fichier temporaire : {cleanup_error}")
+            except Exception:
+                pass
 
-# --- Endpoint de simulation d'entretien ---
-@app.post("/simulate-interview/", tags=["Simulation d'Entretien"], summary="Gérer une conversation d'entretien")
-async def simulate_interview_endpoint(request: InterviewRequest):
+@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"
+        )
+    
     try:
         processor = InterviewProcessor(
             cv_document=request.cv_document,
             job_offer=request.job_offer,
             conversation_history=request.conversation_history
         )
-        ai_response_object = await run_in_threadpool(processor.run, messages=request.messages)
         
-        # On retourne juste la réponse de l'assistant pour le chat
-        return {"response": ai_response_object["messages"][-1].content}
-
+        result = await run_in_threadpool(processor.run, messages=request.messages)
+        return {"response": result["messages"][-1].content}
+        
     except Exception as e:
-        logger.error(f"Erreur interne dans /simulate-interview/: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Erreur interne du serveur : {e}")
+        logger.error(f"Erreur simulation entretien: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-# --- Endpoints pour l'analyse asynchrone via API Celery externe ---
-@app.post("/trigger-analysis/", tags=["Analyse Asynchrone"], response_model=TaskResponse, status_code=202)
+@app.post("/trigger-analysis/", response_model=TaskResponse, status_code=202, tags=["Analysis"])
 async def trigger_analysis(request: AnalysisRequest):
-    """
-    Déclenche l'analyse de l'entretien en tâche de fond via l'API Celery externe.
-    Retourne immédiatement un ID de tâche.
-    """
+    """Déclenche une analyse asynchrone via l'API Celery."""
+    
     try:
-        logger.info(f"Déclenchement d'analyse via API Celery pour candidat: {request.candidate_id}")
-        
-        # Appel à l'API Celery externe
-        celery_response = requests.post(
+        response = requests.post(
             f"{CELERY_API_URL}/trigger-analysis",
-            json={
-                "conversation_history": request.conversation_history,
-                "job_description_text": request.job_description_text,
-                "candidate_id": request.candidate_id
-            },
+            json=request.dict(),
             headers={"Content-Type": "application/json"},
             timeout=30
         )
         
-        if celery_response.status_code == 202:
-            celery_data = celery_response.json()
+        if response.status_code == 202:
+            data = response.json()
             return TaskResponse(
-                task_id=celery_data["task_id"],
-                status=celery_data["status"],
-                result=celery_data.get("result"),
-                message="Analyse démarrée avec succès"
+                task_id=data["task_id"],
+                status=data["status"],
+                message="Analyse démarrée"
             )
         else:
-            logger.error(f"Erreur API Celery: {celery_response.status_code} - {celery_response.text}")
-            raise HTTPException(
-                status_code=503, 
-                detail=f"Service d'analyse indisponible: {celery_response.status_code}"
-            )
+            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
             
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Erreur de connexion à l'API Celery: {e}")
-        raise HTTPException(
-            status_code=503, 
-            detail="Service d'analyse temporairement indisponible"
-        )
+    except requests.RequestException:
+        raise HTTPException(status_code=503, detail="API Celery inaccessible")
     except Exception as e:
-        logger.error(f"Erreur inattendue lors du déclenchement de l'analyse: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/analysis-status/{task_id}", tags=["Analyse Asynchrone"], response_model=TaskResponse)
+@app.get("/analysis-status/{task_id}", response_model=TaskResponse, tags=["Analysis"])
 async def get_analysis_status(task_id: str):
-    """
-    Vérifie le statut de la tâche d'analyse via l'API Celery externe.
-    Si terminée, retourne le résultat.
-    """
+    """Récupère le statut d'une analyse."""
+    
     try:
-        logger.info(f"Vérification du statut pour la tâche: {task_id}")
+        response = requests.get(f"{CELERY_API_URL}/task-status/{task_id}", timeout=10)
         
-        # Appel à l'API Celery externe
-        celery_response = requests.get(
-            f"{CELERY_API_URL}/task-status/{task_id}",
-            timeout=10
-        )
-        
-        if celery_response.status_code == 200:
-            celery_data = celery_response.json()
+        if response.status_code == 200:
+            data = response.json()
             return TaskResponse(
                 task_id=task_id,
-                status=celery_data["status"],
-                result=celery_data.get("result"),
-                message=celery_data.get("progress", "Statut récupéré")
+                status=data["status"],
+                result=data.get("result"),
+                message=data.get("progress", "Statut récupéré")
             )
         else:
-            logger.error(f"Erreur API Celery: {celery_response.status_code}")
-            raise HTTPException(
-                status_code=503, 
-                detail="Service d'analyse indisponible"
-            )
+            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
             
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Erreur de connexion à l'API Celery: {e}")
-        raise HTTPException(
-            status_code=503, 
-            detail="Service d'analyse temporairement indisponible"
-        )
+    except requests.RequestException:
+        raise HTTPException(status_code=503, detail="API Celery inaccessible")
     except Exception as e:
-        logger.error(f"Erreur lors de la vérification du statut: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/celery-stats", tags=["Debug"], summary="Statistiques de l'API Celery")
-async def get_celery_stats():
-    """Récupère les statistiques de l'API Celery externe."""
-    try:
-        response = requests.get(f"{CELERY_API_URL}/worker-stats", timeout=10)
-        if response.status_code == 200:
-            return response.json()
-        else:
-            return {"error": f"API Celery inaccessible: {response.status_code}"}
-    except Exception as e:
-        return {"error": f"Impossible de récupérer les stats: {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")
+        }
+    }
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)