Update src/cv_parsing_agents.py

src/cv_parsing_agents.py

@@ -1,50 +1,58 @@
-import os
-import json
+import torch
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer, util
 
-from src.crew.crew_pool import analyse_cv
-from src.config import load_pdf
+class MultiModelInterviewAnalyzer:
+    def __init__(self):
+        self.sentiment_analyzer = pipeline(
+            "text-classification",
+            model="astrosbd/french_emotion_camembert",
+            return_all_scores=True,
+            device=0 if torch.cuda.is_available() else -1,
+        )
+        self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.intent_classifier = pipeline(
+            "zero-shot-classification",
+            model="joeddav/xlm-roberta-large-xnli"
+            #device=0 if torch.cuda.is_available() else -1,
+        )
 
-def clean_dict_keys(data):
-    if isinstance(data, dict):
-        return {str(key): clean_dict_keys(value) for key, value in data.items()}
-    elif isinstance(data, list):
-        return [clean_dict_keys(element) for element in data]
-    else:
-        return data
+    def analyze_sentiment(self, messages):
+        user_messages = [msg['content'] for msg in messages if msg['role'] == 'user']
+        if not user_messages:
+            return []
+        sentiments = self.sentiment_analyzer(user_messages)
+        return sentiments
 
-class CvParserAgent:
-    def __init__(self, pdf_path: str):
-        self.pdf_path = pdf_path
-
-    def process(self) -> dict:
-        """
-        Traite le fichier PDF pour en extraire le contenu sous forme de JSON.
-        Ne se connecte à aucune base de données.
-        
-        Retourne :
-            Un dictionnaire contenant les données extraites du CV, ou None en cas d'erreur.
-        """
-        print(f"Début du traitement du CV : {self.pdf_path}")
+    def compute_semantic_similarity(self, messages, job_requirements):
+        user_answers = " ".join([msg['content'] for msg in messages if msg['role'] == 'user'])
+        embedding_answers = self.similarity_model.encode(user_answers, convert_to_tensor=True)
+        embedding_requirements = self.similarity_model.encode(job_requirements, convert_to_tensor=True)
+        cosine_score = util.cos_sim(embedding_answers, embedding_requirements)
         
-        try:
-            cv_text_content = load_pdf(self.pdf_path)
-            crew_output = analyse_cv(cv_text_content)
+        return cosine_score.max().item()
 
-            if not crew_output or not hasattr(crew_output, 'raw') or not crew_output.raw.strip():
-                print("Erreur : L'analyse par le crew n'a pas retourné de résultat.")
-                return None
-            raw_string = crew_output.raw
-            json_string_cleaned = raw_string
-            if '```' in raw_string:
-                json_part = raw_string.split('```json')[1].split('```')[0]
-                json_string_cleaned = json_part.strip()
-            profile_data = json.loads(json_string_cleaned)
-            return clean_dict_keys(profile_data)
+    def classify_candidate_intent(self, messages):
+        user_answers = [msg['content'] for msg in messages if msg['role'] == 'user']
+        if not user_answers:
+            return []
+        candidate_labels = [
+            "parle de son expérience technique",
+            "exprime sa motivation",
+            "pose une question",
+            "exprime de l’incertitude ou du stress"
+        ]
+        classifications = self.intent_classifier(user_answers, candidate_labels, multi_label=False)
+        return classifications
 
-        except json.JSONDecodeError as e:
-            print(f"Erreur de décodage JSON : {e}")
-            print(f"Données brutes reçues : {crew_output.raw}")
-            return None
-        except Exception as e:
-            print(f"Une erreur inattendue est survenue dans CvParserAgent : {e}")
-            return None
+    def run_full_analysis(self, conversation_history, job_requirements):
+        sentiment_results = self.analyze_sentiment(conversation_history)
+        similarity_score = self.compute_semantic_similarity(conversation_history, job_requirements)
+        intent_results = self.classify_candidate_intent(conversation_history)
+        analysis_output = {
+            "overall_similarity_score": round(similarity_score, 2),
+            "sentiment_analysis": sentiment_results,
+            "intent_analysis": intent_results,
+            "raw_transcript": conversation_history 
+        }
+        return analysis_output