Update src/services/interview_service.py

src/services/interview_service.py

@@ -1,21 +1,31 @@
-# Mise à jour pour src/services/interview_service.py
-
 import os
-from typing import Dict, List, Any
+import sys
+import json
+from typing import Dict, List, Any, Annotated
 from typing_extensions import TypedDict
+
 from langchain_core.messages import AIMessage, SystemMessage, HumanMessage
 from langgraph.graph import StateGraph, START, END
 from langgraph.graph.message import add_messages
 from langchain_openai import ChatOpenAI
+
 from src.config import read_system_prompt, format_cv
 
 class State(TypedDict):
-    messages: List[add_messages]
+    messages: Annotated[list, add_messages]
 
-class InterviewService:
-    def __init__(self, models: Dict[str, Any]):
-        self.models = models
+class InterviewProcessor:
+    def __init__(self, cv_document: Dict[str, Any], job_offer: Dict[str, Any], conversation_history: List[Dict[str, Any]]):
+        if not cv_document or 'candidat' not in cv_document:
+            raise ValueError("Document CV invalide fourni.")
+        if not job_offer:
+            raise ValueError("Données de l'offre d'emploi non fournies.")
+
+        self.job_offer = job_offer
+        self.cv_data = cv_document['candidat']
+        self.conversation_history = conversation_history
         self.llm = self._get_llm()
+
         self.system_prompt_template = self._load_prompt_template()
         self.graph = self._build_graph()
 
@@ -28,103 +38,44 @@ class InterviewService:
         )
 
     def _load_prompt_template(self) -> str:
-        return read_system_prompt('prompts/rag_prompt_old.txt')
-
-    def _analyze_candidate_profile(self, cv_data: Dict[str, Any]) -> Dict[str, str]:
-        """Analyse le profil candidat pour générer des insights pour l'entretien"""
-        
-        # Analyse des compétences avec niveaux
-        skills_analysis = self._generate_skills_analysis(cv_data)
-        
-        # Analyse de reconversion
-        reconversion_analysis = self._generate_reconversion_analysis(cv_data)
-        
-        return {
-            "skills_analysis": skills_analysis,
-            "reconversion_analysis": reconversion_analysis
-        }
+        return read_system_prompt('prompts/rag_prompt_old.txt') 
 
-    def _generate_skills_analysis(self, cv_data: Dict[str, Any]) -> str:
-        """Génère une analyse textuelle des compétences pour le prompt"""
-        
-        competences = cv_data.get("analyse_competences", [])
-        
+    def _extract_skills_summary(self) -> str:
+        """Extrait un résumé simple des compétences avec niveaux"""
+        competences = self.cv_data.get('analyse_competences', [])
         if not competences:
             return "Aucune analyse de compétences disponible."
         
-        # Grouper par niveau
-        levels_groups = {
-            "expert": [],
-            "avance": [],
-            "intermediaire": [],
-            "debutant": []
-        }
-        
+        summary = []
         for comp in competences:
-            level = comp.get("level", "debutant")
-            skill = comp.get("skill", "")
-            if skill and level in levels_groups:
-                levels_groups[level].append(skill)
-        
-        # Construire l'analyse textuelle
-        analysis_parts = []
-        
-        if levels_groups["expert"]:
-            analysis_parts.append(f"COMPÉTENCES EXPERTES : {', '.join(levels_groups['expert'])}")
-            analysis_parts.append("→ Pose des questions techniques approfondies, demande des exemples d'innovation et de leadership technique")
+            skill = comp.get('skill', '')
+            level = comp.get('level', 'débutant')
+            summary.append(f"{skill}: {level}")
         
-        if levels_groups["avance"]:
-            analysis_parts.append(f"COMPÉTENCES AVANCÉES : {', '.join(levels_groups['avance'])}")
-            analysis_parts.append("→ Explore les défis complexes, l'autonomie et la résolution de problèmes")
-        
-        if levels_groups["intermediaire"]:
-            analysis_parts.append(f"COMPÉTENCES INTERMÉDIAIRES : {', '.join(levels_groups['intermediaire'])}")
-            analysis_parts.append("→ Vérifie la compréhension pratique avec des exemples concrets")
-        
-        if levels_groups["debutant"]:
-            analysis_parts.append(f"COMPÉTENCES DÉBUTANTES : {', '.join(levels_groups['debutant'])}")
-            analysis_parts.append("→ Teste les connaissances de base et évalue la motivation à apprendre")
-        
-        return "\n".join(analysis_parts) if analysis_parts else "Aucune compétence analysée."
+        return "Niveaux de compétences du candidat: " + " | ".join(summary)
 
-    def _generate_reconversion_analysis(self, cv_data: Dict[str, Any]) -> str:
-        """Génère une analyse de reconversion pour le prompt"""
-        
-        reconversion_data = cv_data.get("reconversion", {})
-        
-        if not reconversion_data:
-            return "Aucune analyse de reconversion disponible."
-        
-        is_reconversion = reconversion_data.get("is_reconversion", False)
-        analysis = reconversion_data.get("analysis", "")
+    def _extract_reconversion_info(self) -> str:
+        """Extrait les infos de reconversion"""
+        reconversion = self.cv_data.get('reconversion', {})
+        if not reconversion:
+            return ""
         
+        is_reconversion = reconversion.get('is_reconversion', False)
         if not is_reconversion:
-            return "PROFIL CLASSIQUE : Parcours cohérent dans le domaine. Focus sur l'évolution et les projets marquants."
-        
-        reconversion_guidance = [
-            "CANDIDAT EN RECONVERSION DÉTECTÉE :",
-            f"Analyse : {analysis}",
-            "",
-            "POINTS À EXPLORER OBLIGATOIREMENT :",
-            "1. Motivations du changement de carrière",
-            "2. Compétences transférables de l'expérience passée", 
-            "3. Démarches d'apprentissage et de formation",
-            "4. Engagement et projets dans la nouvelle voie",
-            "5. Vision à long terme dans ce nouveau domaine",
-            "",
-            "APPROCHE : Valorise l'expérience passée, rassure sur la pertinence de la reconversion"
-        ]
+            return ""
         
-        return "\n".join(reconversion_guidance)
+        analysis = reconversion.get('analysis', '')
+        return f"CANDIDAT EN RECONVERSION: {analysis}"
 
-    def _chatbot_node(self, state: State) -> Dict[str, Any]:
+    def _chatbot_node(self, state: State) -> dict:
         messages = state["messages"]
         formatted_cv_str = format_cv(self.cv_data)
         
-        # Générer les analyses du profil candidat
-        profile_analysis = self._analyze_candidate_profile(self.cv_data)
-        
-        # Formatage du prompt système enrichi
+        # Extractions simples
+        skills_summary = self._extract_skills_summary()
+        reconversion_info = self._extract_reconversion_info()
+
+        # Formatage du prompt système avec les nouvelles données
         system_prompt = self.system_prompt_template.format(
             entreprise=self.job_offer.get('entreprise', 'notre entreprise'),
             poste=self.job_offer.get('poste', 'ce poste'),
@@ -133,8 +84,8 @@ class InterviewService:
             competences=self.job_offer.get('competences', 'Non spécifiées'),
             pole=self.job_offer.get('pole', 'Non spécifié'),
             cv=formatted_cv_str,
-            skills_analysis=profile_analysis["skills_analysis"],
-            reconversion_analysis=profile_analysis["reconversion_analysis"]
+            skills_levels=skills_summary,
+            reconversion_info=reconversion_info
         )
         
         llm_messages = [SystemMessage(content=system_prompt)] + messages
@@ -150,25 +101,6 @@ class InterviewService:
         
         return graph_builder.compile()
 
-    def process_conversation(
-        self, 
-        cv_document: Dict[str, Any], 
-        job_offer: Dict[str, Any], 
-        conversation_history: List[Dict[str, Any]], 
-        messages: List[Dict[str, Any]]
-    ) -> Dict[str, Any]:
-        
-        if not cv_document or 'candidat' not in cv_document:
-            raise ValueError("Document CV invalide fourni.")
-        
-        if not job_offer:
-            raise ValueError("Données de l'offre d'emploi non fournies.")
-
-        self.job_offer = job_offer
-        self.cv_data = cv_document['candidat']
-        self.conversation_history = conversation_history
-        initial_state = conversation_history + messages
-        result = self.graph.invoke({"messages": initial_state})
-        
-        response_content = result["messages"][-1].content
-        return {"response": response_content}
+    def run(self, messages: List[Dict[str, Any]]) -> Dict[str, Any]:
+        initial_state = self.conversation_history + messages
+        return self.graph.invoke({"messages": initial_state})