first commit

.dockerignore

@@ -0,0 +1,5 @@
+venv/
+__pycache__/
+*.py[cod]
+.DS_Store
+.env

.gitignore

@@ -0,0 +1,19 @@
+# Environnements virtuels
+venv/
+.venv/
+env/
+.env/
+
+# Fichiers Python compilés
+app/__pycache__/
+*.pyc
+
+# Fichiers système
+.DS_Store
+
+# Configurations IDE
+.vscode/
+.idea/
+
+# Fichiers de logs
+*.log

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.10-slim
+
+#Installation des dépendances système supplémentaires
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Création de l'utilisateur user (requis par Hugging Face)
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user
+ENV PATH=/home/user/.local/bin:$PATH
+
+# Définir le répertoire de travail
+WORKDIR $HOME/app
+
+# Copier les fichiers de requirements avec les bonnes permissions
+COPY --chown=user:user requirements.txt .
+
+# Passer à l'utilisateur user
+USER user
+
+# Installer les dépendances Python
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copier le reste de l'application
+COPY --chown=user:user . .
+
+# Port requis par Hugging Face Spaces
+EXPOSE 7860
+
+# Variables d'environnement pour Hugging Face Spaces
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# Commande de démarrage compatible HF Spaces
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--log-level", "info"]

README.md

@@ -1,10 +1,12 @@
 ---
 title: Reco Orchestrator Api
-emoji: 📈
-colorFrom: gray
-colorTo: red
+emoji: 👁
+colorFrom: red
+colorTo: pink
 sdk: docker
 pinned: false
+short_description: Api d'orchestrateur des micros services d'inférence
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+uvicorn app.main:app --host 0.0.0.0 --port 7860 --log-level debug

app/config.py

@@ -0,0 +1,17 @@
+model_configs_ = [
+    {
+        "model_name": "efficientnetv2m",
+        "url": "https://rkonan-reco-efficientnet-api.hf.space/predict",
+        "health_url": "https://rkonan-reco-efficientnet-api.hf.space/health"
+    },
+    {
+        "model_name": "resnet50v2",
+        "url": "https://rkonan-reco-resnet-api.hf.space/predict",
+        "health_url": "https://rkonan-reco-resnet-api.hf.space/health"
+    }
+]
+
+# Ping interval en secondes
+HEALTH_CHECK_INTERVAL = 60  # à ajuster selon besoin
+HEARTBEAT_TIMEOUT_SECONDS = 120  # 2 minutes
+HEALTHCHECK_INTERVAL_SECONDS = 60

app/main.py

@@ -0,0 +1,144 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request, Query,Body
+from pydantic import BaseModel
+from typing import Union
+import base64
+import logging
+from app.voting import soft_voting
+from app.model_status import monitor_models_async, get_model_status,get_alive_model_configs,check_and_update_model_status_once
+from app.config import HEALTH_CHECK_INTERVAL,HEALTHCHECK_INTERVAL_SECONDS,HEARTBEAT_TIMEOUT_SECONDS
+import asyncio
+from app.model_registry import get_model_registry,store_model
+import time
+
+
+# Logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+
+
+# Schéma pour les payloads JSON base64
+class ImagePayload(BaseModel):
+    image: str
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("🚀 Démarrage de l'orchestrateur")
+
+    asyncio.create_task(monitor_models_async(get_model_registry()))
+
+
+      
+
+
+@app.post("/predict")
+async def predict(
+    request: Request,
+    file: UploadFile = File(None),
+    payload: Union[ImagePayload, None] = None,
+    mode: str = Query("single", enum=["single", "voting", "automatic"], description="Mode de prédiction"),
+    show_heatmap: bool = Query(False, description="Afficher la heatmap"),
+    default_model: str = Query("efficientnetv2m", enum=["efficientnetv2m", "resnet50"], description="Modèle par défaut")
+):
+    logger.info("🔁 Requête reçue")
+    logger.info(f"Mode : {mode}, Default model : {default_model}, Heatmap : {show_heatmap}")
+
+    try:
+        # Lire image depuis un fichier uploadé
+        if file:
+            image_bytes = await file.read()
+            logger.info(f"📂 Image reçue via multipart : {file.filename}, {len(image_bytes)} octets")
+        else:
+            # Sinon essayer de lire le JSON base64
+            body = await request.json()
+            if "image" not in body:
+                raise HTTPException(status_code=422, detail="Champ 'image' manquant.")
+            image_bytes = base64.b64decode(body["image"])
+            logger.info(f"📦 Image reçue via JSON base64 : {len(image_bytes)} octets")
+
+        # Définir les endpoints des APIs modèles
+        model_configs = get_alive_model_configs()
+
+        # Appel au vote multi-modèles
+       
+        prediction = await soft_voting(model_configs, image_bytes, mode, show_heatmap, default_model)
+        return prediction
+    except HTTPException :
+            raise 
+
+    except Exception as e:
+        logger.error("❌ Erreur lors du traitement de la requête", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "ok",
+        **get_model_status()
+    }
+
+class RegisterModelRequest(BaseModel):
+    model_name: str
+    model_type: str
+    url: str
+    
+
+@app.post("/register_model")
+async def register_model(payload: RegisterModelRequest):
+    model_name = payload.model_name
+    model_type=payload.model_type
+    url = payload.url
+
+     # Si le modèle est déjà enregistré : mettre à jour son URL et le status
+    model_registry= get_model_registry()
+    if model_name in model_registry:
+        logger.info(f"🔄 Mise à jour de l'enregistrement pour {model_name}")
+    else:
+        logger.info(f"🆕 Nouveau modèle enregistré : {model_name}")
+
+    store_model(model_name, model_type,
+        url,
+         time.time(),
+         "online")
+    
+    await check_and_update_model_status_once(model_name)
+    logger.info(f"✅  {model_name} enregistré avec succès")
+    return {"message": f"{model_name} enregistré avec succès"}
+
+from pydantic import BaseModel
+
+class HeartbeatRequest(BaseModel):
+    model_name: str
+
+
+
+@app.post("/heartbeat")
+async def heartbeat(payload: HeartbeatRequest):
+    model_name = payload.model_name
+    model_registry=get_model_registry()
+    if model_name not in model_registry :
+        raise HTTPException(status_code=404, detail="Modèle inconnu")
+    model_registry[model_name]["last_seen"] = time.time()
+    model_registry[model_name]["status"] = "online"
+    logger.info(f"💓 Heartbeat reçu de {model_name}")
+    return {"message": f"Heartbeat reçu de {model_name}"}
+
+
+
+@app.get("/available_models")
+async def get_available_models():
+    model_registry = get_model_registry()
+    return {
+        "models": [
+            {"name": name, "model_type" : info["model_type"],"url": info["url"], "status": info["status"]}
+            for name, info in model_registry.items()
+            if info["status"] == "online"
+        ]
+    }
+
+

app/model_registry.py

@@ -0,0 +1,14 @@
+from typing import Dict
+model_registry: Dict[str, Dict] = {}
+
+def get_model_registry():
+    return model_registry
+
+def store_model(name: str, model_type: str, url: str,last_seen,status: str):
+    model_registry[name] = {
+        "model_name": name,
+        "model_type":model_type,
+        "url": url,
+        "last_seen": last_seen,
+        "status":  status
+    }

app/model_status.py

@@ -0,0 +1,98 @@
+import asyncio
+import logging
+import httpx
+import time
+from app.config import HEALTH_CHECK_INTERVAL,HEALTHCHECK_INTERVAL_SECONDS,HEARTBEAT_TIMEOUT_SECONDS
+
+logger = logging.getLogger(__name__)
+
+# Stockage global
+alive_models = []
+dead_models = []
+
+async def ping_api(session, config):
+    try:
+        async with session.get(config["health_url"], timeout=2) as resp:
+            return resp.status == 200
+    except Exception:
+        return False
+
+def get_model_status():
+    return {
+        "alive_models": [m["model_name"]  for m in alive_models],
+        "dead_models":  [m["model_name"]  for m in dead_models]
+    }
+
+def get_alive_model_configs():
+    return alive_models
+
+
+async def monitor_models_async(model_registry):
+    global alive_models, dead_models
+    while True:
+        now=time.time()
+        temp_alive = []
+        temp_dead = []
+        for name, info in model_registry.items():
+            time_diff = now - info["last_seen"]
+            if time_diff > HEARTBEAT_TIMEOUT_SECONDS:
+                try:
+                    health_url = info["url"].replace("/predict", "/health")
+                    async with httpx.AsyncClient(timeout=3) as client:
+                        resp = await client.get(health_url)
+                        if resp.status_code == 200:
+                            model_registry[name]["status"] = "online"
+                        else:
+                            model_registry[name]["status"] = "offline"
+                except:
+                    model_registry[name]["status"] = "offline"
+            if model_registry[name]["status"] == "online":
+                temp_alive.append(model_registry[name])
+            else:
+                temp_dead.append(model_registry[name])
+
+        alive_models =temp_alive
+        dead_models = temp_dead
+        alive=[m["model_name"] for m in alive_models]
+        dead=[m["model_name"] for m in dead_models]
+
+        logger.info(f"✅ Modèles actifs : {alive}")
+        logger.warning(f"❌ Modèles inactifs : {dead}")
+
+        await asyncio.sleep(HEALTHCHECK_INTERVAL_SECONDS)
+
+
+import httpx
+from app.model_registry import get_model_registry
+
+async def check_and_update_model_status_once(model_name: str):
+    global alive_models, dead_models
+    registry = get_model_registry()
+    info = registry.get(model_name)
+    if not info:
+        return
+
+    try:
+        health_url = info["url"].replace("/predict", "/health")
+        async with httpx.AsyncClient(timeout=3) as client:
+            resp = await client.get(health_url)
+            status = "online" if resp.status_code == 200 else "offline"
+    except:
+        status = "offline"
+
+    info["status"] = status
+     # 🔁 Mettre à jour les listes globales
+    temp_alive = []
+    temp_dead = []
+    for name, m_info in registry.items():
+        if m_info.get("status") == "online":
+            temp_alive.append(m_info)
+        else:
+            temp_dead.append(m_info)
+
+    alive_models = temp_alive
+    dead_models = temp_dead
+
+    logger.info(f"🔁 Mise à jour unique pour `{model_name}` → {status}")
+    logger.info(f"✅ Modèles actifs : {[m['model_name'] for m in alive_models]}")
+    logger.warning(f"❌ Modèles inactifs : {[m['model_name'] for m in dead_models]}")

app/utils.py

@@ -0,0 +1,46 @@
+# utils.py ou dans main.py
+
+import aiohttp
+import asyncio
+import numpy as np
+from scipy.spatial.distance import jensenshannon
+
+shannon_threashold=0.15
+
+
+def compute_js_divergence(all_probs):
+    """
+    Calcule la divergence de Jensen-Shannon sur une liste de distributions de probabilités.
+    
+    Args:
+        all_probs (list of np.array): Liste des prédictions de chaque modèle (softmax).
+    
+    Returns:
+        float: La divergence de Jensen-Shannon entre les modèles.
+    """
+    if len(all_probs) < 2:
+        return 0.0  # Pas de désaccord possible avec un seul modèle
+
+    # Convertir la liste en tableau numpy (shape: [nb_modèles, nb_classes])
+    probs_array = np.array(all_probs)
+
+    # Calculer la moyenne des distributions (distribution "moyenne")
+    mean_probs = np.mean(probs_array, axis=0)
+
+    # Calculer la JSD entre chaque modèle et la moyenne
+    jsd_values = []
+    for probs in probs_array:
+        jsd = jensenshannon(probs, mean_probs, base=2)  # base=2 : divergence bornée entre 0 et 1
+        jsd_values.append(jsd)
+
+    # Retourner la moyenne des divergences
+    return np.mean(jsd_values)
+
+# Si js_divergence > 0.1 → Désaccord modéré
+
+def compute_entropy_safe(probas):
+    probas = np.array(probas)
+    # On garde uniquement les probabilités strictement positives
+    mask = probas > 0
+    entropy = -(np.sum(probas[mask] * np.log(probas[mask])))
+    return entropy

app/voting.py

@@ -0,0 +1,168 @@
+import aiohttp
+import numpy as np
+import logging
+from app.utils import compute_js_divergence,shannon_threashold,compute_entropy_safe
+from app.model_status import monitor_models_async,check_and_update_model_status_once
+from app.model_registry import get_model_registry
+from fastapi import HTTPException
+
+logging.basicConfig(
+    level=logging.DEBUG,  # ou logging.DEBUG
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+async def call_model_api(config, image_bytes, show_heatmap):
+    async with aiohttp.ClientSession() as session:
+        try:
+            files = {
+                'file': image_bytes
+            }
+            params = {
+                'show_heatmap': str(show_heatmap).lower()
+            }
+            async with session.post(config["url"], data=files, params=params) as resp:
+                if resp.status != 200:
+                    logger.warning(f"⚠️ Échec de l'appel à {config['model_name']} : {resp.status}")
+                    return None
+                return await resp.json()
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de l'appel à l'API {config['model_name']}: {e}")
+            await check_and_update_model_status_once(config["model_name"])
+            return None
+
+
+async def soft_voting(model_configs, image_bytes: bytes, mode, show_heatmap, default_model):
+    logger.info("🔁 Début de la prédiction multi-modèles")
+
+    all_probs = []
+    models = []
+    models_predictions = []
+    models_confidences = []
+    models_entropies = []
+    models_uncertainties = []
+    models_heatmaps = []
+
+    default_config = next((cfg for cfg in model_configs if cfg["model_name"].lower() == default_model.lower()), None)
+   
+
+    if not default_config:
+        logger.warning(f"❌ Modèle par défaut '{default_model}' non trouvé ou indisponible.")
+        if mode == "single":
+            raise HTTPException(
+             status_code=400,
+            detail=f"Modèle par défaut '{default_model}' indisponible. Veuillez en choisir un autre ou réessayer plus tard.")
+
+        else:
+            logger.info(f"🔁 Fallback : passage automatique en mode 'voting'")
+
+            mode = "voting"
+
+
+    # 🔰 Étape 1 : prédiction avec le modèle par défaut
+    logger.info(f"🚀 Prédiction avec le modèle par défaut : {default_model}")
+    prediction = await call_model_api(default_config, image_bytes, show_heatmap)
+    if prediction is None:
+        raise Exception("Aucune réponse du modèle par défaut.")
+
+    all_probs.append(np.array(prediction["preds"]))
+    models_predictions.append(prediction["predicted_class"])
+    models_confidences.append(prediction["confidence"])
+    models_entropies.append(prediction["entropy"])
+    models_uncertainties.append(prediction["is_uncertain_model"])
+    logger.debug(f"🧠 Incertitude du modèle ajoutée : {prediction['is_uncertain_model']}")
+
+    models.append(default_config["model_name"])
+
+    if show_heatmap:
+        heatmap = prediction.get("heatmap")
+        if heatmap:
+            models_heatmaps.append(heatmap)
+
+    mean_probs = np.mean(all_probs, axis=0)
+    final_class = int(np.argmax(mean_probs))
+    final_confidence = float(mean_probs[final_class])
+    entropy = float(compute_entropy_safe(mean_probs))
+    jsd_score = float(compute_js_divergence(all_probs))
+
+    # 🛑 Mode 'single' → retour immédiat
+    if mode == "single":
+        is_global_uncertain = models_uncertainties[0]
+        logger.info("🛑 Mode 'single' activé")
+        return {
+            "predicted_class": final_class,
+            "confidence": final_confidence,
+            "entropy": entropy,
+            "jsd_score": jsd_score,
+            "models": models,
+            "is_global_uncertain": is_global_uncertain,
+            "models_predictions": models_predictions,
+            "models_confidences": models_confidences,
+            "models_entropies": models_entropies,
+            "models_uncertainties": models_uncertainties,
+            "models_heatmaps": models_heatmaps
+        }
+
+    # 🧠 Mode 'automatic' → si confiance suffisante on s'arrête
+    if mode == "automatic" and prediction["confidence"] >= 0.90:
+        is_global_uncertain = models_uncertainties[0]
+        logger.info("✅ Confiance suffisante, pas de vote")
+        return {
+            "predicted_class": final_class,
+            "confidence": final_confidence,
+            "entropy": entropy,
+            "jsd_score": jsd_score,
+            "models": models,
+            "is_global_uncertain": is_global_uncertain,
+            "models_predictions": models_predictions,
+            "models_confidences": models_confidences,
+            "models_entropies": models_entropies,
+            "models_uncertainties": models_uncertainties,
+            "models_heatmaps": models_heatmaps
+        }
+
+    # 🔁 Sinon → on complète avec les autres modèles
+    logger.info(f"🔍 Mode '{mode}' : on appelle les autres modèles")
+
+    for config in model_configs:
+        if config["model_name"].lower() == default_model.lower():
+            continue
+
+        prediction = await call_model_api(config, image_bytes, show_heatmap)
+        if not prediction:
+            continue
+
+        all_probs.append(np.array(prediction["preds"]))
+        models_predictions.append(prediction["predicted_class"])
+        models_confidences.append(prediction["confidence"])
+        models_entropies.append(prediction["entropy"])
+        models_uncertainties.append(prediction["is_uncertain_model"])
+        models.append(config["model_name"])
+
+        if show_heatmap and prediction.get("heatmap"):
+            models_heatmaps.append(prediction["heatmap"])
+
+    mean_probs = np.mean(all_probs, axis=0)
+    final_class = int(np.argmax(mean_probs))
+    final_confidence = float(mean_probs[final_class])
+    entropy = float(compute_entropy_safe(mean_probs))
+    jsd_score = float(compute_js_divergence(all_probs))
+    is_global_uncertain = any(models_uncertainties) and jsd_score > shannon_threashold
+
+    logger.info("✅ Vote terminé")
+    return {
+        "predicted_class": final_class,
+        "confidence": final_confidence,
+        "entropy": entropy,
+        "jsd_score": jsd_score,
+        "models": models,
+        "is_global_uncertain": is_global_uncertain,
+        "models_predictions": models_predictions,
+        "models_confidences": models_confidences,
+        "models_entropies": models_entropies,
+        "models_uncertainties": models_uncertainties,
+        "models_heatmaps": models_heatmaps
+    }
+
+

app/voting_save_para.py

@@ -0,0 +1,116 @@
+import aiohttp
+import numpy as np
+import logging
+from app.utils import compute_js_divergence,shannon_threashold,compute_entropy_safe
+from app.model_status import monitor_models_async,check_and_update_model_status_once
+from app.model_registry import get_model_registry
+from fastapi import HTTPException
+import asyncio
+import numpy as np
+from fastapi import HTTPException
+
+logging.basicConfig(
+    level=logging.DEBUG,  # ou logging.DEBUG
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+async def call_model_api(config, image_bytes, show_heatmap):
+    async with aiohttp.ClientSession() as session:
+        try:
+            files = {
+                'file': image_bytes
+            }
+            params = {
+                'show_heatmap': str(show_heatmap).lower()
+            }
+            async with session.post(config["url"], data=files, params=params) as resp:
+                if resp.status != 200:
+                    logger.warning(f"⚠️ Échec de l'appel à {config['model_name']} : {resp.status}")
+                    return None
+                return await resp.json()
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de l'appel à l'API {config['model_name']}: {e}")
+            await check_and_update_model_status_once(config["model_name"])
+            return None
+
+
+
+async def soft_voting(model_configs, image_bytes: bytes, mode, show_heatmap, default_model):
+    logger.info("🔁 Début de la prédiction hybride multi-modèles")
+
+    default_config = next((cfg for cfg in model_configs if cfg["model_name"].lower() == default_model.lower()), None)
+    if not default_config:
+        raise HTTPException(400, f"Modèle par défaut '{default_model}' indisponible.")
+
+    logger.info(f"🚀 Prédiction avec le modèle par défaut : {default_model}")
+    default_pred = await call_model_api(default_config, image_bytes, show_heatmap)
+    if not default_pred:
+        raise Exception("Aucune réponse du modèle par défaut.")
+
+    if mode == "single" or (mode == "automatic" and default_pred["confidence"] >= 0.90):
+        logger.info("✅ Mode 'single' ou confiance suffisante en 'automatic'")
+        return {
+            "predicted_class": default_pred["predicted_class"],
+            "confidence": default_pred["confidence"],
+            "entropy": default_pred["entropy"],
+            "jsd_score": 0.0,
+            "models": [default_config["model_name"]],
+            "is_global_uncertain": default_pred["is_uncertain_model"],
+            "models_predictions": [default_pred["predicted_class"]],
+            "models_confidences": [default_pred["confidence"]],
+            "models_entropies": [default_pred["entropy"]],
+            "models_uncertainties": [default_pred["is_uncertain_model"]],
+            "models_heatmaps": [default_pred.get("heatmap")] if show_heatmap else []
+        }
+    if mode!="voting":
+        logger.info("📡 Confiance insuffisante → prédiction en parallèle des autres modèles")
+    else:
+        logger.info("📡 prédiction vote en parallèle")
+
+    async def call_model(config):
+        pred = await call_model_api(config, image_bytes, show_heatmap)
+        return (config["model_name"], pred) if pred else None
+
+    other_configs = [cfg for cfg in model_configs if cfg["model_name"].lower() != default_model.lower()]
+    results = await asyncio.gather(*(call_model(cfg) for cfg in other_configs))
+    results = [(default_config["model_name"], default_pred)] + [r for r in results if r]
+
+    # Fusion des prédictions
+    all_probs, models, models_predictions, models_confidences = [], [], [], []
+    models_entropies, models_uncertainties, models_heatmaps = [], [], []
+
+    for model_name, pred in results:
+        all_probs.append(np.array(pred["preds"]))
+        models.append(model_name)
+        models_predictions.append(pred["predicted_class"])
+        models_confidences.append(pred["confidence"])
+        models_entropies.append(pred["entropy"])
+        models_uncertainties.append(pred["is_uncertain_model"])
+        if show_heatmap and pred.get("heatmap"):
+            models_heatmaps.append(pred["heatmap"])
+
+    mean_probs = np.mean(all_probs, axis=0)
+    final_class = int(np.argmax(mean_probs))
+    final_confidence = float(mean_probs[final_class])
+    entropy = float(compute_entropy_safe(mean_probs))
+    jsd_score = float(compute_js_divergence(all_probs))
+    is_global_uncertain = any(models_uncertainties) and jsd_score > shannon_threashold
+
+    logger.info("✅ Vote hybride terminé")
+    return {
+        "predicted_class": final_class,
+        "confidence": final_confidence,
+        "entropy": entropy,
+        "jsd_score": jsd_score,
+        "models": models,
+        "is_global_uncertain": is_global_uncertain,
+        "models_predictions": models_predictions,
+        "models_confidences": models_confidences,
+        "models_entropies": models_entropies,
+        "models_uncertainties": models_uncertainties,
+        "models_heatmaps": models_heatmaps
+    }
+
+

requirements.txt

@@ -0,0 +1,89 @@
+absl-py==1.4.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.13
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+asttokens==3.0.0
+astunparse==1.6.3
+attrs==25.3.0
+certifi==2025.6.15
+charset-normalizer==3.4.2
+click==8.2.1
+comm==0.2.2
+contourpy==1.3.2
+cycler==0.12.1
+debugpy==1.8.14
+decorator==5.2.1
+Deprecated==1.2.18
+dm-tree==0.1.9
+executing==2.2.0
+fastapi==0.115.12
+flatbuffers==25.2.10
+fonttools==4.58.4
+frozenlist==1.7.0
+gast==0.6.0
+google-pasta==0.2.0
+grpcio==1.73.0
+h11==0.16.0
+h5py==3.14.0
+idna==3.10
+imageio==2.37.0
+jedi==0.19.2
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+keras==3.10.0
+kiwisolver==1.4.8
+libclang==18.1.1
+Markdown==3.8
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.3
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+ml_dtypes==0.5.1
+multidict==6.4.4
+namex==0.1.0
+nest-asyncio==1.6.0
+numpy==1.26.4
+opencv-python==4.11.0.86
+opt_einsum==3.4.0
+optree==0.16.0
+packaging==25.0
+parso==0.8.4
+pexpect==4.9.0
+pillow==11.2.1
+platformdirs==4.3.8
+prompt_toolkit==3.0.51
+propcache==0.3.2
+protobuf==5.29.5
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pydantic==2.11.7
+pydantic_core==2.33.2
+Pygments==2.19.1
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pyzmq==27.0.0
+requests==2.32.4
+rich==14.0.0
+scipy==1.11.4
+setuptools==80.9.0
+six==1.17.0
+sniffio==1.3.1
+stack-data==0.6.3
+starlette==0.46.2
+termcolor==3.1.0
+tornado==6.5.1
+traitlets==5.14.3
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+urllib3==2.4.0
+uvicorn==0.34.3
+wcwidth==0.2.13
+Werkzeug==3.1.3
+wheel==0.45.1
+wrapt==1.17.2
+yarl==1.20.1