Update main.py

main.py

@@ -1,38 +1,37 @@
 import logging
-import tempfile
 import os
+import requests # Ajout de la librairie pour les requêtes HTTP
 from fastapi import FastAPI, HTTPException, Body, UploadFile, File
 from pydantic import BaseModel
 from typing import List, Dict, Any
-from celery.result import AsyncResult
 from dotenv import load_dotenv
 from fastapi.concurrency import run_in_threadpool
 
 # --- Import de VOS modules de travail ---
-# J'ai restauré les imports tels qu'ils étaient dans votre projet original.
 from src.cv_parsing_agents import CVParser
 from src.interview_simulator.entretient_version_prod import InterviewProcessor
-from src.config import Config # En supposant que vous ayez un fichier config
+from src.config import Config
 
-# --- Import de la nouvelle tâche asynchrone ---
-from tasks.worker_celery import run_interview_analysis_task
+# --- Celery n'est plus importé ici ---
 
-# Charger les variables d'environnement
 load_dotenv()
 
-# Configuration du logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# --- Initialisation de l'application FastAPI ---
-# J'ai restauré la structure que vous aviez probablement, avec l'initialisation des singletons.
+# --- Récupération de l'URL du nouveau service ---
+# Vous devrez ajouter cette variable à votre environnement sur la plateforme où vous déploierez cette API.
+CELERY_SERVICE_URL = os.environ.get("CELERY_SERVICE_URL")
+if not CELERY_SERVICE_URL:
+    logger.warning("La variable d'environnement CELERY_SERVICE_URL n'est pas définie. Les analyses asynchrones échoueront.")
+
 app = FastAPI(
-    title="AIrh API - Version Restaurée",
-    description="API complète incluant le parsing de CV, la simulation d'entretien, et l'analyse asynchrone, en respectant la structure originale.",
-    version="2.0.0"
+    title="AIrh Main API",
+    description="API principale gérant le parsing de CV et la simulation interactive.",
+    version="2.1.0"
 )
 
-# --- Modèles de données Pydantic (inchangés) ---
+# --- Modèles de données Pydantic ---
 class ParsedCVResponse(BaseModel):
     candidat: Dict[str, Any]
 
@@ -58,45 +57,28 @@ class TaskStatusResponse(BaseModel):
 
 @app.get("/", summary="Health Check")
 async def read_root():
-    return {"message": "AIrh Analysis API est opérationnelle."}
+    return {"message": "AIrh Main API est opérationnelle."}
 
-# --- SECTION ORIGINALE RESTAURÉE ---
+# --- SECTION ORIGINALE (INCHANGÉE) ---
 
-@app.post("/parse-cv/", response_model=ParsedCVResponse, tags=["1. Parsing de CV (Logique Originale Adaptée)"])
+@app.post("/parse-cv/", response_model=ParsedCVResponse, tags=["1. Parsing de CV"])
 async def parse_cv(file: UploadFile = File(...)):
-    """
-    Endpoint pour parser un CV. La logique utilise maintenant le contenu en mémoire
-    pour être compatible avec les conteneurs, mais l'esprit reste le même.
-    """
     logger.info(f"Réception du fichier CV: {file.filename}")
-    
-    # Lecture du contenu du fichier en mémoire vive.
-    # C'est l'adaptation nécessaire pour un environnement conteneurisé.
     cv_content = await file.read()
     if not cv_content:
         raise HTTPException(status_code=400, detail="Le fichier CV est vide.")
-
     try:
-        # On suppose que votre CVParser peut maintenant accepter des octets (bytes).
-        # C'est une modification mineure à faire dans la classe CVParser.
         parser = CVParser()
         parsed_data = await run_in_threadpool(parser.parse, cv_content)
-        
         if not parsed_data or "candidat" not in parsed_data:
             raise HTTPException(status_code=422, detail="Impossible d'extraire les données structurées du CV.")
-        
-        logger.info("Parsing du CV réussi.")
         return parsed_data
     except Exception as e:
         logger.error(f"Erreur critique lors du parsing du CV: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Erreur interne du serveur lors du parsing: {str(e)}")
 
-@app.post("/simulate-interview/", response_model=InterviewResponse, tags=["2. Simulation d'Entretien (Logique Originale)"])
+@app.post("/simulate-interview/", response_model=InterviewResponse, tags=["2. Simulation d'Entretien"])
 async def simulate_interview(request: InterviewRequest):
-    """
-    Endpoint pour gérer un tour de conversation dans la simulation d'entretien.
-    Cette fonction est conservée telle quelle pour la partie interactive.
-    """
     logger.info("Réception d'une requête pour la simulation d'entretien.")
     try:
         processor = InterviewProcessor(
@@ -105,45 +87,50 @@ async def simulate_interview(request: InterviewRequest):
             conversation_history=request.conversation_history
         )
         ai_response_object = await run_in_threadpool(processor.run, messages=request.messages)
-        
-        # On extrait la dernière réponse de l'assistant pour la retourner au frontend.
         last_message = ai_response_object["messages"][-1].content
         return {"response": last_message}
     except Exception as e:
         logger.error(f"Erreur lors de la simulation d'entretien: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Erreur interne du serveur lors de la simulation: {str(e)}")
 
-# --- SECTION MODIFIÉE POUR L'ANALYSE ASYNCHRONE ---
-# C'est ici que se trouve la seule modification majeure de votre logique.
+# --- SECTION MODIFIÉE POUR APPELER LE SERVICE EXTERNE ---
 
-@app.post("/trigger-analysis/", response_model=TaskStatusResponse, status_code=202, tags=["3. Analyse Asynchrone"])
+@app.post("/trigger-analysis/", response_model=TaskStatusResponse, status_code=202, tags=["3. Analyse Asynchrone (Externe)"])
 async def trigger_analysis(request: AnalysisRequest):
     """
-    Déclenche l'analyse de l'entretien en tâche de fond via Celery.
+    Déclenche l'analyse en appelant le service Celery externe.
     """
-    logger.info(f"Déclenchement de l'analyse pour une conversation de {len(request.conversation_history)} messages.")
+    logger.info("Redirection de la demande d'analyse vers le service Celery externe.")
+    if not CELERY_SERVICE_URL:
+        raise HTTPException(status_code=503, detail="Le service d'analyse est actuellement indisponible.")
+    
     try:
-        # On appelle la tâche Celery de manière asynchrone.
-        task = run_interview_analysis_task.delay(
-            request.conversation_history, 
-            [request.job_description_text]
-        )
-        # On retourne immédiatement l'ID de la tâche pour que le client puisse suivre son statut.
-        return {"task_id": task.id, "status": "PENDING", "result": None}
-    except Exception as e:
-        logger.error(f"Erreur lors du déclenchement de la tâche Celery: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Impossible de soumettre la tâche d'analyse.")
-
-@app.get("/analysis-status/{task_id}", response_model=TaskStatusResponse, tags=["3. Analyse Asynchrone"])
+        # On fait une requête POST à notre service Celery sur Render
+        api_url = f"{CELERY_SERVICE_URL}/trigger-analysis"
+        logger.info(f"Appel de l'API externe : {api_url}")
+        response = requests.post(api_url, json=request.dict())
+        response.raise_for_status() # Lève une exception si le statut n'est pas 2xx
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Erreur de communication avec le service Celery: {e}")
+        raise HTTPException(status_code=502, detail="Erreur de communication avec le service d'analyse.")
+
+@app.get("/analysis-status/{task_id}", response_model=TaskStatusResponse, tags=["3. Analyse Asynchrone (Externe)"])
 async def get_analysis_status(task_id: str):
     """
-    Vérifie le statut d'une tâche d'analyse en cours d'exécution.
+    Vérifie le statut d'une tâche en interrogeant le service Celery externe.
     """
-    logger.info(f"Vérification du statut pour la tâche ID: {task_id}")
-    # On utilise l'ID pour récupérer le résultat depuis le backend Celery (Upstash Redis).
-    task_result = AsyncResult(task_id)
-    
-    status = task_result.status
-    result = task_result.result if task_result.ready() else None
-    
-    return {"task_id": task_id, "status": status, "result": result}
+    logger.info(f"Vérification du statut de la tâche externe: {task_id}")
+    if not CELERY_SERVICE_URL:
+        raise HTTPException(status_code=503, detail="Le service d'analyse est actuellement indisponible.")
+        
+    try:
+        # On fait une requête GET à notre service Celery sur Render
+        api_url = f"{CELERY_SERVICE_URL}/analysis-status/{task_id}"
+        logger.info(f"Appel de l'API externe : {api_url}")
+        response = requests.get(api_url)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Erreur de communication avec le service Celery: {e}")
+        raise HTTPException(status_code=502, detail="Erreur de communication avec le service d'analyse.")