fix models

README.md

@@ -8,189 +8,170 @@ pinned: false
 license: mit
 ---
 
-# MedWin Analyzer 🏥
-
-Une API intelligente pour l'analyse de rapports médicaux utilisant 3 modèles de Machine Learning spécialisés.
-
-## 🚀 Fonctionnalités
-
-### 📊 **Modèle 1: HendSta/analyse_medicale**
-- **Fonction**: Prédiction de paramètres médicaux
-- **Endpoint**: `/predict`
-- **Utilisation**: Analyse et classification des paramètres biologiques
-
-### ⚠️ **Modèle 2: HendSta/analyse_row**
-- **Fonction**: Analyse de risque
-- **Endpoint**: `/analyze-risk`
-- **Utilisation**: Évaluation du niveau de risque des anomalies biologiques
-
-### 🧠 **Modèle 3: HendSta/biomistral-finetuned-fullv3**
-- **Fonction**: Prédiction de maladies
-- **Endpoint**: `/predict-disease`
-- **Utilisation**: Diagnostic basé sur les paramètres anormaux
-
-## 📋 Endpoints API
-
-### 1. **GET /** - Informations générales
-```bash
-curl https://huggingface.co/spaces/HendSta/MedWin-Analyzer
-```
-
-### 2. **POST /predict** - Prédiction de paramètres
-```bash
-curl -X POST "https://huggingface.co/spaces/HendSta/MedWin-Analyzer/predict" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "CodeParametre": "gly",
-    "ValeurActuelle": 6.2,
-    "Unite": "mmol/L",
-    "ValeursUsuelles": "3.9-6.1",
-    "ValeurUsuelleMin": 3.9,
-    "ValeurUsuelleMax": 6.1
-  }'
-```
-
-### 3. **POST /upload-pdf** - Analyse de fichiers PDF/XML
-```bash
-curl -X POST "https://huggingface.co/spaces/HendSta/MedWin-Analyzer/upload-pdf" \
-  -F "file=@rapport_medical.pdf"
-```
-
-### 4. **POST /analyze-risk** - Analyse de risque
-```bash
-curl -X POST "https://huggingface.co/spaces/HendSta/MedWin-Analyzer/analyze-risk" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "CodeParametre": "gly",
-    "ValeurActuelle": 6.2,
-    "Unite": "mmol/L",
-    "ValeursUsuelles": "3.9-6.1",
-    "ValeurUsuelleMin": 3.9,
-    "ValeurUsuelleMax": 6.1,
-    "CodParametre": "GLY"
-  }'
-```
-
-### 5. **POST /predict-disease** - Prédiction de maladies
-```bash
-curl -X POST "https://huggingface.co/spaces/HendSta/MedWin-Analyzer/predict-disease" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "risk_results": [
-      {
-        "statut_risque": "ÉLEVÉ",
-        "degre_risque": "Modéré"
-      }
-    ],
-    "analysis_result": [
-      {
-        "LibParametre": "Glycémie",
-        "ValeurActuelle": 6.2,
-        "Unite": "mmol/L",
-        "ValeursUsuelles": "3.9-6.1"
-      }
-    ]
-  }'
-```
-
-## 🔧 Technologies utilisées
-
-- **FastAPI**: Framework web moderne et rapide
-- **Transformers**: Modèles de langage Hugging Face
-- **PyTorch**: Deep Learning
-- **Pandas**: Manipulation de données
-- **Scikit-learn**: Machine Learning
-- **PDFPlumber**: Extraction de texte PDF
-- **Joblib**: Sauvegarde/chargement de modèles
-
-## 📁 Structure du projet
+# MedWin-Analyzer - Hugging Face Space
 
-```
-MedWin-Analyzer/
-├── app.py              # Application FastAPI principale
-├── requirements.txt    # Dépendances Python
-├── Dockerfile         # Configuration Docker
-└── README.md          # Documentation
-```
+Ce repository contient une application FastAPI déployée sur Hugging Face Spaces pour l'analyse de rapports médicaux.
 
-## 🚀 Démarrage rapide
+## 🚀 Modèles Utilisés
 
-1. **Cloner le repository**:
-```bash
-git clone https://huggingface.co/spaces/HendSta/MedWin-Analyzer
-cd MedWin-Analyzer
-```
+L'application utilise trois modèles hébergés sur Hugging Face :
 
-2. **Installer les dépendances**:
-```bash
-pip install -r requirements.txt
-```
+1. **HendSta/analyse_medicale** - Modèle d'analyse médicale pour la classification des paramètres
+2. **HendSta/analyse_row** - Modèle d'analyse de risque pour évaluer les niveaux de risque
+3. **HendSta/biomistral-finetuned-fullv3** - Modèle LLM pour l'analyse textuelle avancée
+
+## 📋 Endpoints Disponibles
 
-3. **Lancer l'application**:
-```bash
-python app.py
+### 1. Health Check
+```
+GET /health
+```
+Vérifie que tous les modèles sont chargés correctement.
+
+**Réponse :**
+```json
+{
+  "status": "healthy",
+  "models_loaded": {
+    "analyse_medicale_model": true,
+    "analyze_risk_model": true,
+    "llm_model": true,
+    "llm_tokenizer": true
+  },
+  "message": "Tous les modèles sont chargés"
+}
 ```
 
-L'API sera disponible sur `http://localhost:7860`
+### 2. Prédiction Simple
+```
+POST /predict
+```
+Effectue une prédiction sur un seul paramètre.
+
+**Body :**
+```json
+{
+  "CodeParametre": "glucose",
+  "ValeurActuelle": 120.0,
+  "Unite": "mg/dL",
+  "ValeursUsuelles": "70-100",
+  "ValeurUsuelleMin": 70.0,
+  "ValeurUsuelleMax": 100.0,
+  "ValeurAnterieure": 110.0,
+  "DateAnterieure": "01/01/2024"
+}
+```
 
-## 📊 Exemples d'utilisation
+### 3. Upload PDF/XML
+```
+POST /upload-pdf
+```
+Traite un fichier PDF ou XML et retourne l'analyse de tous les paramètres.
 
-### Analyse d'un rapport PDF
-```python
-import requests
+**Body :** `multipart/form-data` avec le fichier
 
-# Upload d'un fichier PDF
-with open('rapport.pdf', 'rb') as f:
-    files = {'file': f}
-    response = requests.post(
-        'https://huggingface.co/spaces/HendSta/MedWin-Analyzer/upload-pdf',
-        files=files
-    )
-    results = response.json()
-    print(results)
+### 4. Analyse de Risque
+```
+POST /analyze-risk
+```
+Analyse le niveau de risque d'un paramètre médical.
+
+**Body :**
+```json
+{
+  "CodeParametre": "glucose",
+  "ValeurActuelle": 120.0,
+  "Unite": "mg/dL",
+  "ValeursUsuelles": "70-100",
+  "ValeurUsuelleMin": 70.0,
+  "ValeurUsuelleMax": 100.0,
+  "ValeurAnterieure": 110.0,
+  "CodParametre": "GLU"
+}
 ```
 
-### Analyse de risque
-```python
-import requests
+**Réponse :**
+```json
+{
+  "parametre": "glucose",
+  "valeur_actuelle": 120.0,
+  "unite": "mg/dL",
+  "valeur_anterieure": 110.0,
+  "valeurs_usuelles": "70-100",
+  "statut_risque": "ÉLEVÉ",
+  "degre_risque": "Modéré",
+  "tendance": "En hausse",
+  "conseil": "Surveillance recommandée. Le glucose est élevé avec un risque modéré."
+}
+```
 
-data = {
-    "CodeParametre": "crea",
-    "ValeurActuelle": 120,
-    "Unite": "µmol/L",
-    "ValeursUsuelles": "60-110",
-    "ValeurUsuelleMin": 60,
-    "ValeurUsuelleMax": 110,
-    "CodParametre": "CREA"
+### 5. Analyse LLM
+```
+POST /llm-analysis
+```
+Utilise le modèle LLM pour fournir une analyse textuelle détaillée.
+
+**Body :**
+```json
+{
+  "CodeParametre": "glucose",
+  "ValeurActuelle": 120.0,
+  "Unite": "mg/dL",
+  "ValeursUsuelles": "70-100",
+  "ValeurAnterieure": 110.0
 }
+```
 
-response = requests.post(
-    'https://huggingface.co/spaces/HendSta/MedWin-Analyzer/analyze-risk',
-    json=data
-)
-risk_analysis = response.json()
-print(risk_analysis)
+**Réponse :**
+```json
+{
+  "parametre": "glucose",
+  "analyse_llm": "Analyse détaillée générée par le LLM...",
+  "prompt_utilise": "Prompt utilisé pour la génération"
+}
 ```
 
-## ⚠️ Avertissements
+## 🔧 Configuration
+
+### Variables d'Environnement
+- `HF_TOKEN` : Token Hugging Face (optionnel pour les modèles publics)
+
+### Dépendances
+Voir `requirements.txt` pour la liste complète des dépendances.
 
-- Cette API est destinée à des fins éducatives et de recherche
-- Les résultats ne constituent pas un diagnostic médical
-- Consultez toujours un professionnel de santé pour toute décision médicale
-- Les modèles sont basés sur des données d'entraînement et peuvent avoir des limitations
+## 🚀 Déploiement
 
-## 📄 Licence
+Cette application est configurée pour être déployée automatiquement sur Hugging Face Spaces.
 
-MIT License - Voir le fichier LICENSE pour plus de détails.
+### Structure des Fichiers
+```
+MedWin-Analyzer/
+├── app.py              # Application FastAPI principale
+├── requirements.txt    # Dépendances Python
+├── Dockerfile         # Configuration Docker
+└── README.md          # Documentation
+```
 
-## 🤝 Contribution
+## 📊 Utilisation
 
-Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une issue ou une pull request.
+1. **Démarrage automatique** : Les modèles sont chargés automatiquement au démarrage
+2. **Health check** : Utilisez `/health` pour vérifier l'état des modèles
+3. **Upload de fichiers** : Supporte les formats PDF et XML
+4. **Analyse en temps réel** : Tous les endpoints fournissent des réponses immédiates
 
-## 📞 Support
+## 🔍 Dépannage
 
-Pour toute question ou problème, veuillez ouvrir une issue sur le repository Hugging Face.
+### Erreurs Courantes
 
----
+1. **Modèles non chargés** : Vérifiez la connexion internet et les permissions
+2. **Erreur de format** : Assurez-vous que les fichiers PDF/XML sont valides
+3. **Timeout** : Les modèles LLM peuvent prendre du temps pour la première génération
+
+### Logs
+Les logs de chargement des modèles sont affichés au démarrage de l'application.
+
+## 📝 Notes
 
-**Développé avec ❤️ pour la communauté médicale**
+- Les modèles sont téléchargés automatiquement depuis Hugging Face au premier démarrage
+- Le cache des modèles est conservé pour les démarrages suivants
+- L'application gère automatiquement les erreurs de chargement des modèles

app.py

@@ -18,23 +18,15 @@ import xml.etree.ElementTree as ET
 from fastapi.responses import JSONResponse
 from sklearn.base import BaseEstimator, TransformerMixin
 import sys
-from dotenv import load_dotenv
 from huggingface_hub import hf_hub_download
-import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
 
-# Charger les variables d'environnement
-load_dotenv()
-
-app = FastAPI(
-    title="MedWin Analyzer",
-    description="API pour l'analyse de rapports médicaux avec 3 modèles ML",
-    version="1.0.0"
-)
+app = FastAPI()
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Pour Hugging Face Spaces
+    allow_origins=["http://localhost:4200"],  # URL de votre frontend Angular
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -62,63 +54,54 @@ class NumericConverter(BaseEstimator, TransformerMixin):
 
 sys.modules['__main__'].NumericConverter = NumericConverter
 
-# Variables globales pour les modèles
-pipeline = None
-risk_model = None
-llm_model = None
-llm_tokenizer = None
-models_loaded = False
-
-def load_models():
+# Charger les modèles ML depuis Hugging Face
+def load_models_from_hf():
     """Charge tous les modèles depuis Hugging Face"""
-    global pipeline, risk_model, llm_model, llm_tokenizer, models_loaded
+    global pipeline, analyze_risk_model, llm_tokenizer, llm_model
     
-    if models_loaded:
-        return pipeline, risk_model, llm_model, llm_tokenizer
+    print("Loading models from Hugging Face...")
     
+    # Charger le modèle d'analyse médicale
     try:
-        print("🔄 Chargement des modèles depuis Hugging Face...")
-        
-        # 1. Modèle d'analyse médicale (HendSta/analyse_medicale)
-        print("📊 Chargement du modèle d'analyse médicale...")
-        pipeline_path = hf_hub_download(
+        model_path = hf_hub_download(
             repo_id="HendSta/analyse_medicale",
             filename="modele_analyse_medicale_final.joblib"
         )
-        pipeline = joblib.load(pipeline_path)
-        print("✅ Modèle d'analyse médicale chargé!")
-        
-        # 2. Modèle d'analyse de risque (HendSta/analyse_row)
-        print("⚠️ Chargement du modèle d'analyse de risque...")
-        risk_model_path = hf_hub_download(
+        pipeline = joblib.load(model_path)
+        print("✅ Modèle d'analyse médicale chargé avec succès")
+    except Exception as e:
+        print(f"❌ Erreur lors du chargement du modèle d'analyse médicale: {e}")
+        raise
+    
+    # Charger le modèle d'analyse de risque
+    try:
+        analyze_risk_model_path = hf_hub_download(
             repo_id="HendSta/analyse_row",
             filename="analyze_row_final.joblib"
         )
-        risk_model = joblib.load(risk_model_path)
-        print("✅ Modèle d'analyse de risque chargé!")
-        
-        # 3. Modèle LLM BioMistral (HendSta/biomistral-finetuned-fullv3)
-        print("🧠 Chargement du modèle LLM BioMistral...")
+        analyze_risk_model = joblib.load(analyze_risk_model_path)
+        print("✅ Modèle d'analyse de risque chargé avec succès")
+    except Exception as e:
+        print(f"❌ Erreur lors du chargement du modèle d'analyse de risque: {e}")
+        raise
+    
+    # Charger le modèle LLM
+    try:
         llm_tokenizer = AutoTokenizer.from_pretrained("HendSta/biomistral-finetuned-fullv3")
-        llm_model = AutoModelForCausalLM.from_pretrained(
-            "HendSta/biomistral-finetuned-fullv3",
-            device_map="auto" if torch.cuda.is_available() else "cpu",
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            low_cpu_mem_usage=True
-        )
-        
-        if llm_tokenizer.pad_token is None:
-            llm_tokenizer.pad_token = llm_tokenizer.eos_token
-        
-        print("✅ Modèle LLM BioMistral chargé!")
-        
-        models_loaded = True
-        print("🎉 Tous les modèles chargés avec succès!")
-        return pipeline, risk_model, llm_model, llm_tokenizer
-        
+        llm_model = AutoModelForCausalLM.from_pretrained("HendSta/biomistral-finetuned-fullv3")
+        print("✅ Modèle LLM chargé avec succès")
     except Exception as e:
-        print(f"❌ Erreur lors du chargement des modèles: {str(e)}")
-        return None, None, None, None
+        print(f"❌ Erreur lors du chargement du modèle LLM: {e}")
+        raise
+
+# Initialiser les modèles avec gestion d'erreur
+try:
+    load_models_from_hf()
+    print("🎉 Tous les modèles ont été chargés avec succès!")
+except Exception as e:
+    print(f"💥 Erreur critique lors du chargement des modèles: {e}")
+    print("L'application ne peut pas démarrer sans les modèles.")
+    raise
 
 # Créer un imputer pour gérer les valeurs NaN
 imputer = SimpleImputer(strategy='constant', fill_value=0)
@@ -178,7 +161,7 @@ TYPE_ANALYSES = {
     "dosage des vitamines": ["dosage des vitamines"]
 }
 
-# Regex patterns
+# Regex patterns - Amélioré pour capturer les nombres avec beaucoup de séparateurs
 REGEX_DATE = r"\b(\d{2}/\d{2}/\d{4})\b"
 REGEX_PATIENT = r"(?i)nom\s*:\s*(.*)"
 REGEX_MEDECIN = r"(?i)demandé par\s*:\s*(.*)"
@@ -194,7 +177,7 @@ UNIT_MAPPING = {
     'g/dl': 'g/dL',
     'mmol/l': 'mmol/L',
     'pmol/l': 'pmol/L'
-} 
+}
 
 # ==== Helper Functions ====
 def normaliser_type_analyse(texte):
@@ -230,6 +213,7 @@ def extract_min_max(valeur_usuelles):
     valeur_usuelles = valeur_usuelles.strip()
 
     # Nettoyer les espaces à l'intérieur des nombres dans la chaîne 
+    # avant de faire l'extraction
     valeur_usuelles = re.sub(r'(?<=\d)\s+(?=\d)', '', valeur_usuelles)
 
     range_pattern = r'(\d+(?:[.,]\d+)?)\s*-\s*(\d+(?:[.,]\d+)?)'
@@ -309,7 +293,7 @@ def extract_patient_info(text: str) -> Dict[str, str]:
     return patient_info
 
 def extract_all_fields_from_text(text: str) -> list:
-    """Extrait tous les paramètres et valeurs du texte nettoyé."""
+    """Extrait tous les paramètres et valeurs du texte nettoyé, y compris valeur antérieure et date antérieure si présentes sur la même ligne."""
     results = []
     lines = text.splitlines()
     for line in lines:
@@ -318,6 +302,7 @@ def extract_all_fields_from_text(text: str) -> list:
             continue
             
         # Nettoyer les motifs "X % Soit :"
+        # On conserve uniquement le nom du paramètre au début et ce qui suit "Soit :" s'il est présent
         soit_match = re.search(r'^([\w\s\.]+)\s+(\d+)\s*%\s*Soit\s*:\s*(.+)$', line, re.IGNORECASE)
         if soit_match:
             param_name = soit_match.group(1).strip()
@@ -433,164 +418,34 @@ def to_native(val):
         return val.item()
     return val
 
-def analyze_abnormal_parameters(abnormal_params):
-    """
-    Analyse les paramètres anormaux et retourne des prédictions de maladies basées sur des règles
-    """
-    diseases = []
-    
-    # Dictionnaire des maladies associées aux paramètres
-    disease_patterns = {
-        'diabète': ['GLY', 'GLUCOSE', 'HBA1C', 'HBA2C', 'glycémie'],
-        'hypercholestérolémie': ['CHOLESTEROL', 'CT', 'LDL', 'HDL', 'TG', 'TRIGLYCERIDES'],
-        'insuffisance rénale': ['CREA', 'CREATININE', 'UREE', 'URI'],
-        'anémie': ['HEM1', 'NFS5', 'NFS6', 'HEMOGLOBINE'],
-        'hyperthyroïdie': ['TSH', 'T3', 'T4'],
-        'hypothyroïdie': ['TSH'],
-        'inflammation': ['CRP', 'VS', 'FIBRINOGENE'],
-        'problèmes hépatiques': ['AST', 'ALT', 'ALAT', 'ASAT', 'BILIRUBINE'],
-        'problèmes cardiaques': ['TROPONINE', 'CPK', 'BNP']
-    }
-    
-    # Analyser chaque paramètre anormal
-    for param in abnormal_params:
-        param_name = param['name'].upper()
-        status = param['status']
-        value = param['value']
-        
-        # Chercher des correspondances avec les patterns de maladies
-        for disease, patterns in disease_patterns.items():
-            for pattern in patterns:
-                if pattern.upper() in param_name:
-                    if disease not in diseases:
-                        diseases.append(disease)
-                    break
-    
-    # Ajouter des analyses spécifiques
-    if diseases:
-        return [f"Possibilité de {disease.replace('_', ' ')}" for disease in diseases]
-    else:
-        return ["Anomalies biologiques détectées nécessitant une évaluation médicale"]
-
-def extract_valeurs_usuelles_xml(val):
-    """Extrait les bornes min/max des valeurs usuelles depuis un format XML."""
-    if not isinstance(val, str) or val.strip() == "":
-        return None, None
-    val = val.lower().replace(',', '.').strip()
-
-    try:
-        if '-' in val:
-            parts = val.split('-')
-            return float(parts[0].strip()), float(parts[1].strip())
-        elif 'inf à' in val:
-            return None, float(re.sub(r"[^\d.]", "", val))
-        elif 'sup à' in val or '>' in val:
-            return float(re.sub(r"[^\d.]", "", val)), None
-    except:
-        return None, None
-
-    return None, None
-
-def parse_xml_file(xml_bytes: bytes) -> list:
-    """Parse un fichier XML et retourne les résultats au format attendu par l'API."""
+# ==== API Endpoints ====
+@app.get("/health")
+def health_check():
+    """Vérifie que tous les modèles sont chargés correctement"""
     try:
-        # Utiliser BytesIO pour lire les bytes comme un fichier
-        tree = ET.parse(io.BytesIO(xml_bytes))
-        root = tree.getroot()
+        # Vérifier que tous les modèles sont disponibles
+        models_status = {
+            "analyse_medicale_model": pipeline is not None,
+            "analyze_risk_model": analyze_risk_model is not None,
+            "llm_model": llm_model is not None,
+            "llm_tokenizer": llm_tokenizer is not None
+        }
         
-        results = []
-
-        demande = root.find(".//Demande")
-        if demande is None:
-            raise HTTPException(status_code=400, detail="Format XML non reconnu: élément 'Demande' introuvable")
-            
-        nom_patient = demande.findtext("NomPatient", "").strip()
-        prenom_patient = demande.findtext("PrenomPatient", "").strip()
-        patient_name = f"{nom_patient} {prenom_patient}".strip()
-        patient_name = nettoyer_nom_patient(patient_name)
-        medecin = demande.findtext("MedecinPrescripteur", "").strip()
-        date_analyse = demande.findtext("DateSaisie", "").strip()
-
-        # Convertir la date si nécessaire
-        if re.match(r'^\d{4}-\d{2}-\d{2}$', date_analyse):
-            parts = date_analyse.split('-')
-            date_analyse = f"{parts[2]}/{parts[1]}/{parts[0]}"
-
-        for examen in demande.findall(".//Examen"):
-            famille = examen.findtext("Famille", "").strip()
-            code_analyse = examen.findtext("CodeAnalyse", "").strip()
-            lib_analyse = examen.findtext("LibAnalyse", "").strip()
-
-            for res in examen.findall("Resultat"):
-                cod_param = res.findtext("CodParametre", "").strip()
-                lib_param = res.findtext("LibParametre", "").strip()
-                valeur = res.findtext("Valeur", "").replace(",", ".").strip()
-                unite = res.findtext("Unite", "").strip()
-                val_usuelle = res.findtext("ValeurUsuelles", "").strip()
-
-                val_min, val_max = extract_valeurs_usuelles_xml(val_usuelle)
-
-                # Normalisation des valeurs
-                try:
-                    valeur_actuelle = normalize_numeric_values(valeur)
-                except ValueError:
-                    valeur_actuelle = ''
-
-                results.append({
-                    "CodeParametre": cod_param.lower(),
-                    "ValeurActuelle": valeur_actuelle,
-                    "Unite": unite,
-                    "ValeursUsuelles": val_usuelle,
-                    "ValeurUsuelleMin": val_min,
-                    "ValeurUsuelleMax": val_max,
-                    "ValeurAnterieure": None,
-                    "DateAnterieure": '',
-                    "NomPatient": patient_name,
-                    "Medecin": medecin,
-                    "DateAnalyse": date_analyse,
-                    "CodParametre": cod_param,  # Champ prédit (copie du code paramètre)
-                    "LIBMEDWINabrege": cod_param,  # Pourrait être différent, dépend du modèle
-                    "LibParametre": lib_param,
-                    "FAMILLE": famille
-                })
-
-        if not results:
-            raise HTTPException(status_code=400, detail="Aucun paramètre reconnu dans le XML")
-            
-        return results
+        all_loaded = all(models_status.values())
+        
+        return {
+            "status": "healthy" if all_loaded else "unhealthy",
+            "models_loaded": models_status,
+            "message": "Tous les modèles sont chargés" if all_loaded else "Certains modèles ne sont pas chargés"
+        }
     except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Erreur lors du traitement du XML: {str(e)}")
-
-# ==== API Endpoints ====
-@app.on_event("startup")
-async def startup_event():
-    """Événement de démarrage"""
-    print("🚀 Démarrage du serveur MedWin Analyzer...")
-    print("📥 Chargement des modèles depuis Hugging Face...")
-    load_models()
-    print("✅ Serveur prêt!")
-
-@app.get("/")
-def greet_json():
-    """Endpoint de base pour tester l'API"""
-    return {
-        "message": "MedWin Analyzer API",
-        "version": "1.0.0",
-        "description": "API pour l'analyse de rapports médicaux avec 3 modèles ML",
-        "endpoints": {
-            "/predict": "Prédiction de paramètres médicaux",
-            "/upload-pdf": "Analyse de fichiers PDF",
-            "/analyze-risk": "Analyse de risque",
-            "/predict-disease": "Prédiction de maladies"
+        return {
+            "status": "error",
+            "error": str(e)
         }
-    }
 
 @app.post("/predict", response_model=PredictionResult)
 def predict(data: InputData):
-    """Prédit les paramètres médicaux avec le modèle HendSta/analyse_medicale"""
-    if pipeline is None:
-        raise HTTPException(status_code=500, detail="Modèle non chargé")
-    
     df = pd.DataFrame([data.dict()])
     preds = pipeline.predict(df)[0]
     return PredictionResult(
@@ -603,10 +458,6 @@ def predict(data: InputData):
 
 @app.post("/upload-pdf", response_model=List[PredictionResult])
 async def upload_file(file: UploadFile = File(...)):
-    """Analyse un fichier PDF ou XML et retourne les prédictions"""
-    if pipeline is None:
-        raise HTTPException(status_code=500, detail="Modèle non chargé")
-    
     content = await file.read()
     file_extension = file.filename.split('.')[-1].lower()
     
@@ -615,7 +466,7 @@ async def upload_file(file: UploadFile = File(...)):
             if file.content_type != "application/pdf":
                 raise HTTPException(status_code=400, detail="Le fichier doit être au format PDF")
             
-            # Traitement PDF
+            # Traitement PDF existant
             extracted_text = extract_text_from_pdf_bytes(content)
             cleaned_text = nettoyer_text(extracted_text)
             patient_info = extract_patient_info(cleaned_text)
@@ -678,14 +529,15 @@ async def upload_file(file: UploadFile = File(...)):
 
 @app.post("/analyze-risk")
 def analyze_risk(param: dict = Body(...)):
-    """Analyse le risque avec le modèle HendSta/analyse_row"""
-    if risk_model is None:
-        raise HTTPException(status_code=500, detail="Modèle de risque non chargé")
-    
+    import pandas as pd
+    import numpy as np
+    # Utiliser le modèle globalement chargé
+    model = analyze_risk_model
+
     # Préparer le DataFrame à partir du paramètre reçu
     df_test = pd.DataFrame([param])
 
-    # Préparation des features dérivées
+    # Préparation des features dérivées (copie de preparer_features)
     df_result = df_test.copy()
     try:
         df_result['ValeurAnterieure'] = pd.to_numeric(df_result['ValeurAnterieure'], errors='coerce')
@@ -727,7 +579,7 @@ def analyze_risk(param: dict = Body(...)):
     features_for_ml = df_result[['DeltaValeurPrecedente', 'RatioValeurPrecedente', 
                                  'PourcentageValeurMin', 'PourcentageValeurMax', 
                                  'EcartNormalise', 'ValeurActuelle', 'CodeParametre']]
-    predicted_risk_num = risk_model.predict(features_for_ml)[0]
+    predicted_risk_num = model.predict(features_for_ml)[0]
     risk_map = {0: 'Aucun', 1: 'Faible', 2: 'Modéré', 3: 'Élevé'}
     degre_risque = risk_map.get(int(predicted_risk_num), 'Inconnu')
 
@@ -766,108 +618,107 @@ def analyze_risk(param: dict = Body(...)):
         "conseil": to_native(conseil)
     }
 
-@app.post("/predict-disease")
-def predict_disease(data: dict = Body(...)):
-    """Prédit les maladies avec le modèle HendSta/biomistral-finetuned-fullv3"""
-    try:
-        print("🔍 Début de l'analyse de prédiction de maladie...")
-        print(f"Données reçues: {len(data.get('risk_results', []))} résultats de risque")
-        
-        # Vérifier si tous les statuts sont NORMAL
-        risk_results = data.get('risk_results', [])
-        abnormal_count = 0
-        
-        for i, risk_result in enumerate(risk_results):
-            if risk_result and risk_result.get('statut_risque') != 'NORMAL':
-                abnormal_count += 1
-                print(f"Paramètre anormal détecté: {risk_result.get('statut_risque')}")
-        
-        print(f"Nombre de paramètres anormaux: {abnormal_count}")
-        
-        if abnormal_count == 0:
-            return {
-                "disease_prediction": "Aucune maladie détectée",
-                "confidence": "Élevée",
-                "explanation": "Tous les paramètres biologiques sont dans les plages normales.",
-                "recommendations": "Continuez à maintenir un mode de vie sain."
-            }
-        
-        # Pour les cas anormaux, utiliser le modèle LLM BioMistral
-        print("🔍 Analyse des paramètres anormaux avec le modèle LLM...")
-        
-        # Préparer le texte des paramètres anormaux
-        abnormal_params = []
-        analysis_result = data.get('analysis_result', [])
-        
-        for i, risk_result in enumerate(risk_results):
-            if risk_result and risk_result.get('statut_risque') != 'NORMAL':
-                if i < len(analysis_result):
-                    param_data = analysis_result[i]
-                    param_name = param_data.get('LibParametre', param_data.get('CodParametre', 'Paramètre'))
-                    current_value = param_data.get('ValeurActuelle', '')
-                    unit = param_data.get('Unite', '')
-                    status = risk_result.get('statut_risque', '')
-                    normal_range = param_data.get('ValeursUsuelles', '')
-                    
-                    abnormal_params.append(
-                        f"- {param_name} : {current_value} {unit} ({status}) | Valeur usuelle : ({normal_range})"
-                    )
-        
-        print(f"Paramètres anormaux identifiés: {len(abnormal_params)}")
-        
-        if not abnormal_params:
-            return {
-                "disease_prediction": "Aucune maladie détectée",
-                "confidence": "Élevée",
-                "explanation": "Aucun paramètre anormal significatif détecté.",
-                "recommendations": "Continuez à maintenir un mode de vie sain."
-            }
-        
-        # Utiliser l'analyse basée sur des règles (mode fallback)
-        print("🧠 Analyse basée sur des règles médicales...")
-        
-        diseases = analyze_abnormal_parameters([{
-            'name': param.split(' : ')[0].replace('- ', ''),
-            'value': param.split(' : ')[1].split(' ')[0] if ' : ' in param else '',
-            'unit': param.split(' ')[2] if len(param.split(' : ')) > 1 and len(param.split(' : ')[1].split(' ')) > 2 else '',
-            'status': param.split('(')[1].split(')')[0] if '(' in param and ')' in param else '',
-            'normal_range': param.split('(')[-1].split(')')[0] if '(' in param and ')' in param else ''
-        } for param in abnormal_params])
-        
-        if diseases:
-            prediction_text = "\n".join(diseases)
-            confidence = "Modérée"
-            explanation = "Analyse basée sur les paramètres anormaux détectés."
-            recommendations = "Consultez un professionnel de santé pour confirmation et suivi."
-        else:
-            prediction_text = "Anomalies biologiques détectées nécessitant une évaluation médicale approfondie."
-            confidence = "Faible"
-            explanation = "Les paramètres anormaux nécessitent une interprétation médicale spécialisée."
-            recommendations = "Consultez immédiatement un professionnel de santé."
-        
+# Fonction de debug temporaire pour tester l'extraction
+def debug_extraction(line):
+    """Teste l'extraction d'une ligne et affiche les résultats"""
+    match = re.search(REGEX_PARAMETRE, line)
+    if match:
         return {
-            "disease_prediction": prediction_text,
-            "confidence": confidence,
-            "explanation": explanation,
-            "recommendations": recommendations
+            "param": match.group(1).strip(),
+            "valeur": match.group(2).strip(),
+            "unite": match.group(3).strip() if match.group(3) else "",
+            "valeur_ant": match.group(4).strip() if match.group(4) else None,
+            "date": match.group(5).strip() if match.group(5) else "",
+            "usuelles": match.group(6).strip() if match.group(6) else ""
         }
+    return None
+
+# Ajouter les fonctions de traitement XML
+def extract_valeurs_usuelles_xml(val):
+    """Extrait les bornes min/max des valeurs usuelles depuis un format XML."""
+    if not isinstance(val, str) or val.strip() == "":
+        return None, None
+    val = val.lower().replace(',', '.').strip()
+
+    try:
+        if '-' in val:
+            parts = val.split('-')
+            return float(parts[0].strip()), float(parts[1].strip())
+        elif 'inf à' in val:
+            return None, float(re.sub(r"[^\d.]", "", val))
+        elif 'sup à' in val or '>' in val:
+            return float(re.sub(r"[^\d.]", "", val)), None
+    except:
+        return None, None
+
+    return None, None
+
+def parse_xml_file(xml_bytes: bytes) -> list:
+    """Parse un fichier XML et retourne les résultats au format attendu par l'API."""
+    try:
+        # Utiliser BytesIO pour lire les bytes comme un fichier
+        tree = ET.parse(io.BytesIO(xml_bytes))
+        root = tree.getroot()
         
-    except Exception as e:
-        print(f"Erreur lors de la prédiction de maladie: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return {
-            "disease_prediction": "Erreur lors de l'analyse",
-            "confidence": "Faible",
-            "explanation": f"Erreur technique: {str(e)}",
-            "recommendations": "Veuillez réessayer ou consulter un professionnel de santé."
-        }
+        results = []
+
+        demande = root.find(".//Demande")
+        if demande is None:
+            raise HTTPException(status_code=400, detail="Format XML non reconnu: élément 'Demande' introuvable")
+            
+        nom_patient = demande.findtext("NomPatient", "").strip()
+        prenom_patient = demande.findtext("PrenomPatient", "").strip()
+        patient_name = f"{nom_patient} {prenom_patient}".strip()
+        patient_name = nettoyer_nom_patient(patient_name)
+        medecin = demande.findtext("MedecinPrescripteur", "").strip()
+        date_analyse = demande.findtext("DateSaisie", "").strip()
+
+        # Convertir la date si nécessaire
+        if re.match(r'^\d{4}-\d{2}-\d{2}$', date_analyse):
+            parts = date_analyse.split('-')
+            date_analyse = f"{parts[2]}/{parts[1]}/{parts[0]}"
+
+        for examen in demande.findall(".//Examen"):
+            famille = examen.findtext("Famille", "").strip()
+            code_analyse = examen.findtext("CodeAnalyse", "").strip()
+            lib_analyse = examen.findtext("LibAnalyse", "").strip()
+
+            for res in examen.findall("Resultat"):
+                cod_param = res.findtext("CodParametre", "").strip()
+                lib_param = res.findtext("LibParametre", "").strip()
+                valeur = res.findtext("Valeur", "").replace(",", ".").strip()
+                unite = res.findtext("Unite", "").strip()
+                val_usuelle = res.findtext("ValeurUsuelles", "").strip()
+
+                val_min, val_max = extract_valeurs_usuelles_xml(val_usuelle)
+
+                # Normalisation des valeurs
+                try:
+                    valeur_actuelle = normalize_numeric_values(valeur)
+                except ValueError:
+                    valeur_actuelle = ''
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=7860,
-        reload=False
-    ) 
+                results.append({
+                    "CodeParametre": cod_param.lower(),
+                    "ValeurActuelle": valeur_actuelle,
+                    "Unite": unite,
+                    "ValeursUsuelles": val_usuelle,
+                    "ValeurUsuelleMin": val_min,
+                    "ValeurUsuelleMax": val_max,
+                    "ValeurAnterieure": None,
+                    "DateAnterieure": '',
+                    "NomPatient": patient_name,
+                    "Medecin": medecin,
+                    "DateAnalyse": date_analyse,
+                    "CodParametre": cod_param,  # Champ prédit (copie du code paramètre)
+                    "LIBMEDWINabrege": cod_param,  # Pourrait être différent, dépend du modèle
+                    "LibParametre": lib_param,
+                    "FAMILLE": famille
+                })
+
+        if not results:
+            raise HTTPException(status_code=400, detail="Aucun paramètre reconnu dans le XML")
+            
+        return results
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Erreur lors du traitement du XML: {str(e)}")

requirements.txt

@@ -11,4 +11,5 @@ scikit-learn==1.3.2
 transformers==4.36.2
 torch==2.1.2
 python-dotenv==1.0.0
-huggingface-hub==0.20.3 
+huggingface-hub==0.20.3
+requests==2.31.0