# Configuration avancée de la page - DOIT ÊTRE LA PREMIÈRE COMMANDE STREAMLIT import streamlit as st st.set_page_config( layout="wide", page_title="Analyse de CV - GFSI (Version 25.12)", page_icon="📄", initial_sidebar_state="expanded" ) from PyPDF2 import PdfReader import pandas as pd from groq import Groq from referentials import REFERENTIALS, load_referentials_from_json, create_referential_with_ai, save_referential_to_json, is_admin_authenticated, TEMPLATE_NOUVEAU_REFERENTIEL import json import re import os # Dictionnaire de traduction TRANSLATIONS = { "fr": { # Textes principaux "app_title": "Analyse de CV selon les Référentiels GFSI", "app_description": "Outil d'analyse de CV - GFSI", "language": "Langue", "french": "Français", "english": "Anglais", # Configuration "configuration": "Configuration", "api_key": "Clé API Groq :", "api_key_help": "La clé API commence par 'gsk_'", "model": "Modèle d'IA:", "model_help": "Balance entre précision d'analyse et vitesse", "models": { "llama-3.3-70b-versatile": "Llama 3.3 70B (Haute précision)", "llama-3.2-11b-versatile": "Llama 3.2 11B (Équilibré)", "llama-3.1-8b-instant": "Llama 3.1 8B (Rapide)", "kmi-k2-70b": "KMI K2 70B (Spécialisé)", "qwen3-72b": "QWEN 3 72B (Alibaba Cloud)" }, # Options d'analyse "analysis_options": "Options d'analyse", "debug_mode": "Afficher les données brutes (Debug)", # Administration "administration": "Administration", "admin_password": "Mot de passe admin :", "access_admin": "Accéder au mode admin", "exit_admin": "Quitter le mode admin", "admin_activated": "Mode admin activé ✅", "admin_password_incorrect": "Mot de passe incorrect", "create_referential": "Créer un nouveau référentiel", "ai_assistant": "Assistant IA de création de référentiel", "paste_requirements": "Collez ici les exigences du nouveau standard :", "generate_json": "Générer le JSON", "generated_referential": "Référentiel généré (à copier/coller dans referentials.py) :", "save_referential": "Sauvegarder le référentiel", "filename": "Nom du fichier (sans extension) :", "referential_saved": "Référentiel sauvegardé dans referentiels/{}.json", "error_saving": "Erreur lors de la sauvegarde", "referential_generated": "Référentiel généré avec succès !", "error_generating": "Erreur lors de la génération du référentiel", "please_enter_requirements": "Veuillez saisir les exigences et configurer votre clé API", # À propos "about": "À propos", "app_info": """ **Outil d'analyse CV - GFSI** Version 25.12 Référentiels supportés : BRCGS, FSSC 22000, IFS """, # Guide d'utilisation "usage_guide": "Guide d'utilisation", "usage_instructions": """ ### Comment utiliser cet outil? 1. **Configuration**: - Saisissez votre clé API Groq dans le panneau latéral - Sélectionnez le modèle d'IA à utiliser 2. **Analyse**: - Téléchargez un CV au format PDF - Sélectionnez le référentiel GFSI applicable - Lancez l'analyse 3. **Résultats**: - Consultez le rapport détaillé avec références aux exigences - Explorez les détails par section (Général, Qualifications, etc.) - Exportez les résultats au format HTML **Astuce**: Plus le document est clairement formaté, meilleure sera l'analyse. """, # Analyse de CV "cv_analysis": "Analyse de CV", "configure_api": "⚠️ Veuillez configurer votre clé API Groq dans le panneau latéral pour continuer.", "upload_cv": "📄 Téléchargez un fichier PDF (CV)", "upload_help": "Formats supportés : PDF. Taille maximale: 10MB", "please_upload_cv": "Veuillez télécharger un fichier PDF pour commencer l'analyse.", "referential_preview": "Aperçu des référentiels supportés", "select_referential": "📋 Sélectionnez un référentiel", "referential_help": "Choisissez le standard GFSI applicable pour ce candidat", "analyze_cv": "🔍 Analyser le CV", "extracting_text": "Extraction du texte en cours...", "no_pages": "Le PDF ne contient aucune page.", "no_text_extracted": "Aucun texte n'a pu être extrait du PDF. Vérifiez qu'il ne s'agit pas d'un PDF scanné.", "pdf_protected": "Conseils: Vérifiez que le PDF n'est pas protégé ou qu'il ne s'agit pas d'un document scanné sans OCR.", "analyzing_cv": "Analyse approfondie du CV en cours...", "analysis_failed": "L'analyse n'a pas pu être structurée correctement. Affichage des résultats bruts.", "connection_error": "Erreur de connexion à l'API Groq : {}", "api_key_invalid": "La clé API semble invalide. Les clés Groq commencent généralement par 'gsk_'.", "text_preview": "Aperçu du texte extrait", "raw_analysis_data": "Données brutes de l'analyse (Debug)", "download_report": "📥 Télécharger le rapport complet", # Résultats d'analyse "analysis_summary": "📊 Résumé de l'analyse selon le référentiel {}", "total_requirements": "📊 Total", "conformant": "✅ Conformes", "partially_conformant": "🟡 Partiel", "non_conformant": "❌ Non conformes", "compliance_rate": "📈 Taux de conformité", "final_recommendation": "Recommandation finale :", "major_strengths": "💪 Forces principales", "critical_gaps": "⚠️ Lacunes critiques", "development_opportunities": "📈 Opportunités", "detailed_justification": "📝 Justification", "no_justification": "Aucune justification disponible.", "detailed_analysis": "📋 Analyse détaillée des exigences", "category": "📁 {}", "requirement": "📋 Exigence", "evaluation": "Évaluation", "status": "Statut:", "confidence_score": "Score de confiance:", "elements_found": "🔍 Éléments trouvés", "no_elements": "Aucun élément trouvé", "justification": "🧠 Justification", "no_justification_detail": "Aucune justification fournie", "recommendations": "💡 Recommandations", "no_recommendations": "Aucune recommandation", "requirement_not_specified": "Exigence non spécifiée", "not_evaluated": "Non évalué", "reference_not_specified": "Non spécifiée", "no_data_available": "Aucune donnée disponible pour la section {}", "conclusion": "Conclusion", "overall_assessment": "Évaluation générale :", "key_strengths": "Forces principales", "improvement_points": "Points d'amélioration", "no_conclusion": "Aucune conclusion disponible.", "general_requirements": "Exigences générales", "qualifications": "Qualifications", "audit_experience": "Expérience en audit", "advanced_requirements": "Exigences avancées", }, "en": { # Main texts "app_title": "CV Analysis according to GFSI Standards", "app_description": "GFSI CV Analysis Tool", "language": "Language", "french": "French", "english": "English", # Configuration "configuration": "Configuration", "api_key": "Groq API Key:", "api_key_help": "API key starts with 'gsk_'", "model": "AI Model:", "model_help": "Balance between analysis precision and speed", "models": { "llama-3.3-70b-versatile": "Llama 3.3 70B (High precision)", "llama-3.2-11b-versatile": "Llama 3.2 11B (Balanced)", "llama-3.1-8b-instant": "Llama 3.1 8B (Fast)", "kmi-k2-70b": "KMI K2 70B (Specialized)", "qwen3-72b": "QWEN 3 72B (Alibaba Cloud)" }, # Analysis options "analysis_options": "Analysis Options", "debug_mode": "Show raw data (Debug)", # Administration "administration": "Administration", "admin_password": "Admin password:", "access_admin": "Access admin mode", "exit_admin": "Exit admin mode", "admin_activated": "Admin mode activated ✅", "admin_password_incorrect": "Incorrect password", "create_referential": "Create new referential", "ai_assistant": "AI Assistant for referential creation", "paste_requirements": "Paste the requirements of the new standard here:", "generate_json": "Generate JSON", "generated_referential": "Generated referential (copy/paste to referentials.py):", "save_referential": "Save referential", "filename": "File name (without extension):", "referential_saved": "Referential saved in referentiels/{}.json", "error_saving": "Error saving", "referential_generated": "Referential generated successfully!", "error_generating": "Error generating referential", "please_enter_requirements": "Please enter requirements and configure your API key", # About "about": "About", "app_info": """ **GFSI CV Analysis Tool** Version 25.12 Supported standards: BRCGS, FSSC 22000, IFS """, # Usage guide "usage_guide": "Usage Guide", "usage_instructions": """ ### How to use this tool? 1. **Configuration**: - Enter your Groq API key in the sidebar - Select the AI model to use 2. **Analysis**: - Upload a CV in PDF format - Select the applicable GFSI standard - Launch the analysis 3. **Results**: - View the detailed report with references to requirements - Explore details by section (General, Qualifications, etc.) - Export results in HTML format **Tip**: The clearer the document is formatted, the better the analysis will be. """, # CV Analysis "cv_analysis": "CV Analysis", "configure_api": "⚠️ Please configure your Groq API key in the sidebar to continue.", "upload_cv": "📄 Upload a PDF file (CV)", "upload_help": "Supported formats: PDF. Maximum size: 10MB", "please_upload_cv": "Please upload a PDF file to start the analysis.", "referential_preview": "Preview of supported standards", "select_referential": "📋 Select a standard", "referential_help": "Choose the applicable GFSI standard for this candidate", "analyze_cv": "🔍 Analyze CV", "extracting_text": "Extracting text...", "no_pages": "The PDF contains no pages.", "no_text_extracted": "No text could be extracted from the PDF. Check if it's a scanned PDF.", "pdf_protected": "Tips: Check that the PDF is not protected or that it is not a scanned document without OCR.", "analyzing_cv": "In-depth CV analysis in progress...", "analysis_failed": "The analysis could not be properly structured. Displaying raw results.", "connection_error": "Error connecting to Groq API: {}", "api_key_invalid": "The API key seems invalid. Groq keys usually start with 'gsk_'.", "text_preview": "Text preview", "raw_analysis_data": "Raw analysis data (Debug)", "download_report": "📥 Download complete report", # Analysis results "analysis_summary": "📊 Analysis summary according to standard {}", "total_requirements": "📊 Total", "conformant": "✅ Conformant", "partially_conformant": "🟡 Partial", "non_conformant": "❌ Non-conformant", "compliance_rate": "📈 Compliance rate", "final_recommendation": "Final recommendation:", "major_strengths": "💪 Major strengths", "critical_gaps": "⚠️ Critical gaps", "development_opportunities": "📈 Development opportunities", "detailed_justification": "📝 Detailed justification", "no_justification": "No justification available.", "detailed_analysis": "📋 Detailed analysis of requirements", "category": "📁 {}", "requirement": "📋 Requirement", "evaluation": "Evaluation", "status": "Status:", "confidence_score": "Confidence score:", "elements_found": "🔍 Elements found", "no_elements": "No elements found", "justification": "🧠 Justification", "no_justification_detail": "No justification provided", "recommendations": "💡 Recommendations", "no_recommendations": "No recommendations", "requirement_not_specified": "Requirement not specified", "not_evaluated": "Not evaluated", "reference_not_specified": "Not specified", "no_data_available": "No data available for section {}", "conclusion": "Conclusion", "overall_assessment": "Overall assessment:", "key_strengths": "Key strengths", "improvement_points": "Improvement points", "no_conclusion": "No conclusion available.", "general_requirements": "General requirements", "qualifications": "Qualifications", "audit_experience": "Audit experience", "advanced_requirements": "Advanced requirements", } } def get_text(key, lang="fr"): """Get translated text for a given key and language""" return TRANSLATIONS.get(lang, TRANSLATIONS["fr"]).get(key, key) # Fonction pour configurer le client Groq avec validation def get_groq_client(api_key): """ Initialise et valide un client Groq avec la clé API fournie. Args: api_key (str): Clé API Groq Returns: Groq: Instance de client Groq ou None en cas d'erreur """ if not api_key or not api_key.startswith("gsk_"): st.error("La clé API semble invalide. Les clés Groq commencent généralement par 'gsk_'.") return None try: client = Groq(api_key=api_key) # Test de la connexion avec une requête minimale test_response = client.chat.completions.create( messages=[{"role": "user", "content": "Test de connexion"}], model="llama-3.1-8b-instant", max_tokens=10 ) if test_response: return client except Exception as e: st.error(f"Erreur de connexion à l'API Groq : {str(e)}") return None # Extraction améliorée de texte depuis un PDF def extract_text_from_pdf(file): """ Extrait le texte d'un fichier PDF avec gestion optimisée des erreurs. Args: file (UploadedFile): Fichier PDF téléchargé Returns: str: Texte extrait du PDF ou None en cas d'erreur """ try: with st.spinner("Extraction du texte en cours..."): reader = PdfReader(file) # Vérification des pages vides if len(reader.pages) == 0: st.warning("Le PDF ne contient aucune page.") return None # Extraction avec nettoyage des caractères spéciaux text_parts = [] for page in reader.pages: page_text = page.extract_text() if page_text: # Nettoyage des caractères problématiques page_text = re.sub(r'\s+', ' ', page_text) text_parts.append(page_text) if not text_parts: st.warning("Aucun texte n'a pu être extrait du PDF. Vérifiez qu'il ne s'agit pas d'un PDF scanné.") return None return " ".join(text_parts) except Exception as e: st.error(f"Erreur lors de l'extraction du texte : {str(e)}") st.info("Conseils: Vérifiez que le PDF n'est pas protégé ou qu'il ne s'agit pas d'un document scanné sans OCR.") return None # Analyse granulaire du CV avec l'API Groq et référentiel def analyze_cv_with_groq(cv_text, referential_name, groq_client, model="llama-3.3-70b-versatile"): """ Analyse approfondie du CV en fonction des référentiels GFSI avec analyse granulaire et pondération. Args: cv_text (str): Texte du CV à analyser referential_name (str): Nom du référentiel GFSI sélectionné groq_client (Groq): Instance de client Groq model (str): Modèle LLM à utiliser Returns: dict: Résultats structurés de l'analyse ou None en cas d'erreur """ referential_data = REFERENTIALS.get(referential_name, {}) # Vérifier si c'est un référentiel au nouveau format (avec catégories pondérées) if "categories" in referential_data: # Nouveau format avec analyse granulaire return analyze_cv_granular(cv_text, referential_name, referential_data, groq_client, model) else: # Ancien format - utiliser l'analyse existante return analyze_cv_traditional(cv_text, referential_name, referential_data, groq_client, model) def analyze_cv_granular(cv_text, referential_name, referential_data, groq_client, model): """ Analyse granulaire avec pondération et référencement précis. """ # Construction d'un prompt structuré optimisé prompt = create_enhanced_analysis_prompt(cv_text, referential_data, referential_name) try: with st.spinner("Analyse approfondie du CV en cours..."): messages = [ {"role": "system", "content": "Vous êtes un expert en conformité GFSI qui fournit des analyses structurées avec références systématiques aux exigences."}, {"role": "user", "content": prompt} ] response = groq_client.chat.completions.create( messages=messages, model=model, max_tokens=4000, temperature=0.1, response_format={"type": "json_object"} ) # Parsing de la réponse en JSON try: result = json.loads(response.choices[0].message.content) return result except json.JSONDecodeError: # Si le parsing JSON échoue, tenter de récupérer le contenu brut content = response.choices[0].message.content st.warning("L'analyse n'a pas pu être structurée correctement. Affichage des résultats bruts.") return {"raw_content": content} except Exception as e: st.error(f"Erreur lors de l'analyse du CV : {str(e)}") return None def analyze_cv_traditional(cv_text, referential_name, referential_data, groq_client, model): """ Analyse traditionnelle pour les anciens référentiels. """ # Structuration des exigences pour analyse systématique requirements_categories = { "General_Requirements": referential_data.get("General_Requirements", {}), "Qualifications": referential_data.get("Qualifications", {}), "Audit_Experience": referential_data.get("Audit_Experience", {}), "Advanced_Requirements": referential_data.get("Advanced_Requirements", {}) } # Construction d'un prompt structuré pour obtenir une réponse analysable prompt = f""" Vous êtes un expert en évaluation des compétences selon les référentiels GFSI. TÂCHE: Analysez ce CV pour vérifier sa conformité avec le référentiel {referential_name} de manière systématique. INSTRUCTIONS: 1. Ne jamais mentionner le nom du candidat - utilisez toujours "le candidat" 2. Pour chaque exigence, fournissez: - La référence exacte de l'exigence (code/numéro) - Votre évaluation avec STATUT: CONFORME, NON CONFORME, ou PARTIELLEMENT CONFORME - Les éléments du CV justifiant votre évaluation - Des recommandations spécifiques si nécessaire 3. Structurez votre réponse exactement selon le format JSON demandé à la fin RÉFÉRENTIEL {referential_name} - EXIGENCES: SECTION 1: EXIGENCES GÉNÉRALES {json.dumps(requirements_categories["General_Requirements"], ensure_ascii=False, indent=2)} SECTION 2: QUALIFICATIONS {json.dumps(requirements_categories["Qualifications"], ensure_ascii=False, indent=2)} SECTION 3: EXPÉRIENCE EN AUDIT {json.dumps(requirements_categories["Audit_Experience"], ensure_ascii=False, indent=2)} SECTION 4: EXIGENCES AVANCÉES {json.dumps(requirements_categories["Advanced_Requirements"], ensure_ascii=False, indent=2)} CV DU CANDIDAT: {cv_text} INSTRUCTIONS SUPPLÉMENTAIRES: - Vérifiez chaque formation et expérience plusieurs fois, car les terminologies peuvent varier - Évaluez si l'équivalence des formations est acceptable selon le référentiel - Identifiez précisément chaque lacune avec référence à l'exigence spécifique FORMAT DE RÉPONSE: Fournissez votre analyse au format JSON avec la structure suivante: {{ "analysis": {{ "general_requirements": [ {{ "reference": "REF-CODE-1", "requirement": "Description de l'exigence", "status": "CONFORME/NON CONFORME/PARTIELLEMENT CONFORME", "evidence": "Éléments du CV justifiant l'évaluation", "recommendations": "Recommandations si nécessaire" }} ], "qualifications": [...], "audit_experience": [...], "advanced_requirements": [...] }}, "summary": {{ "conformant_count": 12, "non_conformant_count": 3, "partially_conformant_count": 2, "overall_assessment": "CONFORME/NON CONFORME/PARTIELLEMENT CONFORME", "key_strengths": ["Force 1", "Force 2"], "key_gaps": ["Lacune 1", "Lacune 2"], "conclusion": "Conclusion générale sur l'adéquation du candidat" }} }} IMPORTANT: Assurez-vous que votre réponse soit un JSON valide et bien structuré. """ try: with st.spinner("Analyse approfondie du CV en cours..."): messages = [ {"role": "system", "content": "Vous êtes un expert en conformité GFSI qui fournit des analyses structurées avec références systématiques aux exigences."}, {"role": "user", "content": prompt} ] response = groq_client.chat.completions.create( messages=messages, model=model, max_tokens=4000, temperature=0.1, response_format={"type": "json_object"} ) # Parsing de la réponse en JSON try: result = json.loads(response.choices[0].message.content) return result except json.JSONDecodeError: # Si le parsing JSON échoue, tenter de récupérer le contenu brut content = response.choices[0].message.content st.warning("L'analyse n'a pas pu être structurée correctement. Affichage des résultats bruts.") return {"raw_content": content} except Exception as e: st.error(f"Erreur lors de l'analyse du CV : {str(e)}") return None def create_enhanced_analysis_prompt(cv_text, referential_data, referential_name): """ Crée un prompt optimisé pour l'analyse granulaire avec pondération. """ # Construction progressive du prompt prompt_parts = [] # 1. En-tête et contexte prompt_parts.append(f""" EXPERT EN ÉVALUATION DE CONFORMITÉ GFSI - ANALYSE STRUCTURÉE TÂCHE : Analyser ce CV selon le référentiel {referential_name} FORMAT DE RÉPONSE : JSON strict (obligatoire) CONFIDENTIALITÉ : Ne jamais mentionner le nom du candidat MÉTHODOLOGIE D'ANALYSE REQUISE : 1. LECTURE APPROFONDIE du CV et du référentiel 2. ANALYSE EXIGENCE PAR EXIGENCE avec référencement systématique 3. JUSTIFICATION précise avec citations du CV 4. ÉVALUATION OBJECTIVE selon critères définis """) # 2. Structure détaillée du référentiel prompt_parts.append("STRUCTURE DU RÉFÉRENTIEL À ANALYSER :") for category_name, category_data in referential_data.get("categories", {}).items(): prompt_parts.append(f"\nCATÉGORIE : {category_name} (Poids: {category_data.get('weight', 0)})") prompt_parts.append(f"Description: {category_data.get('description', '')}") prompt_parts.append("EXIGENCES À VÉRIFIER :") for subcategory_name, subcategory_data in category_data.get("subcategories", {}).items(): prompt_parts.append(f" SOUS-CATÉGORIE : {subcategory_name} (Poids: {subcategory_data.get('weight', 0)})") for i, req in enumerate(subcategory_data.get("requirements", []), 1): prompt_parts.append(f" [{req.get('id', f'{category_name[:3].upper()}-{subcategory_name[:3].upper()}-{i:02d}')}]" + f" {req.get('text', 'Exigence non définie')}") if req.get('critical', False): prompt_parts.append(" ⚠️ EXIGENCE CRITIQUE") prompt_parts.append(f" Acceptable minimum: {req.get('minimum_acceptable', 'Non spécifié')}") # 3. CV du candidat prompt_parts.append(f"\nCV DU CANDIDAT À ANALYSER :\n{cv_text[:8000]}...") # Limite pour éviter dépassement tokens # 4. Instructions détaillées d'analyse prompt_parts.append(""" INSTRUCTIONS D'ANALYSE DÉTAILLÉES : POUR CHAQUE EXIGENCE, FOURNIR : 1. RÉFÉRENCE EXACTE de l'exigence analysée 2. TEXTE EXACT de l'exigence du référentiel 3. ÉLÉMENTS TROUVÉS dans le CV (citations précises avec dates si disponibles) 4. ANALYSE CRITIQUE avec justification objective 5. STATUT : CONFORME | PARTIELLEMENT CONFORME | NON CONFORME 6. SCORE DE CONFIANCE : 0.0 à 1.0 (précision de l'analyse) 7. RECOMMANDATIONS concrètes si non-conforme CRITÈRES D'ÉVALUATION : 🟢 CONFORME : Exigence clairement satisfaite avec preuves concrètes 🟡 PARTIELLEMENT CONFORME : Équivalence acceptable ou expérience partielle 🔴 NON CONFORME : Exigence clairement absente ou insuffisamment démontrée FORMAT JSON OBLIGATOIRE : { "analysis_metadata": { "referential": "nom_du_referentiel", "analysis_timestamp": "date_ISO8601", "total_requirements_analyzed": 0, "confidence_level": 0.0 }, "detailed_evaluation": [ { "requirement_reference": "REF-CODE-01", "requirement_category": "Nom de la catégorie", "requirement_text": "Texte exact de l'exigence", "candidate_evidence": "Citations précises du CV avec dates", "analysis_justification": "Explication détaillée de l'évaluation", "compliance_status": "CONFORME/PARTIELLEMENT CONFORME/NON CONFORME", "confidence_score": 0.95, "recommendations": "Actions spécifiques pour amélioration" } ], "summary_analysis": { "compliance_statistics": { "total_requirements": 0, "conformant": 0, "partially_conformant": 0, "non_conformant": 0, "compliance_rate_percentage": 0.0 }, "key_findings": { "major_strengths": ["Force principale 1"], "critical_gaps": ["Lacune critique 1"], "development_opportunities": ["Opportunité de développement 1"] }, "final_recommendation": "RECOMMANDÉ/À AMÉLIORER/À REJETER", "detailed_justification": "Justification globale de la recommandation" } } IMPORTANT : - Respecter ABSOLUMENT le format JSON spécifié - Fournir des citations précises du CV - Être objectif et factuel dans les évaluations - Ne pas faire d'assomptions non fondées - Inclure des scores de confiance réalistes """) return "\n".join(prompt_parts) # Affichage amélioré des résultats d'analyse def display_analysis_results(analysis_result, referential): """ Affiche les résultats de l'analyse de manière structurée et visuelle. Args: analysis_result (dict): Résultats de l'analyse referential (str): Référentiel GFSI utilisé pour l'analyse """ if not analysis_result: return # Cas où le résultat est brut (non JSON) if "raw_content" in analysis_result: st.markdown( f"""
{analysis_result["raw_content"]}
""", unsafe_allow_html=True ) return # Vérifier si c'est le nouveau format granulaire if "detailed_evaluation" in analysis_result: display_granular_analysis_results(analysis_result, referential) else: display_traditional_analysis_results(analysis_result, referential) def display_granular_analysis_results(analysis_result, referential): """ Affiche les résultats de l'analyse granulaire avec pondération. """ # Affichage du résumé global st.markdown(f"## 📊 Résumé de l'analyse selon le référentiel {referential}") summary_analysis = analysis_result.get("summary_analysis", {}) compliance_stats = summary_analysis.get("compliance_statistics", {}) conformant = compliance_stats.get("conformant", 0) non_conformant = compliance_stats.get("non_conformant", 0) partially_conformant = compliance_stats.get("partially_conformant", 0) total = compliance_stats.get("total_requirements", 0) # Affichage des statistiques avec indicateurs visuels col1, col2, col3, col4, col5 = st.columns(5) with col1: st.metric("📊 Total", total) with col2: st.metric("✅ Conformes", conformant, f"{int(conformant/total*100 if total else 0)}%") with col3: st.metric("🟡 Partiel", partially_conformant, f"{int(partially_conformant/total*100 if total else 0)}%") with col4: st.metric("❌ Non conformes", non_conformant, f"{int(non_conformant/total*100 if total else 0)}%") with col5: compliance_rate = compliance_stats.get("compliance_rate_percentage", 0) st.metric("📈 Taux de conformité", f"{compliance_rate:.1f}%") # Conclusion globale avec couleur selon le niveau final_recommendation = summary_analysis.get("final_recommendation", "Non déterminée") recommendation_color = { "RECOMMANDÉ": "#28a745", "À AMÉLIORER": "#ffc107", "À REJETER": "#dc3545" }.get(final_recommendation, "#6c757d") st.markdown( f"""
Recommandation finale : {final_recommendation}
""", unsafe_allow_html=True ) # Forces et lacunes key_findings = summary_analysis.get("key_findings", {}) col1, col2, col3 = st.columns(3) with col1: st.markdown("### 💪 Forces principales") for strength in key_findings.get("major_strengths", []): st.markdown(f"✅ {strength}") with col2: st.markdown("### ⚠️ Lacunes critiques") for gap in key_findings.get("critical_gaps", []): st.markdown(f"❌ {gap}") with col3: st.markdown("### 📈 Opportunités") for opportunity in key_findings.get("development_opportunities", []): st.markdown(f"📈 {opportunity}") # Justification détaillée st.markdown("### 📝 Justification") st.markdown(summary_analysis.get("detailed_justification", "Aucune justification disponible.")) # Affichage détaillé des exigences analysées st.markdown("## 📋 Analyse détaillée des exigences") detailed_evaluation = analysis_result.get("detailed_evaluation", []) # Regrouper par catégorie pour affichage organisé categories = {} for item in detailed_evaluation: category = item.get("requirement_category", "Non catégorisé") if category not in categories: categories[category] = [] categories[category].append(item) # Création d'onglets pour chaque catégorie if categories: tabs = st.tabs(list(categories.keys())) for i, (category_name, category_items) in enumerate(categories.items()): with tabs[i]: st.markdown(f"### 📁 {category_name}") # Tri par statut (conforme d'abord, puis partiel, puis non conforme) sorted_items = sorted(category_items, key=lambda x: ( 0 if x.get("compliance_status") == "CONFORME" else 1 if x.get("compliance_status") == "PARTIELLEMENT CONFORME" else 2 )) for item in sorted_items: # Couleur en fonction du statut status = item.get("compliance_status", "") status_color = { "CONFORME": "#28a745", "PARTIELLEMENT CONFORME": "#ffc107", "NON CONFORME": "#dc3545" }.get(status, "#6c757d") status_emoji = { "CONFORME": "✅", "PARTIELLEMENT CONFORME": "🟡", "NON CONFORME": "❌" }.get(status, "❓") # Création d'un expander pour chaque exigence expander_title = f"{status_emoji} {item.get('requirement_reference', 'REF')} - {status} ({item.get('confidence_score', 0):.2f})" with st.expander(expander_title): st.markdown(f"**📋 Exigence**") st.write(item.get('requirement_text', 'Exigence non spécifiée')) st.markdown(f"**{status_emoji} Évaluation**") st.markdown(f"**Statut:** {status}") st.markdown(f"**Score de confiance:** {item.get('confidence_score', 0):.2f}/1.00") st.markdown(f"**🔍 Éléments trouvés**") st.info(item.get('candidate_evidence', 'Aucun élément trouvé')) st.markdown(f"**🧠 Justification**") st.write(item.get('analysis_justification', 'Aucune justification fournie')) st.markdown(f"**💡 Recommandations**") st.success(item.get('recommendations', 'Aucune recommandation')) def display_traditional_analysis_results(analysis_result, referential): """ Affiche les résultats de l'analyse traditionnelle (pour compatibilité). """ # Affichage du résumé global st.markdown(f"## Résumé de l'analyse selon le référentiel {referential}") summary = analysis_result.get("summary", {}) conformant = summary.get("conformant_count", 0) non_conformant = summary.get("non_conformant_count", 0) partially = summary.get("partially_conformant_count", 0) total = conformant + non_conformant + partially # Affichage des statistiques col1, col2, col3, col4 = st.columns(4) with col1: st.metric("Total des exigences", total) with col2: st.metric("Conformes", conformant, f"{int(conformant/total*100 if total else 0)}%") with col3: st.metric("Non conformes", non_conformant, f"{int(non_conformant/total*100 if total else 0)}%") with col4: st.metric("Partiellement conformes", partially, f"{int(partially/total*100 if total else 0)}%") # Conclusion globale conclusion_color = { "CONFORME": "#28a745", "NON CONFORME": "#dc3545", "PARTIELLEMENT CONFORME": "#ffc107" }.get(summary.get("overall_assessment", ""), "#6c757d") st.markdown( f"""
Évaluation générale : {summary.get("overall_assessment", "Non déterminée")}
""", unsafe_allow_html=True ) # Forces et lacunes col1, col2 = st.columns(2) with col1: st.markdown("### Forces principales") for strength in summary.get("key_strengths", []): st.markdown(f"✅ {strength}") with col2: st.markdown("### Points d'amélioration") for gap in summary.get("key_gaps", []): st.markdown(f"❌ {gap}") # Conclusion détaillée st.markdown("### Conclusion") st.markdown(summary.get("conclusion", "Aucune conclusion disponible.")) # Affichage détaillé des sections d'analyse analysis = analysis_result.get("analysis", {}) # Liste des sections pour affichage uniforme sections = [ ("Exigences générales", analysis.get("general_requirements", [])), ("Qualifications", analysis.get("qualifications", [])), ("Expérience en audit", analysis.get("audit_experience", [])), ("Exigences avancées", analysis.get("advanced_requirements", [])) ] # Création d'onglets pour chaque section tabs = st.tabs([section[0] for section in sections]) # Affichage du contenu de chaque section dans son onglet for i, (section_name, section_data) in enumerate(sections): with tabs[i]: if not section_data: st.info(f"Aucune donnée disponible pour la section {section_name}") continue for item in section_data: # Couleur en fonction du statut status_color = { "CONFORME": "#28a745", "NON CONFORME": "#dc3545", "PARTIELLEMENT CONFORME": "#ffc107" }.get(item.get("status", ""), "#6c757d") # Création d'un expander pour chaque exigence with st.expander(f"{item.get('reference', 'REF')} - {item.get('requirement', 'Exigence')} ({item.get('status', 'Non évalué')})"): st.markdown( f"""

Référence: {item.get('reference', 'Non spécifiée')}

Exigence: {item.get('requirement', 'Non spécifiée')}

Statut: {item.get('status', 'Non évalué')}

Éléments justificatifs: {item.get('evidence', 'Aucun')}

Recommandations: {item.get('recommendations', 'Aucune')}

""", unsafe_allow_html=True ) # Génération d'un rapport exportable def generate_exportable_report(analysis_result, referential, cv_text): """ Génère un rapport exportable basé sur l'analyse du CV. Args: analysis_result (dict): Résultats de l'analyse referential (str): Référentiel utilisé cv_text (str): Texte du CV analysé Returns: str: HTML du rapport """ if not analysis_result or "raw_content" in analysis_result: return None # Vérifier si c'est le nouveau format granulaire if "detailed_evaluation" in analysis_result: return generate_granular_report(analysis_result, referential, cv_text) else: return generate_traditional_report(analysis_result, referential, cv_text) def generate_granular_report(analysis_result, referential, cv_text): """ Génère un rapport pour le format d'analyse granulaire. """ summary_analysis = analysis_result.get("summary_analysis", {}) compliance_stats = summary_analysis.get("compliance_statistics", {}) key_findings = summary_analysis.get("key_findings", {}) html = f""" Rapport d'analyse CV - {referential}

Rapport d'analyse de CV

Référentiel: {referential}

Date: {pd.Timestamp.now().strftime('%d/%m/%Y %H:%M')}

📊 Résumé de l'analyse

{compliance_stats.get('total_requirements', 0)}
Total des exigences
{compliance_stats.get('conformant', 0)}
Conformes
{compliance_stats.get('partially_conformant', 0)}
Partiellement conformes
{compliance_stats.get('non_conformant', 0)}
Non conformes
{compliance_stats.get('compliance_rate_percentage', 0):.1f}%
Taux de conformité
""" # Recommandation finale final_recommendation = summary_analysis.get("final_recommendation", "Non déterminée") rec_class = "" if "RECOMMANDÉ" in final_recommendation: rec_class = "conforme-rec" elif "À AMÉLIORER" in final_recommendation: rec_class = "ameliorer-rec" elif "À REJETER" in final_recommendation: rec_class = "rejeter-rec" html += f"""
Recommandation finale: {final_recommendation}
""" # Forces et lacunes html += """

💪 Forces principales

    """ for strength in key_findings.get("major_strengths", []): html += f"
  • {strength}
    • " html += """

⚠️ Lacunes critiques

    """ for gap in key_findings.get("critical_gaps", []): html += f"
  • {gap}
    • " html += """

📈 Opportunités

    """ for opportunity in key_findings.get("development_opportunities", []): html += f"
  • {opportunity}
    • " html += """
""" # Justification détaillée html += f"""

📝 Justification détaillée

{summary_analysis.get("detailed_justification", "Aucune justification disponible.")}

""" # Analyse détaillée des exigences html += """

📋 Analyse détaillée des exigences

""" detailed_evaluation = analysis_result.get("detailed_evaluation", []) # Regrouper par catégorie categories = {} for item in detailed_evaluation: category = item.get("requirement_category", "Non catégorisé") if category not in categories: categories[category] = [] categories[category].append(item) for category_name, category_items in categories.items(): html += f'
📁 {category_name}
' html += """ """ for item in category_items: status = item.get("compliance_status", "") status_color = { "CONFORME": "#28a745", "PARTIELLEMENT CONFORME": "#ffc107", "NON CONFORME": "#dc3545" }.get(status, "#6c757d") html += f""" """ html += """
Référence Exigence Statut Confiance Éléments trouvés Recommandations
{item.get('requirement_reference', 'REF')} {item.get('requirement_text', 'Exigence non spécifiée')} {status} {item.get('confidence_score', 0):.2f} {item.get('candidate_evidence', 'Aucun élément trouvé')} {item.get('recommendations', 'Aucune recommandation')}
""" html += """
""" return html def generate_traditional_report(analysis_result, referential, cv_text): """ Génère un rapport pour le format d'analyse traditionnel (pour compatibilité). """ summary = analysis_result.get("summary", {}) analysis = analysis_result.get("analysis", {}) html = f""" Rapport d'analyse CV - {referential}

Rapport d'analyse de CV

Référentiel: {referential}

Date: {pd.Timestamp.now().strftime('%d/%m/%Y')}

Résumé de l'analyse

Exigences conformes Exigences non conformes Exigences partiellement conformes Évaluation générale
{summary.get('conformant_count', 0)} {summary.get('non_conformant_count', 0)} {summary.get('partially_conformant_count', 0)} {summary.get('overall_assessment', 'Non déterminée')}

Forces principales

Points d'amélioration

Conclusion

{summary.get('conclusion', 'Aucune conclusion disponible.')}

""" # Ajout des sections détaillées sections = [ ("Exigences générales", analysis.get("general_requirements", [])), ("Qualifications", analysis.get("qualifications", [])), ("Expérience en audit", analysis.get("audit_experience", [])), ("Exigences avancées", analysis.get("advanced_requirements", [])) ] for section_name, section_data in sections: html += f"""

{section_name}

""" if not section_data: html += "

Aucune donnée disponible pour cette section

" else: for item in section_data: status = item.get('status', '') status_class = "" if "CONFORME" in status and "NON" not in status: status_class = "conforme" elif "NON CONFORME" in status: status_class = "non-conforme" elif "PARTIELLEMENT" in status: status_class = "partiel" html += f"""

{item.get('reference', 'REF')} - {item.get('requirement', 'Exigence')}

Statut: {status}

Éléments justificatifs: {item.get('evidence', 'Aucun')}

Recommandations: {item.get('recommendations', 'Aucune')}

""" html += "
" html += """ """ return html # Fonction principale améliorée def main(): """ Interface principale améliorée avec fonctionnalités d'exportation et statistiques. """ # Barre latérale pour configuration with st.sidebar: st.image("https://via.placeholder.com/150x60?text=GFSI+Analyzer", width=150) st.title("Configuration") # Gestion de la clé API avec sauvegarde dans session_state if "api_key" not in st.session_state: st.session_state.api_key = "" api_key = st.text_input( "Clé API Groq :", value=st.session_state.api_key, type="password", help="La clé API commence par 'gsk_'" ) if api_key != st.session_state.api_key: st.session_state.api_key = api_key st.session_state.groq_client = None if not api_key else get_groq_client(api_key) if "groq_client" not in st.session_state: st.session_state.groq_client = None if not api_key else get_groq_client(api_key) # Sélection du modèle model_options = { "llama-3.3-70b-versatile": "Llama 3.3 70B (Haute précision)", "meta-llama/llama-4-maverick-17b-128e-instruct": "Llama 4 Maverick", "llama-3.1-8b-instant": "Llama 3.1 8B (Rapide)", "moonshotai/kimi-k2-instruct": "KMI K2 70B (Spécialisé)", "qwen/qwen3-32b": "QWEN 3 72B (Alibaba Cloud)" } selected_model = st.selectbox( "Modèle d'IA:", options=list(model_options.keys()), format_func=lambda x: model_options[x], help="Balance entre précision d'analyse et vitesse" ) st.markdown("---") st.markdown("### Options d'analyse") # Options de debug pour développement show_debug = st.checkbox("Afficher les données brutes (Debug)", False) # Interface admin pour création de référentiels st.markdown("---") st.markdown("### 🔐 Administration") if "admin_mode" not in st.session_state: st.session_state.admin_mode = False if not st.session_state.admin_mode: admin_password = st.text_input("Mot de passe admin :", type="password") if st.button("🔐 Accéder au mode admin"): if is_admin_authenticated(admin_password): st.session_state.admin_mode = True st.success("Mode admin activé !") st.rerun() else: st.error("Mot de passe incorrect") else: st.success("Mode admin activé ✅") if st.button("🚪 Quitter le mode admin"): st.session_state.admin_mode = False st.rerun() # Interface de création de référentiel with st.expander("➕ Créer un nouveau référentiel"): st.markdown("### Assistant IA de création de référentiel") exigences_texte = st.text_area("Collez ici les exigences du nouveau standard :", height=300) if st.button("🤖 Générer le JSON"): if exigences_texte and st.session_state.groq_client: with st.spinner("Génération du référentiel en cours..."): referential_json = create_referential_with_ai(exigences_texte, st.session_state.groq_client) if referential_json: st.session_state.generated_referential = referential_json st.success("Référentiel généré avec succès !") st.json(referential_json) else: st.error("Erreur lors de la génération du référentiel") else: st.warning("Veuillez saisir les exigences et configurer votre clé API") # Afficher le référentiel généré s'il existe if "generated_referential" in st.session_state: st.markdown("### Référentiel généré (à copier/coller dans referentials.py) :") st.code(json.dumps(st.session_state.generated_referential, indent=2, ensure_ascii=False), language="json") # Option de sauvegarde filename = st.text_input("Nom du fichier (sans extension) :", value=st.session_state.generated_referential.get("metadata", {}).get("name", "nouveau_referentiel")) if st.button("💾 Sauvegarder le référentiel"): if save_referential_to_json(st.session_state.generated_referential, filename): st.success(f"Référentiel sauvegardé dans referentiels/{filename}.json") # Recharger les référentiels global REFERENTIALS REFERENTIALS = load_referentials_from_json() else: st.error("Erreur lors de la sauvegarde") # Informations supplémentaires st.markdown("---") st.markdown("### À propos") st.info(""" **Outil d'analyse CV - GFSI** Version 25.12 Référentiels supportés : BRCGS, FSSC 22000, IFS """) # Contenu principal st.title("Analyse de CV selon les Référentiels GFSI") st.markdown("---") # Panneau d'information avec des instructions complètes with st.expander("ℹ️ Guide d'utilisation", expanded=True): st.markdown(""" ### Comment utiliser cet outil? 1. **Configuration**: - Saisissez votre clé API Groq dans le panneau latéral - Sélectionnez le modèle d'IA à utiliser 2. **Analyse**: - Téléchargez un CV au format PDF - Sélectionnez le référentiel GFSI applicable - Lancez l'analyse 3. **Résultats**: - Consultez le rapport détaillé avec références aux exigences - Explorez les détails par section (Général, Qualifications, etc.) - Exportez les résultats au format HTML **Astuce**: Plus le document est clairement formaté, meilleure sera l'analyse. """) # Contenu principal - Interface d'analyse st.markdown("## Analyse de CV") # Vérification de la présence du client Groq if not st.session_state.groq_client: st.warning("⚠️ Veuillez configurer votre clé API Groq dans le panneau latéral pour continuer.") return # Chargement du fichier PDF uploaded_file = st.file_uploader( "📄 Téléchargez un fichier PDF (CV)", type="pdf", help="Formats supportés : PDF. Taille maximale: 10MB" ) if not uploaded_file: st.info("Veuillez télécharger un fichier PDF pour commencer l'analyse.") # Affichage d'exemples des référentiels st.markdown("### Aperçu des référentiels supportés") for ref_name, ref_data in REFERENTIALS.items(): with st.expander(f"Référentiel {ref_name}"): st.json(ref_data) return # Sélection du référentiel referential = st.selectbox( "📋 Sélectionnez un référentiel", list(REFERENTIALS.keys()), help="Choisissez le standard GFSI applicable pour ce candidat" ) # Vérification que tous les éléments nécessaires sont présents if uploaded_file and referential and st.session_state.groq_client: # Bouton pour lancer l'analyse if st.button("🔍 Analyser le CV", type="primary"): # Extraction du texte du CV cv_text = extract_text_from_pdf(uploaded_file) # Afficher un extrait du texte extrait en mode debug if show_debug and cv_text: with st.expander("Aperçu du texte extrait", expanded=False): st.text(cv_text[:1000] + "..." if len(cv_text) > 1000 else cv_text) if cv_text: # Analyse du CV avec références systématiques analysis_result = analyze_cv_with_groq( cv_text, referential, st.session_state.groq_client, model=selected_model ) # Affichage des données brutes en mode debug if show_debug and analysis_result: with st.expander("Données brutes de l'analyse (Debug)", expanded=False): st.json(analysis_result) # Affichage des résultats if analysis_result: # Affichage structuré des résultats display_analysis_results(analysis_result, referential) # Génération et téléchargement du rapport report_html = generate_exportable_report(analysis_result, referential, cv_text) if report_html: st.download_button( label="📥 Télécharger le rapport complet", data=report_html, file_name=f"analyse_cv_{referential}_{pd.Timestamp.now().strftime('%Y%m%d_%H%M')}.html", mime="text/html", ) if __name__ == "__main__": main()