Upload 16 files

.env.example

@@ -0,0 +1,6 @@
+# Configuration DeepSeek API
+DEEPSEEK_API_URL=https://shads229-personnal-ai.hf.space/v1/chat/completions
+DEEPSEEK_API_KEY=Shadobsh
+
+# Optionnel : Port du serveur (défaut: 7860 pour Hugging Face)
+PORT=7860

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,44 +1,44 @@
-# Utiliser une image Python légère
-FROM python:3.10-slim
-
-# Éviter les fichiers .pyc et activer le mode non-interactif
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    DEBIAN_FRONTEND=noninteractive
-
-# Installer les dépendances système pour OpenCV, FFmpeg et l'audio
-RUN apt-get update && apt-get install -y \
-    libgl1 \
-    libglib2.0-0 \
-    libsm6 \
-    libxext6 \
-    libxrender-dev \
-    ffmpeg \
-    gcc \
-    python3-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Créer un utilisateur pour Hugging Face
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
-
-WORKDIR $HOME/app
-
-# Copier et installer les dépendances Python
-COPY --chown=user requirements.txt .
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
-
-# Copier l'intégralité du code (backend, engine, app.py, .env)
-COPY --chown=user . .
-
-# Créer les dossiers de données nécessaires
-RUN mkdir -p video_analysis_pro/output video_analysis_pro/cache video_analysis_pro/reports
-
-# Exposer le port par défaut
-EXPOSE 7860
-
-# Démarrer l'application via le point d'entrée app.py
-CMD ["python", "app.py"]
+# Utiliser une image Python légère
+FROM python:3.10-slim
+
+# Éviter les fichiers .pyc et activer le mode non-interactif
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    DEBIAN_FRONTEND=noninteractive
+
+# Installer les dépendances système pour OpenCV, FFmpeg et l'audio
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    ffmpeg \
+    gcc \
+    python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Créer un utilisateur pour Hugging Face
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# Copier et installer les dépendances Python
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copier l'intégralité du code (backend, engine, app.py, .env)
+COPY --chown=user . .
+
+# Créer les dossiers de données nécessaires
+RUN mkdir -p video_analysis_pro/output video_analysis_pro/cache video_analysis_pro/reports
+
+# Exposer le port par défaut
+EXPOSE 7860
+
+# Démarrer l'application via le point d'entrée app.py
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,10 @@
----
-title: Zenith AI
-emoji: 📚
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Zenith AI
+emoji: 📚
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,8 +1,8 @@
-from backend.main import app
-import uvicorn
-import os
-
-if __name__ == "__main__":
-    # Hugging Face utilise le port 7860 par défaut
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+from backend.main import app
+import uvicorn
+import os
+
+if __name__ == "__main__":
+    # Hugging Face utilise le port 7860 par défaut
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

backend/core/engine.py

@@ -1,392 +1,337 @@
-import os, json, logging, time, base64, gc, asyncio, concurrent.futures
-import cv2, numpy as np, torch
-from pathlib import Path
-from typing import List, Dict, Any, Optional, AsyncGenerator
-from collections import Counter
-from dataclasses import dataclass
-from dotenv import load_dotenv
-
-load_dotenv()
-
-# Configuration
-GEMINI_MODEL = "gemini-2.5-flash"
-BASE_DIR = Path("video_analysis_pro")
-OUTPUT_DIR, CACHE_DIR, REPORTS_DIR = BASE_DIR/"output", BASE_DIR/"cache", BASE_DIR/"reports"
-for d in [BASE_DIR, OUTPUT_DIR, CACHE_DIR, REPORTS_DIR]: d.mkdir(parents=True, exist_ok=True)
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger("ZenithEngine")
-
-# Tools Availability
-try:
-    from ultralytics import YOLO
-    YOLO_AVAILABLE = True
-except ImportError:
-    YOLO_AVAILABLE = False
-
-try:
-    from faster_whisper import WhisperModel
-    WHISPER_AVAILABLE = True
-except ImportError:
-    WHISPER_AVAILABLE = False
-
-@dataclass
-class Frame:
-    path: Path
-    timestamp: float
-    metrics: Dict[str, float] = None
-    vision_content: str = ""
-
-class AuthManager:
-    def __init__(self):
-        self.refresh_url = "https://oauth2.googleapis.com/token"
-        self.client_id = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"
-        self.client_secret = "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"
-        self.access_token = None
-        self.expiry_time = 0
-
-        service_account_env = os.getenv("GCP_SERVICE_ACCOUNT")
-        if service_account_env:
-            try:
-                cleaned_env = service_account_env.strip()
-                # Supprimer les guillemets éventuels
-                if (cleaned_env.startswith("'") and cleaned_env.endswith("'")) or \
-                   (cleaned_env.startswith('"') and cleaned_env.endswith('"')):
-                    cleaned_env = cleaned_env[1:-1]
-
-                # Vérifier si c'est un chemin vers un fichier
-                if os.path.isfile(cleaned_env):
-                    with open(cleaned_env, 'r') as f:
-                        self.creds = json.load(f)
-                    logger.info(f"✅ Credentials chargés depuis le fichier : {cleaned_env}")
-                else:
-                    # Sinon, tenter de décoder comme du JSON brut
-                    self.creds = json.loads(cleaned_env)
-                    logger.info("✅ Credentials chargés depuis la variable d'environnement (JSON brut)")
-            except Exception as e:
-                logger.error(f"❌ Erreur critique lors du chargement de GCP_SERVICE_ACCOUNT : {e}")
-                self.creds = {}
-        else:
-            self.creds = {}
-
-    async def get_access_token(self) -> str:
-        if self.access_token and time.time() < (self.expiry_time - 300):
-            return self.access_token
-
-        if not self.creds:
-            logger.error("❌ GCP_SERVICE_ACCOUNT est vide ou mal configuré dans les secrets.")
-            return ""
-
-        refresh_token = self.creds.get("refresh_token")
-        if not refresh_token:
-            logger.error("❌ 'refresh_token' introuvable dans le JSON de GCP_SERVICE_ACCOUNT.")
-            return ""
-
-        payload = {
-            "client_id": self.client_id, "client_secret": self.client_secret,
-            "refresh_token": refresh_token, "grant_type": "refresh_token"
-        }
-        import httpx
-        async with httpx.AsyncClient() as client:
-            try:
-                response = await client.post(self.refresh_url, data=payload)
-                if response.status_code != 200:
-                    logger.error(f"❌ Échec du rafraîchissement du token (HTTP {response.status_code}): {response.text}")
-                    return ""
-                data = response.json()
-                self.access_token = data["access_token"]
-                self.expiry_time = time.time() + data.get("expires_in", 3600)
-                logger.info("✅ Nouveau jeton d'accès Gemini récupéré avec succès.")
-                return self.access_token
-            except Exception as e:
-                logger.error(f"❌ Erreur réseau lors du rafraîchissement du token : {str(e)}")
-                return ""
-
-class GeminiClient:
-    def __init__(self, auth_manager: AuthManager):
-        self.auth_manager = auth_manager
-        self.base_url = "https://cloudcode-pa.googleapis.com/v1internal"
-        self.project_id = os.getenv("GEMINI_PROJECT_ID")
-
-    async def discover_project_id(self) -> str:
-        if self.project_id: return self.project_id
-        token = await self.auth_manager.get_access_token()
-        if not token:
-            logger.warning("⚠️ Pas de token disponible pour découvrir le project_id.")
-            return "default-project"
-        import httpx
-        async with httpx.AsyncClient() as client:
-            try:
-                resp = await client.post(
-                    f"{self.base_url}:loadCodeAssist",
-                    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
-                    json={"cloudaicompanionProject": "default-project", "metadata": {"duetProject": "default-project"}}
-                )
-                if resp.status_code == 200:
-                    data = resp.json()
-                    self.project_id = data.get("cloudaicompanionProject", "default-project")
-                    return self.project_id
-            except Exception as e:
-                logger.error(f"⚠️ Erreur lors de la découverte du projet ID: {e}")
-            return "default-project"
-
-    async def stream_content(self, model: str, messages: List[Dict[str, Any]], options: Dict[str, Any]) -> AsyncGenerator[Dict[str, Any], None]:
-        token = await self.auth_manager.get_access_token()
-        if not token:
-            yield {"error": "Authentification échouée. Vérifiez votre secret GCP_SERVICE_ACCOUNT sur Hugging Face."}
-            return
-
-        project_id = await self.discover_project_id()
-
-        # Format messages for API
-        contents = []
-        for msg in messages:
-            role = "model" if msg["role"] == "assistant" else "user"
-            parts = []
-            content = msg.get("content", "")
-            if isinstance(content, str): parts.append({"text": content})
-            elif isinstance(content, list):
-                for part in content:
-                    if part["type"] == "text": parts.append({"text": part["text"]})
-                    elif part["type"] == "image_url":
-                        url = part["image_url"]["url"]
-                        if url.startswith("data:"):
-                            mime, b64 = url.split(";base64,")
-                            parts.append({"inlineData": {"mimeType": mime.split(":")[1], "data": b64}})
-            contents.append({"role": role, "parts": parts})
-
-        payload = {
-            "model": model, "project": project_id,
-            "request": {
-                "contents": contents,
-                "generationConfig": {"temperature": options.get("temperature", 0.7)},
-                "safetySettings": [{"category": c, "threshold": "BLOCK_NONE"} for c in [
-                    "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_HATE_SPEECH",
-                    "HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT"
-                ]]
-            }
-        }
-
-        import httpx
-        async with httpx.AsyncClient() as client:
-            try:
-                async with client.stream(
-                    "POST", f"{self.base_url}:streamGenerateContent?alt=sse",
-                    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
-                    json=payload, timeout=None
-                ) as response:
-                    async for line in response.aiter_lines():
-                        if line.startswith("data: "):
-                            yield json.loads(line[6:])
-            except Exception as e:
-                yield {"error": str(e)}
-
-class VideoProcessor:
-    @staticmethod
-    def get_frame_metrics(frame: np.ndarray) -> dict:
-        try:
-            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
-            return {"brightness": float(np.mean(gray)), "contrast": float(np.std(gray)),
-                    "saturation": float(np.mean(hsv[:, :, 1])), "sharpness": float(cv2.Laplacian(gray, cv2.CV_64F).var())}
-        except: return {"brightness": 0, "contrast": 0, "saturation": 0, "sharpness": 0}
-
-    def __init__(self, video_path: Path, output_dir: Path):
-        self.video_path, self.output_dir = video_path, output_dir
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-
-    def extract_keyframes(self, max_frames: int = 50) -> List[Frame]:
-        try:
-            from decord import VideoReader, cpu
-            vr = VideoReader(str(self.video_path), ctx=cpu(0))
-            total = len(vr)
-            step = max(1, total // max_frames)
-            indices = range(0, total, step)[:max_frames]
-            frames_data = vr.get_batch(indices).asnumpy()
-            fps = vr.get_avg_fps()
-            extracted = []
-            for i, idx in enumerate(indices):
-                img = cv2.cvtColor(frames_data[i], cv2.COLOR_RGB2BGR)
-                ts = idx / fps
-                p = self.output_dir / f"f_{idx}.jpg"
-                cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 85])
-                extracted.append(Frame(path=p, timestamp=ts, metrics=self.get_frame_metrics(img)))
-            return extracted
-        except Exception as e:
-            logger.warning(f"Decord failed, fallback to CV2: {e}")
-            cap = cv2.VideoCapture(str(self.video_path))
-            fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
-            total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 1000
-            step = max(1, total // max_frames)
-            extracted = []
-            for idx in range(0, total, step):
-                if len(extracted) >= max_frames: break
-                cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
-                ret, img = cap.read()
-                if ret:
-                    ts = idx / fps
-                    p = self.output_dir / f"f_{idx}.jpg"
-                    cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 85])
-                    extracted.append(Frame(path=p, timestamp=ts, metrics=self.get_frame_metrics(img)))
-            cap.release()
-            return extracted
-
-class AudioProcessor:
-    def __init__(self): self.model = None
-    def initialize(self):
-        if WHISPER_AVAILABLE and self.model is None:
-            try:
-                device = "cuda" if torch.cuda.is_available() else "cpu"
-                self.model = WhisperModel("base", device=device, compute_type="int8")
-            except: pass
-    def transcribe(self, p: Path) -> str:
-        self.initialize()
-        if not self.model: return "Transcription indisponible"
-        try:
-            segments, info = self.model.transcribe(str(p), beam_size=5)
-            transcript = " ".join([s.text for s in segments])
-            return f"[Langue source détectée: {info.language.upper()}] {transcript}"
-        except: return "Erreur transcription"
-
-class VideoDownloader:
-    @staticmethod
-    def download(url: str, output_dir: Path) -> Optional[Path]:
-        import yt_dlp
-        ydl_opts = {
-            'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
-            'outtmpl': str(output_dir / 'downloaded_video.%(ext)s'),
-            'noplaylist': True, 'quiet': True, 'no_warnings': True, 'nocheckcertificate': True,
-            'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'referer': 'https://www.google.com/',
-            'http_headers': {'Accept': '*/*', 'Accept-Language': 'en-US,en;q=0.9'}
-        }
-        try:
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(url, download=True)
-                return Path(ydl.prepare_filename(info))
-        except: return None
-
-class ZenithAnalyzer:
-    def __init__(self):
-        self.auth = AuthManager()
-        self.gemini = GeminiClient(self.auth)
-        self.audio_proc = AudioProcessor()
-        self.yolo = YOLO("yolov8n.pt") if YOLO_AVAILABLE else None
-
-    async def extract_frames_only(self, video_path: Path, session_id: str) -> List[str]:
-        session_dir = OUTPUT_DIR / f"session_{session_id}"
-        session_dir.mkdir(parents=True, exist_ok=True)
-        proc = VideoProcessor(video_path, session_dir)
-        frames = proc.extract_keyframes()
-        return [f"/output/session_{session_id}/{f.path.name}" for f in frames[:12]]
-
-    async def run_full_analysis(self, video_path: Path, session_id: str, custom_prompt: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
-        session_dir = OUTPUT_DIR / f"session_{session_id}"
-        session_dir.mkdir(parents=True, exist_ok=True)
-        cache_file = session_dir / "analysis_cache.json"
-
-        # Optimisation : Ne pas ré-extraire si les frames existent déjà
-        existing_frames = list(session_dir.glob("f_*.jpg"))
-        if not existing_frames:
-            yield {"status": "sampling", "message": "Analyse des séquences..."}
-            proc = VideoProcessor(video_path, session_dir)
-            frames = proc.extract_keyframes()
-        else:
-            def get_idx(p):
-                try: return int(p.stem.split('_')[1])
-                except: return 0
-            existing_paths = sorted(existing_frames, key=get_idx)
-            frames = []
-            for p in existing_paths:
-                img = cv2.imread(str(p))
-                metrics = VideoProcessor.get_frame_metrics(img) if img is not None else {"brightness": 0, "contrast": 0, "saturation": 0, "sharpness": 0}
-                frames.append(Frame(path=p, timestamp=0.0, metrics=metrics))
-            yield {"status": "sampling", "message": "Récupération des séquences existantes..."}
-
-        # Envoyer les chemins des images au frontend
-        frame_urls = [f"/output/session_{session_id}/{f.path.name}" for f in frames[:12]]
-        yield {"status": "frames_ready", "frames": frame_urls, "message": "Séquences prêtes."}
-
-        # Vérifier si on a un cache pour l'audio et le visuel
-        cached_data = {}
-        if cache_file.exists():
-            try:
-                with open(cache_file, "r") as f:
-                    cached_data = json.load(f)
-                logger.info(f"✅ Cache trouvé pour la session {session_id}")
-            except: pass
-
-        if "transcript" in cached_data and "vision_info" in cached_data:
-            transcript = cached_data["transcript"]
-            v_info = cached_data["vision_info"]
-            yield {"status": "fusion", "message": "Utilisation des données en cache..."}
-        else:
-            yield {"status": "audio", "message": "Traitement audio & visuel..."}
-            loop = asyncio.get_event_loop()
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                audio_task = loop.run_in_executor(executor, self.audio_proc.transcribe, video_path)
-
-                if self.yolo:
-                    all_paths = [str(f.path) for f in frames]
-                    batch_size = 10
-                    for i in range(0, len(all_paths), batch_size):
-                        batch = all_paths[i:i+batch_size]
-                        results = await loop.run_in_executor(executor, lambda: self.yolo(batch, verbose=False, imgsz=320, stream=False))
-                        for j, res in enumerate(results):
-                            idx = i + j
-                            objs = [res.names[int(b.cls[0])] for b in res.boxes if b.conf > 0.25]
-                            ambiance = f"Ambiance: {'Sombre' if frames[idx].metrics['brightness'] < 50 else 'Lumineuse'}"
-                            frames[idx].vision_content = f"{ambiance}, Objets: " + ", ".join([f"{v}x {k}" for k,v in Counter(objs).items()])
-
-                transcript = await audio_task
-
-            v_info = "\n".join([f"[{f.timestamp:.1f}s] {f.vision_content}" for f in frames[:40]])
-
-            # Sauvegarder dans le cache
-            try:
-                with open(cache_file, "w") as f:
-                    json.dump({"transcript": transcript, "vision_info": v_info}, f)
-            except: pass
-
-        yield {"status": "fusion", "message": "Intelligence Artificielle en action..."}
-
-        # Utilisation du prompt personnalisé si fourni
-        base_instruction = custom_prompt if custom_prompt else "Résumer et continuer l'analyse du média"
-
-        prompt = f"""Tu es l'unité Zenith AI, un système d'analyse de données multimédias.
-        INSTRUCTION UTILISATEUR : {base_instruction}
-
-        DONNÉES D'ENTRÉE :
-        - TRANSCRIPTION : {transcript}
-        - DONNÉES VISUELLES : {v_info}
-
-        Produis un rapport TECHNIQUE, FACTUEL et STRUCTURÉ en Markdown."""
-
-        # Encodage parallèle des images
-        selected_frames = [frames[i] for i in range(0, len(frames), max(1, len(frames)//10))][:10]
-        def encode_f(f):
-            img = cv2.imread(str(f.path))
-            _, buf = cv2.imencode('.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 70])
-            return {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64.b64encode(buf).decode()}"}}
-
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            images = list(executor.map(encode_f, selected_frames))
-
-        messages = [{"role": "user", "content": [{"type": "text", "text": prompt}] + images}]
-
-        yield {"status": "generating", "message": "Génération du rapport par l'IA..."}
-        async for chunk in self.gemini.stream_content(GEMINI_MODEL, messages, {"temperature": 0.7}):
-            if "error" in chunk:
-                yield {"error": chunk["error"]}
-                break
-            resp = chunk.get("response", {})
-            candidates = resp.get("candidates", [])
-            if candidates:
-                for part in candidates[0].get("content", {}).get("parts", []):
-                    text = part.get("text", "")
-                    if text: yield {"status": "streaming", "text": text}
-
-        # Cleanup
-        gc.collect()
-        if torch.cuda.is_available(): torch.cuda.empty_cache()
-        yield {"status": "completed", "message": "Analyse terminée."}
+import os, json, logging, time, base64, gc, asyncio, concurrent.futures
+import cv2, numpy as np, torch
+from pathlib import Path
+from typing import List, Dict, Any, Optional, AsyncGenerator
+from collections import Counter
+from dataclasses import dataclass
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configuration
+DEEPSEEK_API_URL = "https://shads229-personnal-ai.hf.space/v1/chat/completions"
+DEEPSEEK_API_KEY = "Shadobsh"
+DEEPSEEK_MODEL = "deepseek-chat"
+BASE_DIR = Path("video_analysis_pro")
+OUTPUT_DIR, CACHE_DIR, REPORTS_DIR = BASE_DIR/"output", BASE_DIR/"cache", BASE_DIR/"reports"
+for d in [BASE_DIR, OUTPUT_DIR, CACHE_DIR, REPORTS_DIR]: d.mkdir(parents=True, exist_ok=True)
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("ZenithEngine")
+
+# Tools Availability
+try:
+    from ultralytics import YOLO
+    YOLO_AVAILABLE = True
+except ImportError:
+    YOLO_AVAILABLE = False
+
+try:
+    from faster_whisper import WhisperModel
+    WHISPER_AVAILABLE = True
+except ImportError:
+    WHISPER_AVAILABLE = False
+
+@dataclass
+class Frame:
+    path: Path
+    timestamp: float
+    metrics: Dict[str, float] = None
+    vision_content: str = ""
+
+class DeepSeekClient:
+    def __init__(self):
+        self.api_url = DEEPSEEK_API_URL
+        self.api_key = DEEPSEEK_API_KEY
+        logger.info(f"✅ DeepSeek Client initialisé avec l'URL : {self.api_url}")
+
+    async def stream_content(self, model: str, messages: List[Dict[str, Any]], options: Dict[str, Any]) -> AsyncGenerator[Dict[str, Any], None]:
+        # Convertir les messages au format OpenAI compatible
+        formatted_messages = []
+        for msg in messages:
+            role = msg["role"]
+            content = msg.get("content", "")
+
+            # Si le contenu contient des images, on les convertit en format texte + images
+            if isinstance(content, list):
+                text_parts = []
+                image_parts = []
+                for part in content:
+                    if part["type"] == "text":
+                        text_parts.append(part["text"])
+                    elif part["type"] == "image_url":
+                        url = part["image_url"]["url"]
+                        if url.startswith("data:"):
+                            image_parts.append({"type": "image_url", "image_url": {"url": url}})
+
+                # DeepSeek supporte le format OpenAI vision
+                if image_parts:
+                    formatted_messages.append({
+                        "role": role,
+                        "content": [{"type": "text", "text": " ".join(text_parts)}] + image_parts
+                    })
+                else:
+                    formatted_messages.append({"role": role, "content": " ".join(text_parts)})
+            else:
+                formatted_messages.append({"role": role, "content": content})
+
+        payload = {
+            "model": model,
+            "messages": formatted_messages,
+            "temperature": options.get("temperature", 0.7),
+            "stream": True
+        }
+
+        import httpx
+        async with httpx.AsyncClient(timeout=None) as client:
+            try:
+                async with client.stream(
+                    "POST", self.api_url,
+                    headers={
+                        "Authorization": f"Bearer {self.api_key}",
+                        "Content-Type": "application/json"
+                    },
+                    json=payload
+                ) as response:
+                    if response.status_code != 200:
+                        error_text = await response.aread()
+                        logger.error(f"❌ Erreur DeepSeek API (HTTP {response.status_code}): {error_text.decode()}")
+                        yield {"error": f"Erreur API DeepSeek: {response.status_code}"}
+                        return
+
+                    async for line in response.aiter_lines():
+                        if line.startswith("data: "):
+                            data_str = line[6:]
+                            if data_str.strip() == "[DONE]":
+                                break
+                            try:
+                                data = json.loads(data_str)
+                                # Format OpenAI streaming response
+                                if "choices" in data and len(data["choices"]) > 0:
+                                    delta = data["choices"][0].get("delta", {})
+                                    content = delta.get("content", "")
+                                    if content:
+                                        # Convertir au format attendu par le frontend
+                                        yield {
+                                            "response": {
+                                                "candidates": [{
+                                                    "content": {
+                                                        "parts": [{"text": content}]
+                                                    }
+                                                }]
+                                            }
+                                        }
+                            except json.JSONDecodeError:
+                                continue
+            except Exception as e:
+                logger.error(f"❌ Erreur lors du streaming DeepSeek : {str(e)}")
+                yield {"error": str(e)}
+
+class VideoProcessor:
+    @staticmethod
+    def get_frame_metrics(frame: np.ndarray) -> dict:
+        try:
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+            return {"brightness": float(np.mean(gray)), "contrast": float(np.std(gray)),
+                    "saturation": float(np.mean(hsv[:, :, 1])), "sharpness": float(cv2.Laplacian(gray, cv2.CV_64F).var())}
+        except: return {"brightness": 0, "contrast": 0, "saturation": 0, "sharpness": 0}
+
+    def __init__(self, video_path: Path, output_dir: Path):
+        self.video_path, self.output_dir = video_path, output_dir
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def extract_keyframes(self, max_frames: int = 50) -> List[Frame]:
+        try:
+            from decord import VideoReader, cpu
+            vr = VideoReader(str(self.video_path), ctx=cpu(0))
+            total = len(vr)
+            step = max(1, total // max_frames)
+            indices = range(0, total, step)[:max_frames]
+            frames_data = vr.get_batch(indices).asnumpy()
+            fps = vr.get_avg_fps()
+            extracted = []
+            for i, idx in enumerate(indices):
+                img = cv2.cvtColor(frames_data[i], cv2.COLOR_RGB2BGR)
+                ts = idx / fps
+                p = self.output_dir / f"f_{idx}.jpg"
+                cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 85])
+                extracted.append(Frame(path=p, timestamp=ts, metrics=self.get_frame_metrics(img)))
+            return extracted
+        except Exception as e:
+            logger.warning(f"Decord failed, fallback to CV2: {e}")
+            cap = cv2.VideoCapture(str(self.video_path))
+            fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+            total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 1000
+            step = max(1, total // max_frames)
+            extracted = []
+            for idx in range(0, total, step):
+                if len(extracted) >= max_frames: break
+                cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+                ret, img = cap.read()
+                if ret:
+                    ts = idx / fps
+                    p = self.output_dir / f"f_{idx}.jpg"
+                    cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 85])
+                    extracted.append(Frame(path=p, timestamp=ts, metrics=self.get_frame_metrics(img)))
+            cap.release()
+            return extracted
+
+class AudioProcessor:
+    def __init__(self): self.model = None
+    def initialize(self):
+        if WHISPER_AVAILABLE and self.model is None:
+            try:
+                device = "cuda" if torch.cuda.is_available() else "cpu"
+                self.model = WhisperModel("base", device=device, compute_type="int8")
+            except: pass
+    def transcribe(self, p: Path) -> str:
+        self.initialize()
+        if not self.model: return "Transcription indisponible"
+        try:
+            segments, info = self.model.transcribe(str(p), beam_size=5)
+            transcript = " ".join([s.text for s in segments])
+            return f"[Langue source détectée: {info.language.upper()}] {transcript}"
+        except: return "Erreur transcription"
+
+class VideoDownloader:
+    @staticmethod
+    def download(url: str, output_dir: Path) -> Optional[Path]:
+        import yt_dlp
+        ydl_opts = {
+            'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
+            'outtmpl': str(output_dir / 'downloaded_video.%(ext)s'),
+            'noplaylist': True, 'quiet': True, 'no_warnings': True, 'nocheckcertificate': True,
+            'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'referer': 'https://www.google.com/',
+            'http_headers': {'Accept': '*/*', 'Accept-Language': 'en-US,en;q=0.9'}
+        }
+        try:
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(url, download=True)
+                return Path(ydl.prepare_filename(info))
+        except: return None
+
+class ZenithAnalyzer:
+    def __init__(self):
+        self.deepseek = DeepSeekClient()
+        self.audio_proc = AudioProcessor()
+        self.yolo = YOLO("yolov8n.pt") if YOLO_AVAILABLE else None
+
+    async def extract_frames_only(self, video_path: Path, session_id: str) -> List[str]:
+        session_dir = OUTPUT_DIR / f"session_{session_id}"
+        session_dir.mkdir(parents=True, exist_ok=True)
+        proc = VideoProcessor(video_path, session_dir)
+        frames = proc.extract_keyframes()
+        return [f"/output/session_{session_id}/{f.path.name}" for f in frames[:12]]
+
+    async def run_full_analysis(self, video_path: Path, session_id: str, custom_prompt: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
+        session_dir = OUTPUT_DIR / f"session_{session_id}"
+        session_dir.mkdir(parents=True, exist_ok=True)
+        cache_file = session_dir / "analysis_cache.json"
+
+        # Optimisation : Ne pas ré-extraire si les frames existent déjà
+        existing_frames = list(session_dir.glob("f_*.jpg"))
+        if not existing_frames:
+            yield {"status": "sampling", "message": "Analyse des séquences..."}
+            proc = VideoProcessor(video_path, session_dir)
+            frames = proc.extract_keyframes()
+        else:
+            def get_idx(p):
+                try: return int(p.stem.split('_')[1])
+                except: return 0
+            existing_paths = sorted(existing_frames, key=get_idx)
+            frames = []
+            for p in existing_paths:
+                img = cv2.imread(str(p))
+                metrics = VideoProcessor.get_frame_metrics(img) if img is not None else {"brightness": 0, "contrast": 0, "saturation": 0, "sharpness": 0}
+                frames.append(Frame(path=p, timestamp=0.0, metrics=metrics))
+            yield {"status": "sampling", "message": "Récupération des séquences existantes..."}
+
+        # Envoyer les chemins des images au frontend
+        frame_urls = [f"/output/session_{session_id}/{f.path.name}" for f in frames[:12]]
+        yield {"status": "frames_ready", "frames": frame_urls, "message": "Séquences prêtes."}
+
+        # Vérifier si on a un cache pour l'audio et le visuel
+        cached_data = {}
+        if cache_file.exists():
+            try:
+                with open(cache_file, "r") as f:
+                    cached_data = json.load(f)
+                logger.info(f"✅ Cache trouvé pour la session {session_id}")
+            except: pass
+
+        if "transcript" in cached_data and "vision_info" in cached_data:
+            transcript = cached_data["transcript"]
+            v_info = cached_data["vision_info"]
+            yield {"status": "fusion", "message": "Utilisation des données en cache..."}
+        else:
+            yield {"status": "audio", "message": "Traitement audio & visuel..."}
+            loop = asyncio.get_event_loop()
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                audio_task = loop.run_in_executor(executor, self.audio_proc.transcribe, video_path)
+
+                if self.yolo:
+                    all_paths = [str(f.path) for f in frames]
+                    batch_size = 10
+                    for i in range(0, len(all_paths), batch_size):
+                        batch = all_paths[i:i+batch_size]
+                        results = await loop.run_in_executor(executor, lambda: self.yolo(batch, verbose=False, imgsz=320, stream=False))
+                        for j, res in enumerate(results):
+                            idx = i + j
+                            objs = [res.names[int(b.cls[0])] for b in res.boxes if b.conf > 0.25]
+                            ambiance = f"Ambiance: {'Sombre' if frames[idx].metrics['brightness'] < 50 else 'Lumineuse'}"
+                            frames[idx].vision_content = f"{ambiance}, Objets: " + ", ".join([f"{v}x {k}" for k,v in Counter(objs).items()])
+
+                transcript = await audio_task
+
+            v_info = "\n".join([f"[{f.timestamp:.1f}s] {f.vision_content}" for f in frames[:40]])
+
+            # Sauvegarder dans le cache
+            try:
+                with open(cache_file, "w") as f:
+                    json.dump({"transcript": transcript, "vision_info": v_info}, f)
+            except: pass
+
+        yield {"status": "fusion", "message": "Intelligence Artificielle en action..."}
+
+        # Utilisation du prompt personnalisé si fourni
+        base_instruction = custom_prompt if custom_prompt else "Résumer et continuer l'analyse du média"
+
+        prompt = f"""Tu es l'unité Zenith AI, un système d'analyse de données multimédias.
+        INSTRUCTION UTILISATEUR : {base_instruction}
+
+        DONNÉES D'ENTRÉE :
+        - TRANSCRIPTION : {transcript}
+        - DONNÉES VISUELLES : {v_info}
+
+        Produis un rapport TECHNIQUE, FACTUEL et STRUCTURÉ en Markdown."""
+
+        # Encodage parallèle des images
+        selected_frames = [frames[i] for i in range(0, len(frames), max(1, len(frames)//10))][:10]
+        def encode_f(f):
+            img = cv2.imread(str(f.path))
+            _, buf = cv2.imencode('.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 70])
+            return {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64.b64encode(buf).decode()}"}}
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            images = list(executor.map(encode_f, selected_frames))
+
+        messages = [{"role": "user", "content": [{"type": "text", "text": prompt}] + images}]
+
+        yield {"status": "generating", "message": "Génération du rapport par l'IA..."}
+        async for chunk in self.deepseek.stream_content(DEEPSEEK_MODEL, messages, {"temperature": 0.7}):
+            if "error" in chunk:
+                yield {"error": chunk["error"]}
+                break
+            resp = chunk.get("response", {})
+            candidates = resp.get("candidates", [])
+            if candidates:
+                for part in candidates[0].get("content", {}).get("parts", []):
+                    text = part.get("text", "")
+                    if text: yield {"status": "streaming", "text": text}
+
+        # Cleanup
+        gc.collect()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+        yield {"status": "completed", "message": "Analyse terminée."}

backend/main.py

@@ -1,122 +1,121 @@
-import os, uuid, json, asyncio, time
-from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, HTTPException
-from fastapi.responses import StreamingResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from pathlib import Path
-from backend.core.engine import ZenithAnalyzer, VideoDownloader, OUTPUT_DIR
-
-app = FastAPI(title="Zenith AI API")
-
-# Configuration CORS étendue pour permettre au frontend hébergé ailleurs de communiquer avec l'API
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], # Vous pourrez remplacer "*" par l'URL de votre site Vercel plus tard pour plus de sécurité
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-analyzer = ZenithAnalyzer()
-
-def cleanup_old_sessions(max_age_hours=1):
-    """Supprime les dossiers de session plus vieux que max_age_hours."""
-    try:
-        import shutil
-        now = time.time()
-        for path in OUTPUT_DIR.glob("session_*"):
-            if path.is_dir():
-                # Vérifier l'âge du dossier
-                if (now - path.stat().st_mtime) > (max_age_hours * 3600):
-                    shutil.rmtree(path)
-    except Exception as e:
-        print(f"Erreur lors du nettoyage : {e}")
-
-@app.post("/analyze/url")
-async def analyze_url(url: str = Form(...), background_tasks: BackgroundTasks = BackgroundTasks()):
-    background_tasks.add_task(cleanup_old_sessions)
-    session_id = str(uuid.uuid4())
-    session_dir = OUTPUT_DIR / f"session_{session_id}"
-    session_dir.mkdir(parents=True, exist_ok=True)
-
-    video_path = VideoDownloader.download(url, session_dir)
-    if not video_path:
-        raise HTTPException(status_code=400, detail="Échec du téléchargement de la vidéo")
-
-    # Retourner l'URL relative pour le frontend
-    video_url = f"/output/session_{session_id}/{video_path.name}"
-    return {"session_id": session_id, "video_path": str(video_path), "video_url": video_url}
-
-@app.post("/analyze/upload")
-async def analyze_upload(file: UploadFile = File(...), background_tasks: BackgroundTasks = BackgroundTasks()):
-    background_tasks.add_task(cleanup_old_sessions)
-    session_id = str(uuid.uuid4())
-    session_dir = OUTPUT_DIR / f"session_{session_id}"
-    session_dir.mkdir(parents=True, exist_ok=True)
-
-    file_path = session_dir / file.filename
-    with open(file_path, "wb") as buffer:
-        buffer.write(await file.read())
-
-    # Retourner l'URL relative pour le frontend
-    video_url = f"/output/session_{session_id}/{file.filename}"
-    return {"session_id": session_id, "video_path": str(file_path), "video_url": video_url}
-
-@app.post("/analyze/extract-frames")
-async def extract_frames(session_id: str = Form(...), video_path: str = Form(...)):
-    # Sécurité : Vérifier que le chemin du fichier est bien dans le dossier autorisé
-    abs_video_path = Path(video_path).resolve()
-    abs_output_dir = OUTPUT_DIR.resolve()
-
-    if not str(abs_video_path).startswith(str(abs_output_dir)):
-        raise HTTPException(status_code=403, detail="Accès au fichier non autorisé")
-
-    try:
-        frames = await analyzer.extract_frames_only(abs_video_path, session_id)
-        return {"status": "success", "frames": frames}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/stream/{session_id}")
-async def stream_analysis(session_id: str, video_path: str, prompt: str = None):
-    # Sécurité : Vérifier que le chemin du fichier est bien dans le dossier autorisé
-    abs_video_path = Path(video_path).resolve()
-    abs_output_dir = OUTPUT_DIR.resolve()
-
-    if not str(abs_video_path).startswith(str(abs_output_dir)):
-        raise HTTPException(status_code=403, detail="Accès au fichier non autorisé")
-
-    async def event_generator():
-        try:
-            async for update in analyzer.run_full_analysis(abs_video_path, session_id, custom_prompt=prompt):
-                yield f"data: {json.dumps(update)}\n\n"
-        except Exception as e:
-            yield f"data: {json.dumps({'error': str(e)})}\n\n"
-
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
-
-# Servir le dossier de sortie pour les images extraites
-app.mount("/output", StaticFiles(directory=str(OUTPUT_DIR)), name="output")
-
-# Servir le frontend statique uniquement s'il existe
-frontend_path = Path("frontend")
-if frontend_path.exists():
-    app.mount("/", StaticFiles(directory="frontend", html=True), name="frontend")
-else:
-    @app.get("/")
-    async def root():
-        import os
-        gcp_configured = "OUI" if os.getenv("GCP_SERVICE_ACCOUNT") else "NON"
-        return {
-            "status": "Zenith AI API is running",
-            "frontend": "hosted externally",
-            "diagnostics": {
-                "gcp_service_account": gcp_configured,
-                "yolo_available": "YES" if analyzer.yolo else "NO",
-                "whisper_available": "YES" if analyzer.audio_proc else "NO"
-            }
-        }
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+import os, uuid, json, asyncio, time
+from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pathlib import Path
+from backend.core.engine import ZenithAnalyzer, VideoDownloader, OUTPUT_DIR
+
+app = FastAPI(title="Zenith AI API")
+
+# Configuration CORS étendue pour permettre au frontend hébergé ailleurs de communiquer avec l'API
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # Vous pourrez remplacer "*" par l'URL de votre site Vercel plus tard pour plus de sécurité
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+analyzer = ZenithAnalyzer()
+
+def cleanup_old_sessions(max_age_hours=1):
+    """Supprime les dossiers de session plus vieux que max_age_hours."""
+    try:
+        import shutil
+        now = time.time()
+        for path in OUTPUT_DIR.glob("session_*"):
+            if path.is_dir():
+                # Vérifier l'âge du dossier
+                if (now - path.stat().st_mtime) > (max_age_hours * 3600):
+                    shutil.rmtree(path)
+    except Exception as e:
+        print(f"Erreur lors du nettoyage : {e}")
+
+@app.post("/analyze/url")
+async def analyze_url(url: str = Form(...), background_tasks: BackgroundTasks = BackgroundTasks()):
+    background_tasks.add_task(cleanup_old_sessions)
+    session_id = str(uuid.uuid4())
+    session_dir = OUTPUT_DIR / f"session_{session_id}"
+    session_dir.mkdir(parents=True, exist_ok=True)
+
+    video_path = VideoDownloader.download(url, session_dir)
+    if not video_path:
+        raise HTTPException(status_code=400, detail="Échec du téléchargement de la vidéo")
+
+    # Retourner l'URL relative pour le frontend
+    video_url = f"/output/session_{session_id}/{video_path.name}"
+    return {"session_id": session_id, "video_path": str(video_path), "video_url": video_url}
+
+@app.post("/analyze/upload")
+async def analyze_upload(file: UploadFile = File(...), background_tasks: BackgroundTasks = BackgroundTasks()):
+    background_tasks.add_task(cleanup_old_sessions)
+    session_id = str(uuid.uuid4())
+    session_dir = OUTPUT_DIR / f"session_{session_id}"
+    session_dir.mkdir(parents=True, exist_ok=True)
+
+    file_path = session_dir / file.filename
+    with open(file_path, "wb") as buffer:
+        buffer.write(await file.read())
+
+    # Retourner l'URL relative pour le frontend
+    video_url = f"/output/session_{session_id}/{file.filename}"
+    return {"session_id": session_id, "video_path": str(file_path), "video_url": video_url}
+
+@app.post("/analyze/extract-frames")
+async def extract_frames(session_id: str = Form(...), video_path: str = Form(...)):
+    # Sécurité : Vérifier que le chemin du fichier est bien dans le dossier autorisé
+    abs_video_path = Path(video_path).resolve()
+    abs_output_dir = OUTPUT_DIR.resolve()
+
+    if not str(abs_video_path).startswith(str(abs_output_dir)):
+        raise HTTPException(status_code=403, detail="Accès au fichier non autorisé")
+
+    try:
+        frames = await analyzer.extract_frames_only(abs_video_path, session_id)
+        return {"status": "success", "frames": frames}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/stream/{session_id}")
+async def stream_analysis(session_id: str, video_path: str, prompt: str = None):
+    # Sécurité : Vérifier que le chemin du fichier est bien dans le dossier autorisé
+    abs_video_path = Path(video_path).resolve()
+    abs_output_dir = OUTPUT_DIR.resolve()
+
+    if not str(abs_video_path).startswith(str(abs_output_dir)):
+        raise HTTPException(status_code=403, detail="Accès au fichier non autorisé")
+
+    async def event_generator():
+        try:
+            async for update in analyzer.run_full_analysis(abs_video_path, session_id, custom_prompt=prompt):
+                yield f"data: {json.dumps(update)}\n\n"
+        except Exception as e:
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+# Servir le dossier de sortie pour les images extraites
+app.mount("/output", StaticFiles(directory=str(OUTPUT_DIR)), name="output")
+
+# Servir le frontend statique uniquement s'il existe
+frontend_path = Path("frontend")
+if frontend_path.exists():
+    app.mount("/", StaticFiles(directory="frontend", html=True), name="frontend")
+else:
+    @app.get("/")
+    async def root():
+        import os
+        return {
+            "status": "Zenith AI API is running",
+            "frontend": "hosted externally",
+            "diagnostics": {
+                "deepseek_configured": "YES",
+                "yolo_available": "YES" if analyzer.yolo else "NO",
+                "whisper_available": "YES" if analyzer.audio_proc else "NO"
+            }
+        }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -1,15 +1,15 @@
-gradio
-requests
-numpy
-opencv-python
-ultralytics
-faster-whisper
-decord
-yt-dlp
-fastapi
-uvicorn
-httpx
-python-dotenv
-python-multipart
-python-magic; platform_system != 'Windows'
-python-magic-bin; platform_system == 'Windows'
+gradio
+requests
+numpy
+opencv-python
+ultralytics
+faster-whisper
+decord
+yt-dlp
+fastapi
+uvicorn
+httpx
+python-dotenv
+python-multipart
+python-magic; platform_system != 'Windows'
+python-magic-bin; platform_system == 'Windows'

run.py

@@ -1,16 +1,16 @@
-import uvicorn
-import os
-from dotenv import load_dotenv
-
-if __name__ == "__main__":
-    load_dotenv()
-
-    # Vérification des variables d'environnement critiques
-    if not os.getenv("GCP_SERVICE_ACCOUNT"):
-        print("⚠️ Attention : GCP_SERVICE_ACCOUNT n'est pas configuré dans le fichier .env")
-
-    print("🚀 Démarrage de Zenith AI SaaS...")
-    print("🌍 Interface disponible sur : http://localhost:8000")
-
-    # Lancement du serveur FastAPI
-    uvicorn.run("backend.main:app", host="0.0.0.0", port=8000, reload=True)
+import uvicorn
+import os
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+
+    # Vérification des variables d'environnement critiques
+    if not os.getenv("GCP_SERVICE_ACCOUNT"):
+        print("⚠️ Attention : GCP_SERVICE_ACCOUNT n'est pas configuré dans le fichier .env")
+
+    print("🚀 Démarrage de Zenith AI SaaS...")
+    print("🌍 Interface disponible sur : http://localhost:8000")
+
+    # Lancement du serveur FastAPI
+    uvicorn.run("backend.main:app", host="0.0.0.0", port=8000, reload=True)

test_deepseek.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Script de test pour vérifier la connexion à l'API DeepSeek
+"""
+import asyncio
+import sys
+from backend.core.engine import DeepSeekClient, DEEPSEEK_MODEL
+
+async def test_deepseek():
+    print("🔍 Test de connexion à DeepSeek API...")
+    print(f"📡 URL: https://shads229-personnal-ai.hf.space/v1/chat/completions")
+    print(f"🤖 Modèle: {DEEPSEEK_MODEL}\n")
+
+    client = DeepSeekClient()
+
+    # Message de test simple
+    messages = [
+        {
+            "role": "user",
+            "content": "Réponds simplement 'OK' si tu me reçois."
+        }
+    ]
+
+    print("📤 Envoi du message de test...")
+
+    try:
+        response_received = False
+        async for chunk in client.stream_content(DEEPSEEK_MODEL, messages, {"temperature": 0.7}):
+            if "error" in chunk:
+                print(f"❌ Erreur: {chunk['error']}")
+                return False
+
+            if "response" in chunk:
+                candidates = chunk.get("response", {}).get("candidates", [])
+                if candidates:
+                    for part in candidates[0].get("content", {}).get("parts", []):
+                        text = part.get("text", "")
+                        if text:
+                            print(f"✅ Réponse reçue: {text}")
+                            response_received = True
+
+        if response_received:
+            print("\n✅ Test réussi ! L'API DeepSeek fonctionne correctement.")
+            return True
+        else:
+            print("\n⚠️ Aucune réponse reçue de l'API.")
+            return False
+
+    except Exception as e:
+        print(f"\n❌ Erreur lors du test: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    result = asyncio.run(test_deepseek())
+    sys.exit(0 if result else 1)