first try

.gitignore

@@ -0,0 +1,131 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+*.log
+
+# Model files (if any are downloaded locally)
+*.joblib
+*.pkl
+*.pth
+*.pt
+
+# Test files
+test_*.py
+*_test.py 

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"] 

README.md

@@ -1,10 +1,196 @@
 ---
 title: MedWin Analyzer
-emoji: 👀
-colorFrom: yellow
-colorTo: red
+emoji: 🏥
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 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/
+├── app.py              # Application FastAPI principale
+├── requirements.txt    # Dépendances Python
+├── Dockerfile         # Configuration Docker
+└── README.md          # Documentation
+```
+
+## 🚀 Démarrage rapide
+
+1. **Cloner le repository**:
+```bash
+git clone https://huggingface.co/spaces/HendSta/MedWin-Analyzer
+cd MedWin-Analyzer
+```
+
+2. **Installer les dépendances**:
+```bash
+pip install -r requirements.txt
+```
+
+3. **Lancer l'application**:
+```bash
+python app.py
+```
+
+L'API sera disponible sur `http://localhost:7860`
+
+## 📊 Exemples d'utilisation
+
+### Analyse d'un rapport PDF
+```python
+import requests
+
+# 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)
+```
+
+### Analyse de risque
+```python
+import requests
+
+data = {
+    "CodeParametre": "crea",
+    "ValeurActuelle": 120,
+    "Unite": "µmol/L",
+    "ValeursUsuelles": "60-110",
+    "ValeurUsuelleMin": 60,
+    "ValeurUsuelleMax": 110,
+    "CodParametre": "CREA"
+}
+
+response = requests.post(
+    'https://huggingface.co/spaces/HendSta/MedWin-Analyzer/analyze-risk',
+    json=data
+)
+risk_analysis = response.json()
+print(risk_analysis)
+```
+
+## ⚠️ Avertissements
+
+- 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
+
+## 📄 Licence
+
+MIT License - Voir le fichier LICENSE pour plus de détails.
+
+## 🤝 Contribution
+
+Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une issue ou une pull request.
+
+## 📞 Support
+
+Pour toute question ou problème, veuillez ouvrir une issue sur le repository Hugging Face.
+
+---
+
+**Développé avec ❤️ pour la communauté médicale**

app.py

@@ -0,0 +1,873 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Body
+from pydantic import BaseModel
+import joblib
+import pandas as pd
+import pdfplumber
+import re
+import numpy as np
+import io
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Dict, Any, Optional
+import os
+import json
+from rapidfuzz import process
+from sklearn.impute import SimpleImputer
+import random
+import math
+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
+
+# 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.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Pour Hugging Face Spaces
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class NumericConverter(BaseEstimator, TransformerMixin):
+    """
+    Transformer that converts string values to numeric, with special handling for 'Négatif'
+    """
+    def __init__(self, negatif_value=0):
+        self.negatif_value = negatif_value
+        
+    def fit(self, X, y=None):
+        return self
+        
+    def transform(self, X):
+        X_copy = X.copy()
+        for col in X_copy.columns:
+            mask = X_copy[col] == 'Négatif'
+            if mask.any():
+                X_copy.loc[mask, col] = self.negatif_value
+            X_copy[col] = pd.to_numeric(X_copy[col], errors='coerce')
+        X_copy.fillna(0, inplace=True)
+        return X_copy
+
+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():
+    """Charge tous les modèles depuis Hugging Face"""
+    global pipeline, risk_model, llm_model, llm_tokenizer, models_loaded
+    
+    if models_loaded:
+        return pipeline, risk_model, llm_model, llm_tokenizer
+    
+    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(
+            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(
+            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...")
+        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
+        
+    except Exception as e:
+        print(f"❌ Erreur lors du chargement des modèles: {str(e)}")
+        return None, None, None, None
+
+# Créer un imputer pour gérer les valeurs NaN
+imputer = SimpleImputer(strategy='constant', fill_value=0)
+
+# ==== Pydantic Models ====
+class InputData(BaseModel):
+    CodeParametre: str
+    ValeurActuelle: float
+    Unite: str
+    ValeursUsuelles: str
+    ValeurUsuelleMin: float
+    ValeurUsuelleMax: float
+    ValeurAnterieure: Optional[float] = None
+    DateAnterieure: str = ''
+
+class PredictionResult(BaseModel):
+    # Champs d'entrée
+    CodeParametre: str
+    ValeurActuelle: float
+    Unite: str
+    ValeursUsuelles: str
+    ValeurUsuelleMin: float
+    ValeurUsuelleMax: float
+    ValeurAnterieure: Optional[float] = None
+    DateAnterieure: str = ''
+    # Champs prédits
+    CodParametre: str
+    LIBMEDWINabrege: str
+    LibParametre: str
+    FAMILLE: str
+    # Informations du patient
+    NomPatient: str = "Patient inconnu"
+    Medecin: str = "Médecin inconnu"
+    DateAnalyse: str = ""
+
+# ==== Constants ====
+TYPE_ANALYSES = {
+    "hématologie": ["hematologie", "hématologie", "CYTO-HEMATOLOGIE", "HEMATOLOGIE"],
+    "biochimie": ["biochimie", "BIO-CHIMIE", "BIOCHIMIE"],
+    "enzymologie": ["enzymologie", "ENZYMOLOGIE"],
+    "hormonologie": ["hormonologie", "HORMONOLOGIE"],
+    "marqueurs biochimiques": ["marqueurs biochimiques"],
+    "biochimie des urines": ["biochimie des urines", "CHIMIE URINE"],
+    "immunologie": ["immunologie"],
+    "microbiologie": ["MICROBIOLOGIE"],
+    "coagulation": ["COAGULATION"],
+    "hémostase-coagulation": ["hemostase-coagulation"],
+    "hémostase": ["hemostase"],
+    "bactériologie": ["bacteriologie"],
+    "antibiogramme": ["antibiogramme"],
+    "biochimie clinique": ["biochimie clinique", "biochimie clinique (sang)"],
+    "vitamines": ["vitamines"],
+    "marqueurs tumoraux": ["marqueurs tumoraux"],
+    "marqueurs cardiaques": ["marqueurs cardiaques"],
+    "immuno-hématologie": ["immuno-hematologie"],
+    "hormones": ["hormones"],
+    "dosage des vitamines": ["dosage des vitamines"]
+}
+
+# Regex patterns
+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*(.*)"
+REGEX_PARAMETRE = r"([\w\s]+?)[\s\.]+(\d+(?:[ \.,]\d+)*)\s*([a-zA-Z/%³]*)\s*(\d+(?:[ \.,]\d+)*)?\s*(\d{2}/\d{2}/\d{2,4})?\s*\(([^)]*)\)?"
+
+# Unit mapping
+UNIT_MAPPING = {
+    'millions/mm³': '10^6/mm³',
+    'millions/mm3': '10^6/mm³',
+    'µ3': 'fl',
+    'µl': 'fl',
+    'ui/l': 'UI/L',
+    'g/dl': 'g/dL',
+    'mmol/l': 'mmol/L',
+    'pmol/l': 'pmol/L'
+} 
+
+# ==== Helper Functions ====
+def normaliser_type_analyse(texte):
+    """Associe un type d'analyse à partir du dictionnaire."""
+    texte = texte.lower()
+    for type_normalise, variantes in TYPE_ANALYSES.items():
+        if texte in [var.lower() for var in variantes]:
+            return type_normalise
+    return texte
+
+def normalize_numeric_values(val):
+    """Normalise les valeurs numériques."""
+    if not isinstance(val, str):
+        return val
+    
+    # Supprimer les espaces à l'intérieur des nombres (ex: 4 290 -> 4290)
+    val = re.sub(r'(?<=\d)\s+(?=\d)', '', val)
+    
+    # Remplacer les virgules par des points pour la conversion
+    val = val.replace(',', '.')
+    
+    if val.isdigit() and val.startswith('0') and len(val) > 1:
+        return int(val)
+    try:
+        return float(val)
+    except ValueError:
+        return val
+
+def extract_min_max(valeur_usuelles):
+    """Extrait les bornes min/max des valeurs usuelles."""
+    if not isinstance(valeur_usuelles, str):
+        return None, None
+    valeur_usuelles = valeur_usuelles.strip()
+
+    # Nettoyer les espaces à l'intérieur des nombres dans la chaîne 
+    valeur_usuelles = re.sub(r'(?<=\d)\s+(?=\d)', '', valeur_usuelles)
+
+    range_pattern = r'(\d+(?:[.,]\d+)?)\s*-\s*(\d+(?:[.,]\d+)?)'
+    lt_pattern = r'<\s*(\d+(?:[.,]\d+)?)'
+    gt_pattern = r'>\s*(\d+(?:[.,]\d+)?)'
+
+    range_match = re.search(range_pattern, valeur_usuelles)
+    if range_match:
+        min_val = range_match.group(1).replace(',', '.')
+        max_val = range_match.group(2).replace(',', '.')
+        return float(min_val), float(max_val)
+
+    lt_match = re.search(lt_pattern, valeur_usuelles)
+    if lt_match:
+        return None, float(lt_match.group(1).replace(',', '.'))
+
+    gt_match = re.search(gt_pattern, valeur_usuelles)
+    if gt_match:
+        return float(gt_match.group(1).replace(',', '.')), None
+
+    return None, None
+
+def nettoyer_code_parametre(code_param):
+    """Nettoie le code paramètre."""
+    if pd.isna(code_param):
+        return code_param
+    code_param = str(code_param)
+    code_param = re.sub(r'\s+\d+[.,]?\d*\s*\S*$', '', code_param)
+    return code_param.strip().lower()
+
+def extract_text_from_pdf_bytes(pdf_bytes: bytes) -> str:
+    """Extrait le texte d'un PDF à partir de son contenu en bytes."""
+    extracted_text = ""
+    with pdfplumber.open(io.BytesIO(pdf_bytes)) as pdf:
+        for page in pdf.pages:
+            text = page.extract_text()
+            if text:
+                extracted_text += text + "\n"
+    return extracted_text
+
+def nettoyer_text(contenu: str) -> str:
+    """Nettoyage avancé du texte."""
+    contenu = re.sub(r'(\b[A-ZÀ-ÖØ-öø-ÿ])(?:\.+[A-ZÀ-ÖØ-öø-ÿ])+\b', lambda m: m.group(0).replace('.', ''), contenu)
+    contenu = re.sub(r'\.(?!\d)', '', contenu)
+    return contenu
+
+def nettoyer_nom_patient(nom):
+    """Supprime les caractères non nécessaires comme les astérisques du nom du patient."""
+    if not nom or not isinstance(nom, str):
+        return "Patient inconnu"
+    # Supprimer les astérisques
+    nom = re.sub(r'[*]+', '', nom)
+    # Supprimer les espaces multiples et les espaces au début/fin
+    nom = re.sub(r'\s+', ' ', nom).strip()
+    return nom if nom else "Patient inconnu"
+
+def extract_patient_info(text: str) -> Dict[str, str]:
+    """Extrait les informations du patient."""
+    patient_info = {
+        "NomPatient": "Patient inconnu",
+        "Medecin": "Médecin inconnu",
+        "DateAnalyse": ""
+    }
+    
+    date_match = re.search(REGEX_DATE, text)
+    if date_match:
+        patient_info["DateAnalyse"] = date_match.group(1)
+    
+    patient_match = re.search(REGEX_PATIENT, text)
+    if patient_match:
+        patient_info["NomPatient"] = nettoyer_nom_patient(patient_match.group(1).strip())
+    
+    medecin_match = re.search(REGEX_MEDECIN, text)
+    if medecin_match:
+        patient_info["Medecin"] = medecin_match.group(1).strip()
+    
+    return patient_info
+
+def extract_all_fields_from_text(text: str) -> list:
+    """Extrait tous les paramètres et valeurs du texte nettoyé."""
+    results = []
+    lines = text.splitlines()
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # Nettoyer les motifs "X % Soit :"
+        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()
+            values_part = soit_match.group(3).strip()
+            line = f"{param_name} {values_part}"
+            
+        param_match = re.search(REGEX_PARAMETRE, line)
+        valeur_anterieure = None
+        date_anterieure = ''
+        if param_match:
+            parametre = param_match.group(1).replace('.', '').strip().lower()
+            valeur_actuelle = param_match.group(2).strip()
+            unite = param_match.group(3).strip()
+            valeur_usuelles = param_match.group(6).strip() if param_match.group(6) else ""
+            valeur_anterieure = param_match.group(4).strip() if param_match.group(4) else None
+            date_anterieure = param_match.group(5).strip() if param_match.group(5) else ''
+            # Normalisation des unités
+            unite = UNIT_MAPPING.get(unite.lower(), unite)
+            # Normalisation des valeurs numériques
+            try:
+                valeur_actuelle = normalize_numeric_values(valeur_actuelle)
+            except ValueError:
+                valeur_actuelle = ''
+            try:
+                valeur_anterieure = normalize_numeric_values(valeur_anterieure) if valeur_anterieure not in [None, ''] else None
+            except ValueError:
+                valeur_anterieure = None
+            # Extraction des bornes min/max
+            min_val, max_val = extract_min_max(valeur_usuelles)
+            # Nettoyage du code paramètre
+            parametre = nettoyer_code_parametre(parametre)
+            results.append({
+                "CodeParametre": parametre,
+                "ValeurActuelle": valeur_actuelle,
+                "Unite": unite,
+                "ValeursUsuelles": valeur_usuelles,
+                "ValeurUsuelleMin": min_val,
+                "ValeurUsuelleMax": max_val,
+                "ValeurAnterieure": valeur_anterieure,
+                "DateAnterieure": date_anterieure
+            })
+    if not results:
+        raise HTTPException(status_code=400, detail="Aucun paramètre reconnu dans le PDF")
+    return results
+
+def handle_missing_values(df: pd.DataFrame) -> pd.DataFrame:
+    """Gère les valeurs manquantes dans le DataFrame."""
+    # Remplir les valeurs manquantes pour les informations du patient
+    df['NomPatient'] = df['NomPatient'].fillna('patient')
+    df['Medecin'] = df['Medecin'].fillna('médecin')
+    df['DateAnalyse'] = df['DateAnalyse'].fillna('')
+
+    # Remplir les valeurs manquantes pour les paramètres
+    df['Unite'] = df['Unite'].fillna('-')
+    df['ValeursUsuelles'] = df['ValeursUsuelles'].fillna('')
+    
+    # Remplir les valeurs manquantes pour les valeurs numériques
+    df['ValeurUsuelleMin'] = df['ValeurUsuelleMin'].fillna(-1e6)
+    df['ValeurUsuelleMax'] = df['ValeurUsuelleMax'].fillna(1e6)
+    df['ValeurActuelle'] = df['ValeurActuelle'].fillna(0)
+
+    # Pour les codes paramètres manquants, utiliser une valeur par défaut
+    df['CodeParametre'] = df['CodeParametre'].fillna('parametre_inconnu')
+
+    # Convertir explicitement les colonnes numériques en float
+    numeric_columns = ['ValeurActuelle', 'ValeurUsuelleMin', 'ValeurUsuelleMax']
+    for col in numeric_columns:
+        df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0).astype(float)
+
+    return df
+
+def postprocess_valeurs_usuelles(df):
+    def format_valeurs(row):
+        val_usuelle = str(row['ValeursUsuelles'])
+        # nombre - 1,000,000
+        match_min = re.match(r'^\s*(\d+(?:[.,]?\d+)?)\s*-\s*1[,.]?0{6,}', val_usuelle)
+        if match_min:
+            min_val = match_min.group(1).replace(',', '.')
+            row['ValeursUsuelles'] = f"{min_val}<"
+            row['ValeurUsuelleMin'] = float(min_val)
+            row['ValeurUsuelleMax'] = ''
+            return row
+        # 1,000,000 - nombre
+        match_max = re.match(r'^1[,.]?0{6,}\s*-\s*(\d+(?:[.,]?\d+)?)', val_usuelle)
+        if match_max:
+            max_val = match_max.group(1).replace(',', '.')
+            row['ValeursUsuelles'] = f"{max_val}>"
+            row['ValeurUsuelleMin'] = ''
+            row['ValeurUsuelleMax'] = float(max_val)
+            return row
+        # -1,000,000
+        match_neg = re.match(r'^-1[,.]?0{6,}\s*-\s*(\d+(?:[.,]?\d+)?)', val_usuelle)
+        if match_neg:
+            nombre = match_neg.group(1).replace(',', '.')
+            row['ValeurUsuelleMin'] = ''
+            row['ValeursUsuelles'] = f"{nombre}>"
+            row['ValeurUsuelleMax'] = float(nombre)
+            return row
+        return row
+    df = df.apply(format_valeurs, axis=1)
+    return df
+
+def clean_json_value(val, field_type):
+    if isinstance(val, float) and (math.isnan(val) or math.isinf(val)):
+        if field_type == float or field_type == Optional[float]:
+            return None
+        else:
+            return "n'existe pas"
+    return val
+
+def to_native(val):
+    if isinstance(val, (np.generic,)):
+        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."""
+    try:
+        # Utiliser BytesIO pour lire les bytes comme un fichier
+        tree = ET.parse(io.BytesIO(xml_bytes))
+        root = tree.getroot()
+        
+        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
+    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"
+        }
+    }
+
+@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(
+        **data.dict(),
+        CodParametre=preds[0],
+        LIBMEDWINabrege=preds[1],
+        LibParametre=preds[2],
+        FAMILLE=preds[3]
+    )
+
+@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()
+    
+    try:
+        if file_extension == "pdf":
+            if file.content_type != "application/pdf":
+                raise HTTPException(status_code=400, detail="Le fichier doit être au format PDF")
+            
+            # Traitement PDF
+            extracted_text = extract_text_from_pdf_bytes(content)
+            cleaned_text = nettoyer_text(extracted_text)
+            patient_info = extract_patient_info(cleaned_text)
+            data_fields_list = extract_all_fields_from_text(cleaned_text)
+            
+            for item in data_fields_list:
+                item.update(patient_info)
+                
+            # Créer le DataFrame
+            df = pd.DataFrame(data_fields_list)
+            
+        elif file_extension == "xml":
+            # Traitement XML
+            results = parse_xml_file(content)
+            # Convertir la liste de résultats en DataFrame
+            df = pd.DataFrame(results)
+            
+        else:
+            raise HTTPException(status_code=400, detail="Format de fichier non pris en charge. Utilisez PDF ou XML.")
+    
+        # Traitement commun pour PDF et XML
+        df = handle_missing_values(df)
+        df = postprocess_valeurs_usuelles(df)
+        
+        # Si on a du PDF et qu'on a besoin de prédire les paramètres
+        if file_extension == "pdf":
+            # Faire la prédiction
+            preds = pipeline.predict(df)
+            
+            # Créer les résultats avec les prédictions
+            results = []
+            for input_data, p in zip(df.to_dict('records'), preds):
+                # Nettoyer les valeurs NaN/inf selon le type attendu
+                for k, v in input_data.items():
+                    field_type = PredictionResult.model_fields[k].annotation if k in PredictionResult.model_fields else str
+                    input_data[k] = clean_json_value(v, field_type)
+                result = PredictionResult(
+                    **input_data,
+                    CodParametre=p[0],
+                    LIBMEDWINabrege=p[1],
+                    LibParametre=p[2],
+                    FAMILLE=p[3]
+                )
+                results.append(result)
+        else:
+            # Pour XML, nous avons déjà les informations complètes
+            results = []
+            for input_data in df.to_dict('records'):
+                # Nettoyer les valeurs NaN/inf selon le type attendu
+                for k, v in input_data.items():
+                    field_type = PredictionResult.model_fields[k].annotation if k in PredictionResult.model_fields else str
+                    input_data[k] = clean_json_value(v, field_type)
+                result = PredictionResult(**input_data)
+                results.append(result)
+
+        return results
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors du traitement: {str(e)}")
+
+@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é")
+    
+    # Préparer le DataFrame à partir du paramètre reçu
+    df_test = pd.DataFrame([param])
+
+    # Préparation des features dérivées
+    df_result = df_test.copy()
+    try:
+        df_result['ValeurAnterieure'] = pd.to_numeric(df_result['ValeurAnterieure'], errors='coerce')
+        for i, row in df_result.iterrows():
+            if not pd.isna(row['ValeurAnterieure']) and row['ValeurAnterieure'] != 0:
+                df_result.loc[i, 'DeltaValeurPrecedente'] = row['ValeurActuelle'] - row['ValeurAnterieure']
+                df_result.loc[i, 'RatioValeurPrecedente'] = row['ValeurActuelle'] / row['ValeurAnterieure']
+            else:
+                df_result.loc[i, 'DeltaValeurPrecedente'] = 0
+                df_result.loc[i, 'RatioValeurPrecedente'] = 1
+    except:
+        df_result['DeltaValeurPrecedente'] = 0
+        df_result['RatioValeurPrecedente'] = 1
+    df_result['PourcentageValeurMin'] = (df_result['ValeurActuelle'] / df_result['ValeurUsuelleMin']) * 100
+    df_result['PourcentageValeurMax'] = (df_result['ValeurActuelle'] / df_result['ValeurUsuelleMax']) * 100
+    df_result['EcartNormalise'] = 0.0
+    mask = (df_result['ValeurUsuelleMax'] - df_result['ValeurUsuelleMin']) > 0
+    df_result.loc[mask, 'EcartNormalise'] = (
+        (df_result.loc[mask, 'ValeurActuelle'] - df_result.loc[mask, 'ValeurUsuelleMin']) /
+        (df_result.loc[mask, 'ValeurUsuelleMax'] - df_result.loc[mask, 'ValeurUsuelleMin'])
+    )
+    for col in ['DeltaValeurPrecedente', 'RatioValeurPrecedente', 'PourcentageValeurMin', 
+                'PourcentageValeurMax', 'EcartNormalise']:
+        df_result[col] = df_result[col].replace([np.inf, -np.inf], np.nan)
+        df_result[col] = df_result[col].fillna(0)
+
+    # Statut
+    valeur_actuelle = df_result['ValeurActuelle'].values[0]
+    min_usuel = df_result['ValeurUsuelleMin'].values[0]
+    max_usuel = df_result['ValeurUsuelleMax'].values[0]
+    if valeur_actuelle < min_usuel:
+        statut = "BAS"
+    elif valeur_actuelle > max_usuel:
+        statut = "ÉLEVÉ"
+    else:
+        statut = "NORMAL"
+
+    # Features pour le ML
+    features_for_ml = df_result[['DeltaValeurPrecedente', 'RatioValeurPrecedente', 
+                                 'PourcentageValeurMin', 'PourcentageValeurMax', 
+                                 'EcartNormalise', 'ValeurActuelle', 'CodeParametre']]
+    predicted_risk_num = risk_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')
+
+    # Détermination de la tendance
+    valeur_anterieure = df_result['ValeurAnterieure'].values[0]
+    tendance = "Indéterminée (pas de valeur antérieure)"
+    if not pd.isna(valeur_anterieure) and valeur_anterieure != 0:
+        delta = df_result['DeltaValeurPrecedente'].values[0]
+        if abs(delta) < 0.05 * (max_usuel - min_usuel):
+            tendance = "Stable"
+        elif delta > 0:
+            tendance = "En hausse"
+        else:
+            tendance = "En baisse"
+
+    # Conseil simple
+    if degre_risque == "Aucun":
+        conseil = "Aucune action particulière requise. Les valeurs sont dans la plage normale."
+    elif degre_risque == "Faible":
+        conseil = f"À surveiller lors du prochain contrôle. Le {param['CodParametre']} est légèrement {statut.lower()}."
+    elif degre_risque == "Modéré":
+        conseil = f"Surveillance recommandée. Le {param['CodParametre']} est {statut.lower()} avec un risque modéré."
+    else:  # Élevé
+        conseil = f"Consultation médicale recommandée. Le {param['CodParametre']} présente un risque élevé."
+
+    # Conversion explicite des types pour la réponse JSON
+    return {
+        "parametre": to_native(param['CodeParametre']),
+        "valeur_actuelle": to_native(valeur_actuelle),
+        "unite": to_native(param.get('Unite', '')),
+        "valeur_anterieure": to_native(valeur_anterieure) if not pd.isna(valeur_anterieure) else "n'existe pas",
+        "valeurs_usuelles": to_native(param.get('ValeursUsuelles', '')),
+        "statut_risque": to_native(statut),
+        "degre_risque": to_native(degre_risque),
+        "tendance": to_native(tendance),
+        "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é."
+        
+        return {
+            "disease_prediction": prediction_text,
+            "confidence": confidence,
+            "explanation": explanation,
+            "recommendations": recommendations
+        }
+        
+    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é."
+        }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=7860,
+        reload=False
+    ) 

requirements.txt

@@ -0,0 +1,14 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+joblib==1.3.2
+pandas==2.1.4
+pdfplumber==0.10.3
+numpy==1.24.3
+python-multipart==0.0.6
+rapidfuzz==3.6.1
+scikit-learn==1.3.2
+transformers==4.36.2
+torch==2.1.2
+python-dotenv==1.0.0
+huggingface-hub==0.20.3