Update app.py

app.py

@@ -1,345 +1,469 @@
 # -*- coding: utf-8 -*-
 """
-analyze_media.py — Pont Python AI pour MAM SHIELD v5.2
-ACoNum / Trusted Sound 2026
+Antigravity Shield v5.0 — ACoNum / Trusted Sound 2026
 =====================================================
-Usage (appelé par server.js) :
-  python analyze_media.py audio   <chemin_fichier>
-  python analyze_media.py video   <chemin_fichier>
-  python analyze_media.py image   <chemin_fichier>
-  python analyze_media.py pdf     <chemin_fichier>
-
-Retourne un JSON sur stdout :
-  { "summary": "...", "tags": [...], "transcript": "...", "flac_ok": true, "flac_path": "..." }
+Fusion : AASIST neural anti-spoofing + Jitter/Flatness + AcoustID
+Résout :
+  - Faux positifs sur anciennes chansons (vintage)
+  - Voix off / parlées non chantées
+  - AI Cover complexes (ElevenLabs, YourTTS, RVC)
+  - Broadcast FM (jitter élevé naturel)
 """
 
-import sys
+import numpy as np
+import librosa
+import librosa.display
+import matplotlib.pyplot as plt
+import noisereduce as nr
+import hashlib
 import os
 import json
 import subprocess
-import traceback
-
-# ── Config Ollama ────────────────────────────────────────────
-OLLAMA_HOST  = 'http://localhost:11434'
-OLLAMA_MODEL = 'qwen2.5:3b'   # tags + résumé standard
-
-# ── Nemotron — auto-détection au démarrage ───────────────
-# Modèle téléchargé : nvidia/Nemotron-3-Nano-Omni-30B → version 4B locale
-# Nom Ollama attendu : nemotron-mini ou nemotron-mini:4b
-NEMOTRON_MODEL = None
-NEMOTRON_PRIORITY = [          # ordre de priorité exact
-    'nemotron-mini:4b',
-    'nemotron-mini:latest',
-    'nemotron-mini',
-    'nemotron:4b',
-    'nemotron:mini',
-    'nemotron:latest',
-    'nvidia/nemotron-mini',
-    'nemotron-nano',
-    'nemotron',
-]
-
-def detect_nemotron():
-    """Cherche automatiquement un modèle Nemotron dans Ollama (priorité 4B mini)."""
-    global NEMOTRON_MODEL
-    try:
-        import urllib.request as ur
-        req = ur.Request(OLLAMA_HOST + '/api/tags', method='GET')
-        with ur.urlopen(req, timeout=5) as r:
-            data   = json.loads(r.read().decode('utf-8'))
-            models = [m.get('name','') for m in data.get('models', [])]
-            # Cherche par priorité exacte d'abord
-            for prio in NEMOTRON_PRIORITY:
-                if prio in models:
-                    NEMOTRON_MODEL = prio
-                    return prio
-            # Sinon: correspondance partielle
-            for m in models:
-                if 'nemotron' in m.lower():
-                    NEMOTRON_MODEL = m
-                    return m
-    except Exception:
-        pass
-    NEMOTRON_MODEL = OLLAMA_MODEL   # fallback qwen si absent
-    return NEMOTRON_MODEL
-
-detect_nemotron()
-
-# ── Config FFmpeg ────────────────────────────────────────────
-def find_ffmpeg():
-    candidates = [
-        os.path.join(os.path.expanduser('~'), 'ffmpeg', 'bin', 'ffmpeg.exe'),
-        os.path.join(os.path.expanduser('~'), 'AppData', 'Local', 'Programs', 'ffmpeg', 'bin', 'ffmpeg.exe'),
-        'ffmpeg',
-    ]
-    for c in candidates:
-        if c == 'ffmpeg':
-            return c
-        if os.path.exists(c):
-            return c
-    return 'ffmpeg'
-
-FFMPEG = find_ffmpeg()
-
-# ── Résultat ─────────────────────────────────────────────────
-def ok(**kwargs):
-    print(json.dumps({ 'ok': True, **kwargs }, ensure_ascii=False))
-    sys.exit(0)
-
-def fail(msg):
-    print(json.dumps({ 'ok': False, 'error': str(msg) }, ensure_ascii=False))
-    sys.exit(1)
-
-
-# ════════════════════════════════════════════════════════════
-#  OLLAMA — appel local
-# ════════════════════════════════════════════════════════════
-def ollama_generate(prompt, model=OLLAMA_MODEL):
-    try:
-        import urllib.request
-        body = json.dumps({
-            'model':   model,
-            'prompt':  prompt,
-            'stream':  False,
-            'options': { 'temperature': 0, 'num_predict': 300 }
-        }).encode('utf-8')
-        req = urllib.request.Request(
-            OLLAMA_HOST + '/api/generate',
-            data=body,
-            headers={ 'Content-Type': 'application/json' },
-            method='POST'
-        )
-        with urllib.request.urlopen(req, timeout=30) as resp:
-            data = json.loads(resp.read().decode('utf-8'))
-            return data.get('response', '').strip()
-    except Exception as e:
-        return None
-
-
-def generate_tags(name, media_type, content=''):
-    raw = ollama_generate(
-        f"Tu es un archiviste média. Génère exactement 5 tags pertinents pour cet asset.\n"
-        f"Nom: {name}\nType: {media_type}\nContenu: {content[:300] if content else 'non disponible'}\n"
-        f"Réponds UNIQUEMENT avec un tableau JSON de 5 strings en français. "
-        f"Ex: [\"tag1\",\"tag2\",\"tag3\",\"tag4\",\"tag5\"]"
+import gradio as gr
+
+# ══════════════════════════════════════════════════════════════
+#  CONFIG
+# ══════════════════════════════════════════════════════════════
+
+# AcoustID — clé API (remplacer par la tienne)
+ACOUSTID_KEY = "TY6HUQsigs"
+
+# AASIST — modèle HuggingFace anti-spoofing
+AASIST_MODEL_ID = "Mahmoud-Yassen/aasist-antispoof"  # fallback si absent: "m-aliabbas/AASIST"
+
+# Double Jitter — seuils v4.4.5 calibrés broadcast FM
+JITTER_BROADCAST_MIN = 0.85
+FLATNESS_THRESHOLD   = 0.0012
+FLATNESS_BROADCAST   = 0.0010
+CENTROID_BROADCAST   = 3500.0
+CENTROID_VINTAGE     = 3000.0
+ZCR_VINTAGE          = 0.06
+
+
+# ══════════════════════════════════════════════════════════════
+class AntigravityShield:
+    def __init__(self):
+        print("🚀 Antigravity Shield v5.0 — AASIST + Jitter + AcoustID")
+        self.ast_model  = None   # MIT/ast — classification audio générale
+        self.aasist     = None   # AASIST — anti-spoofing neural
+        self.aasist_ok  = False
+
+    # ──────────────────────────────────────────────────────────
+    # MODÈLES
+    # ──────────────────────────────────────────────────────────
+    def load_ast(self):
+        if self.ast_model is None:
+            try:
+                from transformers import pipeline
+                self.ast_model = pipeline(
+                    "audio-classification",
+                    model="MIT/ast-finetuned-audioset-10-10-0.4593"
+                )
+                print("✅ AST chargé")
+            except Exception as e:
+                print(f"⚠️ AST non disponible : {e}")
+                self.ast_model = None
+
+    def load_aasist(self):
+        """
+        Charge AASIST pour la détection anti-spoofing de bas niveau.
+        AASIST opère sur la forme d'onde brute → détecte les artefacts
+        que le jitter seul ne voit pas (TTS modernes, RVC, ElevenLabs).
+        """
+        if self.aasist is None:
+            try:
+                from transformers import pipeline, AutoFeatureExtractor, AutoModelForAudioClassification
+                import torch
+                # Essayer plusieurs modèles anti-spoofing disponibles
+                candidates = [
+                    "Mahmoud-Yassen/aasist-antispoof",
+                    "m-aliabbas/AASIST",
+                    "fusing/aasist",
+                ]
+                for model_id in candidates:
+                    try:
+                        self.aasist = pipeline(
+                            "audio-classification",
+                            model=model_id,
+                            sampling_rate=16000
+                        )
+                        self.aasist_ok = True
+                        print(f"✅ AASIST chargé : {model_id}")
+                        break
+                    except Exception:
+                        continue
+                if not self.aasist_ok:
+                    print("⚠️ AASIST non disponible — mode fallback jitter seul")
+            except Exception as e:
+                print(f"⚠️ AASIST erreur : {e}")
+
+    # ──────────────────────────────────────────────────────────
+    # SHA256
+    # ──────────────────────────────────────────────────────────
+    def get_sha256(self, path):
+        with open(path, "rb") as f:
+            return hashlib.sha256(f.read()).hexdigest()
+
+    # ──────────────────────────────────────────────────────────
+    # ACOUSTID — identification musicale
+    # ──────────────────────────────────────────────────────────
+    def acoustid_lookup(self, path):
+        """
+        Identifie le fichier via AcoustID/MusicBrainz.
+        Si la chanson est CONNUE → c'est une vraie chanson (bonus authenticité).
+        Si la chanson n'est PAS dans la base → potentiellement AI Cover.
+        """
+        try:
+            import acoustid
+            results = acoustid.match(ACOUSTID_KEY, path)
+            for score, recording_id, title, artist in results:
+                if score > 0.8:
+                    return True, f"{artist} — {title} (score {score:.0%})", recording_id
+            return False, "Non identifié dans MusicBrainz", None
+        except ImportError:
+            # Fallback: fpcalc si acoustid module absent
+            try:
+                fpcalc = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'fpcalc.exe')
+                if not os.path.exists(fpcalc):
+                    fpcalc = 'fpcalc'
+                result = subprocess.run(
+                    [fpcalc, '-json', path],
+                    capture_output=True, timeout=15
+                )
+                if result.returncode == 0:
+                    data = json.loads(result.stdout.decode('utf-8'))
+                    fingerprint = data.get('fingerprint', '')
+                    return bool(fingerprint), f"Empreinte : {fingerprint[:24]}...", None
+            except Exception:
+                pass
+            return None, "AcoustID non disponible", None
+        except Exception as e:
+            return None, f"AcoustID erreur : {str(e)[:60]}", None
+
+    # ──────────────────────────────────────────────────────────
+    # SPECTROGRAMME
+    # ──────────────────────────────────────────────────────────
+    def generer_spectrogramme(self, y, sr, jitter_a, jitter_b, aasist_score):
+        fig, axes = plt.subplots(1, 2, figsize=(14, 4))
+
+        # Mel spectrogram
+        S    = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
+        S_dB = librosa.power_to_db(S, ref=np.max)
+        librosa.display.specshow(S_dB, sr=sr, x_axis='time', y_axis='mel',
+                                  cmap='magma', ax=axes[0])
+        axes[0].set_title('Mel Spectrogram — Texture vocale')
+
+        # Double Jitter timeline
+        frame_len = 2048
+        hop       = 512
+        pitches, mags = librosa.piptrack(y=y, sr=sr, hop_length=hop, fmin=60, fmax=4000)
+        frames    = np.arange(pitches.shape[1])
+        times     = librosa.frames_to_time(frames, sr=sr, hop_length=hop)
+
+        # Jitter par frame
+        jitter_timeline = []
+        for i in range(pitches.shape[1]):
+            col = pitches[:, i]
+            col_mags = mags[:, i]
+            m = col_mags > np.median(col_mags)
+            jitter_timeline.append(np.std(col[m]) / 1000 if np.any(m) else 0)
+
+        axes[1].plot(times[:len(jitter_timeline)], jitter_timeline,
+                     color='cyan', linewidth=0.8, alpha=0.8, label='Jitter frame')
+        axes[1].axhline(y=jitter_a, color='lime',   linestyle='--', linewidth=1.5,
+                        label=f'Jitter-A global={jitter_a:.3f}')
+        axes[1].axhline(y=jitter_b, color='yellow', linestyle='--', linewidth=1.5,
+                        label=f'Jitter-B débruité={jitter_b:.3f}')
+        if aasist_score is not None:
+            axes[1].axhline(y=aasist_score, color='red', linestyle=':', linewidth=2,
+                            label=f'AASIST spoof={aasist_score:.2f}')
+        axes[1].set_xlabel('Temps (s)')
+        axes[1].set_ylabel('Jitter')
+        axes[1].set_title('Double Jitter + AASIST Timeline')
+        axes[1].legend(fontsize=7)
+        axes[1].set_ylim(0, max(2.0, max(jitter_timeline) * 1.2) if jitter_timeline else 2.0)
+
+        plt.tight_layout()
+        plot_path = "spectrum_v5.png"
+        plt.savefig(plot_path, dpi=120)
+        plt.close()
+        return plot_path
+
+    # ──────────────────────────────────────────────────────────
+    # ANALYSE AASIST — neural anti-spoofing
+    # ──────────────────────────────────────────────────────────
+    def run_aasist(self, path):
+        """
+        Retourne (spoof_score 0-1, label_string)
+        spoof_score > 0.5 = suspect de spoofing
+        """
+        if not self.aasist_ok or self.aasist is None:
+            return None, "AASIST non chargé"
+        try:
+            results = self.aasist(path)
+            # Cherche le label "spoof" ou "fake"
+            for r in results:
+                lbl = r['label'].lower()
+                if any(k in lbl for k in ['spoof', 'fake', 'synthetic', 'generated']):
+                    return float(r['score']), f"AASIST spoof={r['score']:.1%}"
+            # Si labels sont 0/1 ou bonafide/spoof
+            for r in results:
+                lbl = r['label'].lower()
+                if any(k in lbl for k in ['1', 'spoof']):
+                    return float(r['score']), f"AASIST score={r['score']:.1%}"
+            # Retour du premier label
+            return 1 - float(results[0]['score']), f"AASIST={results[0]['label']}:{results[0]['score']:.1%}"
+        except Exception as e:
+            return None, f"AASIST erreur : {str(e)[:60]}"
+
+    # ──────────────────────────────────────────────────────────
+    # ANALYSE PRINCIPALE
+    # ──────────────────────────────────────────────────────────
+    def analyser_expert(self, path):
+        if path is None:
+            return None, "En attente...", None
+        try:
+            self.load_ast()
+            self.load_aasist()
+
+            y, sr = librosa.load(path, sr=44100)
+
+            # ── DÉBRUITAGE ADAPTATIF ──────────────────────────
+            y_light = nr.reduce_noise(y=y, sr=sr, prop_decrease=0.3)
+            centroid_light = float(np.mean(librosa.feature.spectral_centroid(y=y_light, sr=sr)))
+
+            if centroid_light < CENTROID_BROADCAST:
+                prop = 0.4
+                raison_denoise = "Débruitage doux (broadcast détecté)"
+            else:
+                prop = 0.7
+                raison_denoise = "Débruitage standard"
+
+            y_denoised = nr.reduce_noise(y=y, sr=sr, prop_decrease=prop)
+
+            # ── DOUBLE JITTER (A brut / B débruité) ──────────
+            def compute_jitter(signal):
+                pitches, mags = librosa.piptrack(y=signal, sr=sr, fmin=60, fmax=4000)
+                mask = mags > np.median(mags)
+                return float(np.std(pitches[mask]) / 1000) if np.any(mask) else 0.0
+
+            jitter_a = compute_jitter(y)           # Jitter brut
+            jitter_b = compute_jitter(y_denoised)  # Jitter débruité
+            jitter_delta = abs(jitter_a - jitter_b)
+
+            flatness = float(np.mean(librosa.feature.spectral_flatness(y=y_denoised)))
+            centroid  = float(np.mean(librosa.feature.spectral_centroid(y=y_denoised, sr=sr)))
+            zcr       = float(np.mean(librosa.feature.zero_crossing_rate(y_denoised)))
+
+            # ── VINTAGE ───────────────────────────────────────
+            is_vintage = centroid < CENTROID_VINTAGE and zcr < ZCR_VINTAGE
+
+            # ── AST CLASSIFICATION ────────────────────────────
+            top_label, score_ia = "Inconnu", 0.0
+            if self.ast_model:
+                try:
+                    res_ia = self.ast_model(path)
+                    top_label  = res_ia[0]['label']
+                    score_ia   = res_ia[0]['score'] * 100
+                except Exception:
+                    pass
+
+            # ── AASIST — neural anti-spoofing ─────────────────
+            aasist_score, aasist_label = self.run_aasist(path)
+
+            # ── ACOUSTID ──────────────────────────────────────
+            acoustid_known, acoustid_info, _ = self.acoustid_lookup(path)
+
+            # ══════════════════════════════════════════════════
+            # SCORING FUSIONNÉ v5.0
+            # Pondération : AASIST(40%) + Jitter(35%) + Flatness(15%) + Context(10%)
+            # ══════════════════════════════════════════════════
+            confiance = 50
+            raisons   = []
+
+            # ── 1. AASIST NEURAL (priorité maximale) ──────────
+            if aasist_score is not None:
+                if aasist_score > 0.80:
+                    # AASIST très sûr → deepfake
+                    confiance -= 40
+                    raisons.append(f"🤖 AASIST détecte synthèse ({aasist_score:.0%}) — deepfake probable")
+                elif aasist_score > 0.55:
+                    confiance -= 20
+                    raisons.append(f"⚠️ AASIST : signal suspect ({aasist_score:.0%})")
+                elif aasist_score < 0.30:
+                    confiance += 20
+                    raisons.append(f"✅ AASIST : signal authentique ({1-aasist_score:.0%} bona-fide)")
+                else:
+                    raisons.append(f"📊 AASIST ambigu ({aasist_score:.0%})")
+            else:
+                raisons.append("⚙️ AASIST indisponible — mode jitter seul")
+
+            # ── 2. VINTAGE (override partiel si vintage) ──────
+            if is_vintage:
+                confiance += 12
+                raisons.append("����️ Signature vintage (enregistrement ancien)")
+                # Les AI Covers anciens ont rarement un centroïde aussi bas
+                if aasist_score and aasist_score > 0.80:
+                    raisons.append("⚠️ Vintage MAIS AASIST détecte synthèse — AI Cover vintage possible")
+
+            # ── 3. FLATNESS ────────────────────────────────────
+            if flatness > FLATNESS_THRESHOLD:
+                confiance += 15
+                raisons.append(f"🌿 Texture organique (flatness={flatness:.5f})")
+            else:
+                confiance -= 20
+                raisons.append(f"🔇 Signal trop pur (flatness={flatness:.5f} < {FLATNESS_THRESHOLD})")
+                if score_ia < 70:
+                    confiance -= 15
+                    raisons.append("🚫 Signal pur + source IA incertaine → deepfake renforcé")
+
+            # ── 4. DOUBLE JITTER ───────────────────────────────
+            is_broadcast = (jitter_a >= JITTER_BROADCAST_MIN and centroid_light < CENTROID_BROADCAST) or prop == 0.4
+
+            # 4a. Voix/parole
+            if "Music" not in top_label and "Singing" not in top_label:
+                if 0.10 < jitter_b < 0.80:
+                    confiance += 20
+                    raisons.append(f"🗣️ Vibration vocale naturelle (jitter-B={jitter_b:.3f})")
+                elif jitter_b >= JITTER_BROADCAST_MIN:
+                    if is_broadcast and flatness > FLATNESS_BROADCAST:
+                        confiance += 18
+                        raisons.append(f"📻 Jitter broadcast FM validé (jitter-B={jitter_b:.3f})")
+                    elif is_broadcast and flatness <= FLATNESS_BROADCAST:
+                        confiance -= 25
+                        raisons.append(f"❌ Trop pur pour broadcast (jitter-B={jitter_b:.3f})")
+                    elif flatness > 0.0008:
+                        confiance += 12
+                        raisons.append(f"📡 Flux radio détecté (jitter-B={jitter_b:.3f})")
+                    else:
+                        confiance -= 50
+                        raisons.append(f"🚨 Instabilité artificielle voix off (jitter-B={jitter_b:.3f})")
+                # Jitter delta trop grand = débruitage anormal = synthétique
+                if jitter_delta > 0.5:
+                    confiance -= 15
+                    raisons.append(f"⚡ Delta jitter A-B anormal (Δ={jitter_delta:.3f}) — artefact synthèse")
+
+            # 4b. Musique / Chant
+            else:
+                if jitter_b > 1.0 or jitter_b < 0.09:
+                    if is_vintage:
+                        confiance += 8
+                        raisons.append(f"🎵 Jitter vintage validé (jitter-B={jitter_b:.3f})")
+                    elif flatness < FLATNESS_THRESHOLD:
+                        confiance -= 50
+                        raisons.append(f"🎤 AI Cover — jitter anormal + signal pur (jitter-B={jitter_b:.3f})")
+                    else:
+                        confiance -= 15
+                        raisons.append(f"🔎 Jitter musical suspect — analyse inconclusif (jitter-B={jitter_b:.3f})")
+                else:
+                    confiance += 18
+                    raisons.append(f"🎶 Harmoniques naturelles validées (jitter-B={jitter_b:.3f})")
+
+            # ── 5. ACOUSTID ────────────────────────────────────
+            if acoustid_known is True:
+                confiance += 15
+                raisons.append(f"🎵 Chanson connue MusicBrainz : {acoustid_info}")
+                # Chanson connue MAIS AASIST détecte synthèse = AI Cover de chanson réelle
+                if aasist_score and aasist_score > 0.65:
+                    confiance -= 20
+                    raisons.append("🚨 Chanson connue + AASIST suspect = AI Cover d'original")
+            elif acoustid_known is False:
+                raisons.append(f"❓ Non identifié MusicBrainz — {acoustid_info}")
+            else:
+                raisons.append(f"⚙️ {acoustid_info}")
+
+            confiance = max(0, min(100, confiance))
+
+            # ── VERDICT ────────────────────────────────────────
+            if confiance >= 70:
+                verdict = "🔒 AUTHENTIQUE CERTIFIÉ"
+                color   = "green"
+            elif 40 <= confiance < 70:
+                verdict = "⚠️ ANALYSE INCONCLUSIVE"
+                color   = "orange"
+            else:
+                verdict = "🛑 AI COVER / DEEPFAKE DÉTECTÉ"
+                color   = "red"
+
+            sha = self.get_sha256(path)
+
+            report  = f"\n{'='*50}\n📌 RAPPORT Antigravity Shield v5.0\n{'='*50}\n"
+            report += f" 🤖 AST SOURCE  : {top_label} ({score_ia:.1f}%)\n"
+            report += f" 🧠 AASIST      : {aasist_label}\n"
+            report += f" 🎯 CONFIANCE   : {confiance}%\n"
+            report += f" 🎛️ JITTER-A    : {jitter_a:.4f} (brut)\n"
+            report += f" 🎛️ JITTER-B    : {jitter_b:.4f} (débruité)\n"
+            report += f" ⚡ JITTER-Δ    : {jitter_delta:.4f}\n"
+            report += f" 📊 FLATNESS    : {flatness:.6f}\n"
+            report += f" 🕰️ VINTAGE     : {'Oui' if is_vintage else 'Non'}\n"
+            report += f" 📻 BROADCAST   : {'Oui' if is_broadcast else 'Non'}\n"
+            report += f" 🎵 ACOUSTID    : {acoustid_info}\n"
+            report += f" 🧹 DÉBRUITAGE  : {raison_denoise}\n"
+            report += f" 🔑 SHA256      : {sha[:24]}...\n"
+            report += f"{'-'*50}\n"
+            report += f" >>> VERDICT : {verdict}\n"
+            report += f" >>> NOTES :\n"
+            for r in raisons:
+                report += f"     • {r}\n"
+            report += f"{'='*50}\n"
+            report += "Antigravity Shield v5.0 · ACoNum / Trusted Sound 2026\n"
+
+            return (
+                self.generer_spectrogramme(y, sr, jitter_a, jitter_b, aasist_score),
+                report,
+                {
+                    "Score": f"{confiance}%",
+                    "Verdict": verdict,
+                    "Jitter-A": round(jitter_a, 4),
+                    "Jitter-B": round(jitter_b, 4),
+                    "Jitter-Delta": round(jitter_delta, 4),
+                    "Flatness": round(flatness, 6),
+                    "AASIST": round(aasist_score, 3) if aasist_score is not None else "N/A",
+                    "AcoustID": acoustid_info,
+                    "Vintage": is_vintage,
+                    "Broadcast": is_broadcast,
+                    "Centroid": round(centroid, 1)
+                }
+            )
+
+        except Exception as e:
+            import traceback
+            return None, f"Erreur : {e}\n{traceback.format_exc()}", None
+
+
+# ══════════════════════════════════════════════════════════════
+#  INTERFACE GRADIO
+# ══════════════════════════════════════════════════════════════
+shield = AntigravityShield()
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# 🛡️ Antigravity Shield v5.0 PRO\n"
+        "### Détecteur d'authenticité audio — AASIST + Double Jitter + AcoustID\n"
+        "_Fusion v5.0 : AASIST neural anti-spoofing + jitter calibré broadcast FM + AcoustID MusicBrainz_"
     )
-    if not raw:
-        return []
-    try:
-        import re
-        m = re.search(r'\[.*?\]', raw, re.DOTALL)
-        return json.loads(m.group(0)) if m else []
-    except Exception:
-        return []
-
-
-def generate_summary(name, media_type, content=''):
-    return ollama_generate(
-        f"Tu es un archiviste média professionnel. Rédige une description courte (2-3 phrases) pour:\n"
-        f"Nom: {name}\nType: {media_type}\nContenu: {content[:500] if content else 'non disponible'}\n"
-        f"Réponds uniquement avec la description en français."
+    with gr.Row():
+        with gr.Column():
+            audio_input = gr.Audio(type="filepath", label="Audio Input (MP3/WAV/FLAC)")
+            run_btn     = gr.Button("⚙️ ANALYSER", variant="primary")
+        with gr.Column():
+            image_output   = gr.Image(label="Spectrogramme + Double Jitter")
+            report_output  = gr.Textbox(label="Rapport d'expertise", lines=20)
+            metrics_output = gr.JSON(label="Métriques détaillées")
+
+    run_btn.click(
+        fn=shield.analyser_expert,
+        inputs=audio_input,
+        outputs=[image_output, report_output, metrics_output]
     )
 
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)          
 
-# ════════════════════════════════════════════════════════════
-#  AUDIO — Whisper + conversion FLAC TC-04
-# ════════════════════════════════════════════════════════════
-def analyze_audio(file_path):
-    transcript = ''
-    flac_ok    = False
-    flac_path  = ''
-
-    # 1. Transcription Whisper
-    try:
-        import whisper
-        model = whisper.load_model('small')
-        result = model.transcribe(file_path, language=None, fp16=False)
-        transcript = result.get('text', '').strip()
-    except ImportError:
-        transcript = '[Whisper non installé — lance INSTALLER_MAM.bat]'
-    except Exception as e:
-        transcript = f'[Erreur Whisper: {str(e)[:100]}]'
-
-    # 2. Conversion FLAC IASA TC-04 (96kHz / 24-bit)
-    try:
-        base      = os.path.splitext(os.path.basename(file_path))[0]
-        flac_dir  = os.path.join(os.path.dirname(file_path), '..', 'flac')
-        os.makedirs(flac_dir, exist_ok=True)
-        flac_path = os.path.abspath(os.path.join(flac_dir, base + '_TC04_96k24b.flac'))
-
-        cmd = [
-            FFMPEG, '-y', '-i', file_path,
-            '-c:a', 'flac',
-            '-ar', '96000',
-            '-sample_fmt', 's32',
-            '-bits_per_raw_sample', '24',
-            '-compression_level', '8',
-            flac_path
-        ]
-        result = subprocess.run(cmd, capture_output=True, timeout=120)
-        flac_ok = result.returncode == 0 and os.path.exists(flac_path)
-    except Exception as e:
-        flac_ok = False
-        flac_path = ''
-
-    # 3. Tags + résumé via Ollama
-    name    = os.path.basename(file_path)
-    content = transcript[:400] if transcript else ''
-    tags    = generate_tags(name, 'audio', content)
-    summary = generate_summary(name, 'audio', content)
-
-    ok(
-        summary    = summary    or f'Fichier audio : {name}',
-        tags       = tags       or ['audio', 'archive', 'patrimoine', 'son', 'ACoNum'],
-        transcript = transcript,
-        flac_ok    = flac_ok,
-        flac_path  = flac_path,
-        standard   = 'IASA TC-04 — FLAC 96kHz/24-bit' if flac_ok else 'Conversion FLAC non effectuée',
-    )
-
-
-# ════════════════════════════════════════════════════════════
-#  VIDEO — FFmpeg + Whisper
-# ════════════════════════════════════════════════════════════
-def analyze_video(file_path):
-    transcript = ''
-    audio_tmp  = file_path + '_audio_tmp.wav'
-
-    # 1. Extraire l'audio en WAV
-    try:
-        cmd = [FFMPEG, '-y', '-i', file_path, '-vn',
-               '-ar', '16000', '-ac', '1', '-f', 'wav', audio_tmp]
-        subprocess.run(cmd, capture_output=True, timeout=120)
-    except Exception:
-        pass
-
-    # 2. Transcrire avec Whisper
-    audio_src = audio_tmp if os.path.exists(audio_tmp) else file_path
-    try:
-        import whisper
-        model  = whisper.load_model('small')
-        result = model.transcribe(audio_src, language=None, fp16=False)
-        transcript = result.get('text', '').strip()
-    except ImportError:
-        transcript = '[Whisper non installé]'
-    except Exception as e:
-        transcript = f'[Erreur Whisper: {str(e)[:100]}]'
-
-    # Nettoyage fichier temporaire
-    if os.path.exists(audio_tmp):
-        try: os.remove(audio_tmp)
-        except: pass
-
-    name    = os.path.basename(file_path)
-    content = transcript[:400]
-    tags    = generate_tags(name, 'video', content)
-    summary = generate_summary(name, 'video', content)
-
-    ok(
-        summary    = summary    or f'Fichier vidéo : {name}',
-        tags       = tags       or ['video', 'archive', 'media', 'ACoNum', 'deepfake'],
-        transcript = transcript,
-        videoshield_url = 'https://huggingface.co/spaces/NOBODY204/VideoShield',
-    )
-
-
-# ════════════════════════════════════════════════════════════
-#  IMAGE — LLaVA via Ollama (si disponible)
-# ════════════════════════════════════════════════════════════
-def analyze_image(file_path):
-    description = ''
-    name        = os.path.basename(file_path)
-
-    # Tenter LLaVA via Ollama (modèle vision)
-    try:
-        import urllib.request, base64
-        with open(file_path, 'rb') as f:
-            img_b64 = base64.b64encode(f.read()).decode('utf-8')
-
-        body = json.dumps({
-            'model':  'llava:7b',
-            'prompt': 'Décris cette image en français en 2-3 phrases pour un archiviste média.',
-            'images': [img_b64],
-            'stream': False,
-            'options': { 'temperature': 0, 'num_predict': 200 }
-        }).encode('utf-8')
-
-        req = urllib.request.Request(
-            OLLAMA_HOST + '/api/generate',
-            data=body,
-            headers={ 'Content-Type': 'application/json' },
-            method='POST'
-        )
-        with urllib.request.urlopen(req, timeout=60) as resp:
-            data = json.loads(resp.read().decode('utf-8'))
-            description = data.get('response', '').strip()
-    except Exception:
-        description = f'[LLaVA non disponible — analyse visuelle désactivée pour {name}]'
-
-    tags    = generate_tags(name, 'image', description)
-    summary = description or generate_summary(name, 'image', '')
-
-    ok(
-        summary         = summary or f'Fichier image : {name}',
-        tags            = tags    or ['image', 'visuel', 'archive', 'media', 'ACoNum'],
-        description     = description,
-        imageshield_url = 'https://huggingface.co/spaces/NOBODY204/ImageShield',
-    )
-
-
-# ���═══════════════════════════════════════════════════════════
-#  PDF — pdfplumber
-# ════════════════════════════════════════════════════════════
-def analyze_pdf(file_path):
-    text = ''
-    name = os.path.basename(file_path)
-
-    try:
-        import pdfplumber
-        with pdfplumber.open(file_path) as pdf:
-            pages = []
-            for i, page in enumerate(pdf.pages[:5]):  # 5 premières pages max
-                t = page.extract_text()
-                if t:
-                    pages.append(t.strip())
-            text = '\n'.join(pages)
-    except ImportError:
-        text = '[pdfplumber non installé — lance INSTALLER_MAM.bat]'
-    except Exception as e:
-        text = f'[Erreur lecture PDF: {str(e)[:100]}]'
-
-    content = text[:600]
-    tags    = generate_tags(name, 'pdf', content)
-    summary = generate_summary(name, 'pdf', content)
-
-    ok(
-        summary  = summary or f'Document PDF : {name}',
-        tags     = tags    or ['document', 'pdf', 'archive', 'texte', 'ACoNum'],
-        text     = text[:1000] if text else '',
-    )
-
-
-# ════════════════════════════════════════════════════════════
-#  MAIN
-# ════════════════════════════════════════════════════════════
-if __name__ == '__main__':
-    if len(sys.argv) < 3:
-        fail('Usage: python analyze_media.py <audio|video|image|pdf> <chemin_fichier>')
-
-    media_type = sys.argv[1].lower().strip()
-    file_path  = sys.argv[2].strip()
-
-    if not os.path.exists(file_path):
-        fail(f'Fichier introuvable : {file_path}')
+            
+       
 
-    try:
-        if   media_type == 'audio': analyze_audio(file_path)
-        elif media_type == 'video': analyze_video(file_path)
-        elif media_type == 'image': analyze_image(file_path)
-        elif media_type in ('pdf', 'doc'): analyze_pdf(file_path)
-        else: fail(f'Type non supporté : {media_type}. Utiliser audio/video/image/pdf')
-    except Exception as e:
-        fail(traceback.format_exc())
+