stoms / app.py
2Btainment's picture
Sicherheits-Audit: Gast-Pfade härten, XFF-Rate-Limit-Schlüssel, Presets nur Inhaber, pyc entfernt
04d06e6 verified
Raw History Blame Contribute Delete
71.7 kB
"""STΩMs – Absolution Audio Stem Engine (Gradio 6 · ZeroGPU). Standardweg (Einfachheit zuerst): Song hochladen → Ziel wird erkannt und vorausgewählt → ein Klick „Stems trennen“. Alles Weitere (Modelle, Ensembles, Ketten, Studio-Regler, Tempo/Tonart, Batch, Bibliothek) ist eingeklappt. """ from __future__ import annotations import os # Gradio 6 SSR kollidiert mit dem HF-Space-Runner → Client-Rendering erzwingen. os.environ["GRADIO_SSR_MODE"] = "false" # ZeroGPU-Regel: `import spaces` MUSS vor torch kommen. try: import spaces # noqa: F401 except ImportError: # lokal ohne spaces spaces = None import html import json import math import re import logging import time from pathlib import Path from typing import Any import gradio as gr from stoms import analysis from stoms import audio_io as aio from stoms import engine as eng from stoms import exports from stoms import fetchlink from stoms import jobs from stoms import library from stoms import master as M from stoms import registry as reg from stoms import stretch from stoms import studio from stoms import websec logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s") for noisy in ("httpx", "audio_separator", "urllib3", "httpcore"): logging.getLogger(noisy).setLevel(logging.WARNING) LOG = logging.getLogger("stoms") ROOT = Path(__file__).resolve().parent ASSETS = ROOT / "assets" gr.set_static_paths([str(ASSETS)]) ASSET_URL = "/gradio_api/file=" + str(ASSETS) V = "mk11" CSS = (ASSETS / "stoms.css").read_text(encoding="utf-8").replace("__ASSETS__", ASSET_URL) # Kritisches CSS direkt im index.html: Gradio hängt `head` erst per JS ein – auf langsamen Netzen würde die App # kurz ungestylt rendern und dann komplett umbrechen (CLS ≈ 1). Gradio montiert zudem erst leere Stations-Hüllen → unsichtbar, bis Hero und Footer gerendert sind (spätestens nach 8 s). CRIT_CSS = ("html,body{background:#05080d}gradio-app{visibility:hidden;animation:st-rv 0s 8s forwards}" "gradio-app:has(.st-hero):has(.st-foot){visibility:visible}@keyframes st-rv{to{visibility:visible}}") # Gradio scoped `css=` unter `.gradio-container .contain` – Media-Queries, Intro, Dock und Modals brauchen zusätzlich ein # ungescoptes Stylesheet. (ASSETS / "stoms.built.css").write_text(CSS, encoding="utf-8") HEAD = (f'<meta name="color-scheme" content="dark"><meta name="theme-color" content="#05080d">' f'<meta name="description" content="STΩMs – Stems trennen, mastern, MIDI und Analyse. Absolution Audio · 2Btainment.">' f'<meta property="og:title" content="STΩMs · Absolution Audio Stem Engine">' f'<meta property="og:description" content="Ein Song rein, saubere Stems raus – plus Mastering-Studio, MIDI und Tonart/BPM.">' f'<meta property="og:image" content="{ASSET_URL}/og.png"><meta name="twitter:card" content="summary_large_image">' f'<link rel="icon" type="image/svg+xml" href="{ASSET_URL}/favicon.svg">' f'<link rel="preload" as="font" type="font/woff2" crossorigin href="{ASSET_URL}/fonts/Figtree-normal-latin.woff2">' f'<link rel="preload" as="font" type="font/woff2" crossorigin href="{ASSET_URL}/fonts/Syne-normal-latin.woff2">' f'<link rel="preload" as="image" href="{ASSET_URL}/abyss-poster.webp" media="(min-width: 761px)">' f'<link rel="preload" as="image" href="{ASSET_URL}/abyss-poster-sm.webp" media="(max-width: 760px)">' f'<link rel="stylesheet" href="{ASSET_URL}/stoms.built.css?v={V}">' f'<script type="module" src="{ASSET_URL}/stoms.js?v={V}"></script>') EXAMPLE = str(ASSETS / "halflife_josh_woodward.flac") GOD_MAX_S = 1800.0 def H(*args, **kw) -> gr.HTML: """gr.HTML ohne Standard-js_on_load (spart 27 Klick-Listener und Function-Kompilate).""" kw.setdefault("js_on_load", None) return gr.HTML(*args, **kw) LIB_ROOT = jobs.OUT_ROOT / "lib" def lic_badge(m: dict) -> str: lic = m.get("license", "") return "MIT" if lic.startswith("MIT") else "GPL-3.0" if "GPL" in lic else "⚠ Lizenz offen" MODELS = reg.models() MODEL_CHOICES = [(f"{m['label']} · {lic_badge(m)}", k) for k, m in MODELS.items()] ENS = reg.ensembles() ENS_CHOICES = [(e["name"], k) for k, e in ENS.items()] CHAIN_CHOICES = [(c["name"], k) for k, c in reg.CHAINS.items()] ENS_MODEL_CHOICES = [(f"{m['label']} · {lic_badge(m)}", m["file"]) for m in MODELS.values() if m["task"] in ("vocals", "instrumental")] STEM_INPUTS = ["Mix", "Vocals", "Instrumental", "Lead", "Begleitung", "Drums", "Bass", "Other", "Guitar", "Piano", "Trocken"] MODES = [("Ω-Modus · Demucs v4 + HPSS + Mix-Check", "omega"), ("Einzelmodell", "single"), ("Ensemble", "ensemble"), ("Kette", "chain")] PRESET_CHOICES = [(f'{p["label"]} · {p["tag"]}', k) for k, p in M.PRESETS.items()] def preset_ui(k: str): """Preset gewählt: Erklärung zeigen, Ziel-Lautheit und Decke in die Regler (Rest setzt die Analyse beim Mastern).""" p = M.PRESETS[M.preset_key(k)] return (preset_info(k), *[gr.update(value=p[f]) if f in ("lufs", "ceiling") else gr.update() for f, *_ in SLIDERS]) def preset_info(k: str) -> str: p = M.PRESETS[M.preset_key(k)] tgt = ("aus der Messung" if M.preset_key(k) == "auto" else f'{_n(p["lufs"])} LUFS · Decke {_n(p["ceiling"])} dBTP') return (f'<div class="st-preset-info"><b>{html.escape(p["label"])}</b><span class="st-preset-info__t">◎ {tgt}</span>' f'<span>{html.escape(p["info"])}</span></div>') SLIDERS = [ # (Feld, Label, min, max, step, Standard) ("vb_amount", "Virtual Bass · Obertöne", 0, 1, 0.01, 0.35), ("vb_freq", "Virtual Bass · Grenzfrequenz (Hz)", 50, 160, 1, 90), ("vb_sub", "Sub-Boost 45 Hz (dB)", -3, 6, 0.1, 0), ("eq_low", "EQ Bass 110 Hz (dB)", -6, 6, 0.1, 0), ("eq_lowmid", "EQ Tiefmitten 350 Hz (dB)", -6, 6, 0.1, 0), ("eq_mid", "EQ Mitten 1,5 kHz (dB)", -6, 6, 0.1, 0), ("eq_pres", "EQ Präsenz 4,5 kHz (dB)", -6, 6, 0.1, 0), ("eq_air", "EQ Luft 11 kHz (dB)", -6, 6, 0.1, 0), ("comp", "Multiband-Kompressor · Intensität", 0, 1, 0.01, 0.35), ("sat", "Sättigung", 0, 1, 0.01, 0.15), ("exciter", "Exciter (Höhen)", 0, 1, 0.01, 0.15), ("width", "Stereobreite (M/S)", 0, 1.6, 0.01, 1.0), ("mono_below", "Bass mono unter (Hz)", 0, 250, 1, 120), ("lufs", "Ziel-Lautheit (LUFS)", -30, -6, 0.1, -14), ("ceiling", "True-Peak-Decke (dBTP)", -3, -0.1, 0.1, -1.0), ] STEM_DOTS = ["#7ef0d0", "#ffb35c", "#8f7bff", "#6fd3f5", "#a6e04a"] OMEGA = "M27 93 H45 V85 C31 79 22 67 22 53 C22 33 39 19 60 19 C81 19 98 33 98 53 C98 67 89 79 75 85 V93 H93" def emblem(uid: str, cls: str, anim: bool = True) -> str: """Ω-Emblem: Ring mit Skala, gekippte Stem-Umlaufbahn mit 5 Stem-Punkten, Ω in drei versetzten Spektral-Strichen (= Trennung), Wellenform im Bauch. Reines SVG, eindeutige IDs je Einsatz.""" g, gl, co = f"{uid}g", f"{uid}f", f"{uid}c" dots = [] for i, c in enumerate(STEM_DOTS): a = i / len(STEM_DOTS) * 2 * math.pi + 0.5 x, y = 50 * math.cos(a), 15 * math.sin(a) r = math.radians(-22) X, Y = 60 + x * math.cos(r) - y * math.sin(r), 60 + x * math.sin(r) + y * math.cos(r) dots.append(f'<circle class="st-mark__dot" cx="{X:.1f}" cy="{Y:.1f}" r="{3.1 if i == 0 else 2.4}" fill="{c}" style="--i:{i}"/>') bars = "".join(f'<rect x="{46 + i * 6:.0f}" y="{53 - h / 2:.1f}" width="3.2" height="{h:.1f}" rx="1.6"/>' for i, h in enumerate([7, 15, 22, 13, 8])) pl = ' pathLength="100"' if anim else "" return (f'<svg class="{cls}" viewBox="0 0 120 120" aria-hidden="true" focusable="false">' f'<defs><linearGradient id="{g}" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#b9fbe9"/>' f'<stop offset=".45" stop-color="#6fd3f5"/><stop offset="1" stop-color="#b39bff"/></linearGradient>' f'<radialGradient id="{co}" cx=".5" cy=".46" r=".5"><stop offset="0" stop-color="#6fd3f5" stop-opacity=".30"/>' f'<stop offset=".6" stop-color="#b39bff" stop-opacity=".08"/><stop offset="1" stop-color="#05080d" stop-opacity="0"/></radialGradient>' f'<filter id="{gl}" x="-30%" y="-30%" width="160%" height="160%"><feGaussianBlur stdDeviation="2.4" result="b"/>' f'<feMerge><feMergeNode in="b"/><feMergeNode in="SourceGraphic"/></feMerge></filter></defs>' f'<circle cx="60" cy="60" r="57" fill="url(#{co})"/>' f'<g filter="url(#{gl})" fill="none" stroke-linecap="round" stroke-linejoin="round">' f'<circle cx="60" cy="60" r="55" stroke="url(#{g})" stroke-width="1.1" opacity=".55"/>' f'<circle class="st-mark__ticks" cx="60" cy="60" r="50.5" stroke="url(#{g})" stroke-width="2.6" stroke-dasharray=".7 4.587" opacity=".38"/>' f'<ellipse class="st-mark__orbit" cx="60" cy="60" rx="50" ry="15" transform="rotate(-22 60 60)" stroke="url(#{g})" stroke-width=".9" opacity=".5"/>' f'<path class="st-mark__om st-mark__om--a" d="{OMEGA}"{pl} stroke="#b39bff" stroke-width="7.5" opacity=".75" transform="translate(2.4 1.2)"/>' f'<path class="st-mark__om st-mark__om--b" d="{OMEGA}"{pl} stroke="#7ef0d0" stroke-width="7.5" opacity=".75" transform="translate(-2.4 -1.2)"/>' f'<path class="st-mark__om st-mark__om--c" d="{OMEGA}"{pl} stroke="url(#{g})" stroke-width="6"/>' f'<g class="st-mark__wave" fill="url(#{g})" stroke="none">{bars}</g>' f'{"".join(dots)}</g></svg>') def wavemark(uid: str, cls: str) -> str: """mk11-Logo links: offener Lichtring + symmetrische Wellenform + Achse, die in das S läuft. Reines SVG.""" g, gl = f"{uid}g", f"{uid}f" hs = [4, 7, 5, 11, 9, 17, 24, 33, 44, 30, 38, 22, 15, 19, 10, 6, 8, 4] bars = "".join(f'<rect x="{24 + i * 4.1:.1f}" y="{60 - h / 2:.1f}" width="1.7" height="{h:.1f}" rx=".85" style="--i:{i}"/>' for i, h in enumerate(hs)) return (f'<svg class="{cls}" viewBox="0 0 120 120" aria-hidden="true" focusable="false">' f'<defs><linearGradient id="{g}" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#b9fbe9"/>' f'<stop offset=".5" stop-color="#6fd3f5"/><stop offset="1" stop-color="#b39bff"/></linearGradient>' f'<filter id="{gl}" x="-40%" y="-40%" width="180%" height="180%"><feGaussianBlur stdDeviation="2.2" result="b"/>' f'<feMerge><feMergeNode in="b"/><feMergeNode in="SourceGraphic"/></feMerge></filter></defs>' f'<g filter="url(#{gl})" fill="none" stroke-linecap="round">' f'<path class="st-wm__ring" d="M104 36 A52 52 0 1 0 104 84" stroke="url(#{g})" stroke-width="3.2"/>' f'<path d="M98 40 A46 46 0 1 0 98 80" stroke="#b9fbe9" stroke-width=".8" opacity=".55"/>' f'<path d="M6 60 H120" stroke="url(#{g})" stroke-width="1" opacity=".8"/>' f'<g class="st-wm__wave" fill="url(#{g})" stroke="none">{bars}</g></g></svg>') def _ekg() -> str: # EKG-Linie quer durch die Mitte des Ω (Ruhe – P – QRS – T – Ruhe) + Stern für den einmaligen Glanz return ('<svg class="st-logo__ekg" viewBox="0 0 100 40" preserveAspectRatio="none" aria-hidden="true" focusable="false">' '<path d="M-6 21 H22 L26 18 L29 21 H35 L38 25 L42 4 L47 36 L51 14 L54 23 L57 21 H64 Q68 15 72 21 H106"/></svg>' '<svg class="st-logo__star" viewBox="-10 -10 20 20" aria-hidden="true" focusable="false">' '<path d="M0 -10 L1.3 -1.3 L10 0 L1.3 1.3 L0 10 L-1.3 1.3 L-10 0 L-1.3 -1.3Z"/></svg>') def _ribbons(uid: str) -> str: """Lichtbänder unter den Buchstaben (vom Ring bis zum s); non-scaling-stroke → überall gleich fein.""" g, g2 = f"{uid}r", f"{uid}s" ps = [("M0 52 C120 20 220 96 360 60 S600 10 720 58 S900 92 1000 40", f"url(#{g})", 2.2, ".9", "st-logo__rb"), ("M0 60 C140 34 230 104 380 68 S610 22 740 64 S920 98 1000 52", f"url(#{g})", 1.1, ".7", ""), ("M0 66 C150 48 250 110 400 76 S620 36 760 72 S930 104 1000 62", f"url(#{g2})", 1, ".55", "st-logo__rb"), ("M0 56 C100 40 240 84 370 64 S590 30 730 60 S910 84 1000 46", "#b9fbe9", .6, ".6", ""), ("M0 72 C160 62 260 112 420 84 S640 52 780 80 S940 108 1000 74", f"url(#{g})", .7, ".35", "")] paths = "".join(f'<path d="{d}" stroke="{c}" stroke-width="{w}" opacity="{o}" vector-effect="non-scaling-stroke"' + (f' class="{k}" pathLength="100"' if k else "") + "/>" for d, c, w, o, k in ps) sparks = "".join(f'<circle cx="{x}" cy="{y}" r="{r}" style="--i:{i}"/>' for i, (x, y, r) in enumerate([(905, 30, 2.4), (950, 70, 1.8), (870, 86, 1.6), (985, 44, 2), (930, 14, 1.4), (842, 40, 1.5)])) return (f'<svg class="st-logo__rib" viewBox="0 0 1000 120" preserveAspectRatio="none" aria-hidden="true" focusable="false">' f'<defs><linearGradient id="{g}" x1="0" x2="1"><stop offset="0" stop-color="#7ef0d0" stop-opacity=".2"/>' f'<stop offset=".18" stop-color="#7ef0d0"/><stop offset=".55" stop-color="#6fd3f5"/><stop offset="1" stop-color="#b39bff"/></linearGradient>' f'<linearGradient id="{g2}" x1="0" x2="1"><stop offset="0" stop-color="#ffd08a" stop-opacity="0"/><stop offset=".45" stop-color="#ffd08a"/>' f'<stop offset=".62" stop-color="#a6e04a"/><stop offset="1" stop-color="#b39bff" stop-opacity=".3"/></linearGradient></defs>' f'<g fill="none" stroke-linecap="round">{paths}</g>' f'<g class="st-logo__sparks" fill="#fff">{sparks}</g></svg>') def logo(uid: str, intro: bool = False) -> str: """STΩMs-Wortmarke (mk11): Ring+Welle · ST/Ms als RapScript-Masken (Schrift wird nicht ausgeliefert) · Ω in normaler Schrift mit EKG-Linie · Lichtbänder darunter. Glanz-Sweep läuft einmalig beim Intro (Klasse is-reveal, JS).""" om = (f'<span class="mk-intro__om st-logo__om">Ω{_ekg()}</span>' if intro else f'<button type="button" class="st-omega st-logo__om" aria-label="Omega">Ω{_ekg()}</button>') sr = (lambda t: "") if intro else (lambda t: f'<span class="st-sr">{t}</span>') return (_ribbons(uid) + wavemark(uid + "w", "st-mark st-logo__mark st-neon st-neon--b") + f'<span class="st-lg st-lg--st st-neon">{sr("ST")}</span>' + om + f'<span class="st-lg st-lg--ms st-neon">{sr("Ms")}</span>') # Überschriften als Masken aus RapScript_Fade (tools/render_heads.py) – die Schrift selbst wird nicht ausgeliefert. HD = {"Quelle": ("quelle", 492), "Modus": ("modus", 414), "Trennung": ("trennung", 715), "Stem-Orbit": ("orbit", 807), "Mastering-Studio": ("studio", 1295), "Export": ("export", 499), "Vorher": ("vorher", 484), "Nachher": ("nachher", 575), "Visuals": ("visual", 586)} HD_H = 161 def hd(text: str, cls: str = "st-hd") -> str: """Überschrift als Gradient-Maske (Bild der Schrift) + unsichtbarer, vorlesbarer Text.""" if text not in HD: return html.escape(text) k, w = HD[text] return (f'<span class="{cls}" style="--lg:url({ASSET_URL}/hd/{k}.webp?v={V});--ar:{w}/{HD_H}" aria-hidden="true"></span>' f'<span class="st-sr">{html.escape(text)}</span>') INTRO = f""" <div class="mk-intro" role="dialog" aria-label="STΩMs Intro" aria-modal="false"> <div class="mk-intro__inner"> <div class="mk-intro__word st-logo" role="img" aria-label="STΩMs">{logo("il", intro=True)}</div> <div class="mk-intro__sub">Absolution Audio · Stem Engine</div> <button type="button" class="mk-intro__go">Los geht’s ↓</button> </div> <button type="button" class="mk-intro__snd" aria-pressed="true" aria-label="Start-Klang an/aus">♪ Klang an</button> </div>""" HERO = """ <header class="st-hero"> <span class="st-kicker">Absolution Audio · Stem Engine</span> <h1 class="st-title st-logo">""" + logo("hl") + """</h1> <p class="st-lead">Ein Song rein, saubere Stems raus. STΩMs erkennt, was du hochlädst, wählt die passende Trennung vor – du klickst nur noch einmal. Danach: 3D-Orbit, Mastering-Studio, MIDI, Tonart & BPM.</p> <div class="st-chips"><span class="st-chip">bis 10 min · 100 MB</span><span class="st-chip">FLAC 24 bit · MIDI · Bericht</span> <span class="st-chip">Mastering auf CPU – keine GPU-Verschwendung</span><span class="st-chip">Taste ? = Tastenkürzel</span></div> </header> <nav class="mk-dock" aria-label="Stationen"> <button type="button" class="mk-dock__st is-on" data-st="1"><b>1</b><span>Quelle</span></button> <button type="button" class="mk-dock__st" data-st="2"><b>2</b><span>Modus</span></button> <button type="button" class="mk-dock__st" data-st="3"><b>3</b><span>Trennung</span></button> <button type="button" class="mk-dock__st" data-st="4"><b>4</b><span>Orbit</span></button> <button type="button" class="mk-dock__st" data-st="5"><b>5</b><span>Studio</span></button> <button type="button" class="mk-dock__st" data-st="6"><b>6</b><span>Export</span></button> </nav> """ def head(n: int, title: str, sub: str) -> str: return (f'<div class="st-head"><span class="st-num">{n}</span><h2 class="st-h">{hd(title)}</h2></div>' f'<p class="st-sub">{html.escape(sub)}</p>') def status(kind: str, msg: str, extra: str = "") -> str: return f'<div class="st-status"{extra}><span class="{kind}">{html.escape(msg)}</span></div>' def god_ok(god_on: bool, profile: gr.OAuthProfile | None) -> bool: """God-Mode nur serverseitig: Checkbox UND HF-Login 2Btainment – Client-Zustand allein zählt nie.""" return bool(god_on) and library.is_owner(profile) # ------------------------------------------------------------------ Station 1 · Quelle + Ziel-Erkennung def _goal_html(a: dict | None) -> str: if not a: return "" g = a.get("goal") or {} chips = [] if g.get("goal") != "speech": k = a.get("key") or {} if k.get("key"): chips.append(f'<span class="st-chip" title="Alternative: {html.escape(str(k.get("alternative", "")))}">Tonart {html.escape(k["key"])} · {html.escape(k.get("camelot", ""))}</span>') if a.get("bpm"): chips.append(f'<span class="st-chip" title="halbes/doppeltes Tempo: {html.escape(str(a.get("bpm_halb_doppelt", "")))}">{a["bpm"]:.0f} BPM</span>') if a.get("chords_common"): chips.append(f'<span class="st-chip">Akkorde {html.escape(" · ".join(a["chords_common"][:5]))}</span>') return (f'<div class="st-goal" data-goal="{html.escape(g.get("goal", ""))}"><b>Erkannt: {html.escape(g.get("label", "?"))}</b> ' f'<span class="st-note">({int(round(100 * g.get("confidence", 0)))} %)</span><br>{html.escape(g.get("reason", ""))} ' f'<span class="st-note">Schon vorausgewählt – du musst nur noch trennen. Ändern kannst du alles in Station 2.</span>' f'<div class="st-chips">{"".join(chips)}</div></div>') def on_upload(path: str | None, god_on: bool = False, profile: gr.OAuthProfile | None = None): keep = (gr.update(),) * 5 if not path: return (status("st-note", "Noch keine Datei."), "", None, *keep) try: i = aio.validate_upload(path, GOD_MAX_S if god_ok(god_on, profile) else aio.MAX_SECONDS) except aio.InputError as exc: return (status("err", "✕ " + str(exc)), "", None, *keep) m, s = divmod(int(round(i["duration"])), 60) info = status("ok", f"✓ {i['name']} · {m}:{s:02d} min · {i['codec']} · {i['sample_rate']} Hz · {i['channels']} Kanal/e · " f"{i['size_bytes'] / 1048576:.1f} MB") try: t0 = time.time() a = analysis.analyze_song(aio.read(path), aio.SR) LOG.info("Analyse %.1f s: %s", time.time() - t0, a.get("goal", {}).get("goal")) except Exception: LOG.exception("Analyse fehlgeschlagen") return (info, "", None, *keep) p = (a.get("goal") or {}).get("preset") or {} mode = p.get("mode", "omega") return (info, _goal_html(a), a, gr.update(value=mode), gr.update(value=p.get("quality", "schnell")), gr.update(value=0.7 if p.get("bleed") else 0.0), gr.update(value=p["model"]) if p.get("model") else gr.update(), gr.update(value=MODE_INFO.get(mode, ""))) def on_mode(mode: str): return (gr.update(visible=mode == "single"), gr.update(visible=mode == "ensemble"), gr.update(visible=mode == "chain"), gr.update(value=MODE_INFO.get(mode, ""))) MODE_INFO = { "omega": "**Ω-Modus** · Demucs v4 htdemucs_ft (MIT) trennt in Vocals/Drums/Bass/Other. Eine HPSS-Verfeinerung verschiebt " "harmonische Reste aus den Drums nach Other und perkussive Reste zurück – summenerhaltend. Ein float64-Mix-Check rechnet " "Mix − Σ Stems; was übrig bleibt, landet als **Rest**: Die Stems ergeben den Song exakt.", "single": "**Einzelmodell** · ein Modell aus der Registry, direkt auf den Song. Lizenz steht hinter jedem Namen.", "ensemble": "**Ensemble** · mehrere Modelle für denselben Stem, kombiniert mit einem Ensemble-Algorithmus; " "der Gegenpart ist exakt Mix − Ergebnis.", "chain": "**Kette** · Schritt für Schritt: jedes Modell bekommt einen Stem des vorherigen Schritts.", } # ------------------------------------------------------------------ Station 3 · Trennung def _quality_html(rep: dict | None) -> str: if not rep or not rep.get("stems"): return "" rows = [] for s in rep["stems"]: q = s.get("quality") or {} light = q.get("light") or "info" val = "–" if q.get("bleed_pct") is None else f"{q['bleed_pct']:.1f} % Übersprechen · Konsistenz {q['sdr_proxy_db']:.1f} dB" rows.append(f'<li class="st-q st-q--{html.escape(light)}" tabindex="0" title="{html.escape(q.get("hint", ""))}">' f'<i aria-hidden="true"></i><b>{html.escape(s["name"])}</b><span>{html.escape(val)}</span>' f'<em class="st-sr">{html.escape(light)}: {html.escape(q.get("hint", ""))}</em></li>') return (f'<div class="st-qual"><div class="st-qual__h">Stem-Ampel <span class="st-info" tabindex="0" ' f'title="{html.escape(rep.get("quality_method", ""))}">ⓘ ehrlich erklärt</span></div><ul>{"".join(rows)}</ul></div>') def _validate_choice(mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, god: bool): custom_ens = None if mode == "ensemble" and ens_custom: files = list(ens_models or []) hi = 8 if god else 4 if not 2 <= len(files) <= hi: raise eng.EngineError(f"Wähle für ein eigenes Ensemble 2 bis {hi} Modelle.") if ens_algo not in reg.ALGORITHMS: raise eng.EngineError("Unbekannter Ensemble-Algorithmus.") if not set(files) <= {f for _, f in ENS_MODEL_CHOICES}: raise eng.EngineError("Ein gewähltes Modell ist nicht freigegeben.") tgt = "Instrumental" if ens_target == "Instrumental" else "Vocals" custom_ens = {"name": "Eigenes Ensemble", "models": files, "algorithm": ens_algo, "target": tgt, "complement": "Vocals" if tgt == "Instrumental" else "Instrumental"} custom_chain = None if mode == "chain" and chain_custom: custom_chain = [(s1m, "Mix")] if s2m: custom_chain.append((s2m, s2i or "Vocals")) if s2m and s3m: custom_chain.append((s3m, s3i or "Vocals")) for mk, src in custom_chain: if mk not in MODELS or src not in STEM_INPUTS: raise eng.EngineError("Ungültiger Ketten-Schritt.") if mode not in {"omega", "single", "ensemble", "chain"} or (mode == "single" and model_key not in MODELS) \ or (mode == "ensemble" and not custom_ens and ens_key not in ENS) \ or (mode == "chain" and not custom_chain and chain_key not in reg.CHAINS): raise eng.EngineError("Ungültige Auswahl.") return custom_ens, custom_chain def _extras(path: str, bleed, midi_on, ana: dict | None, god: bool) -> dict: if ana is None: try: aio.validate_upload(path, GOD_MAX_S if god else aio.MAX_SECONDS) ana = analysis.analyze_song(aio.read(path), aio.SR) except Exception: LOG.exception("Analyse fehlgeschlagen") ana = None return {"bleed": float(bleed or 0), "midi": bool(midi_on), "analysis": ana, "max_seconds": GOD_MAX_S if god else aio.MAX_SECONDS} def _sid(request: gr.Request | None) -> str | None: return getattr(request, "session_hash", None) if request is not None else None def _song_label(job_dir: str | None, fallback: str = "Song") -> str: try: return Path(json.loads((Path(job_dir) / "report.json").read_text(encoding="utf-8"))["input"]["name"]).stem or fallback except Exception: return fallback def _export_job(sid, r: dict) -> None: """Trenn-Ergebnis → Export: Stems, MIDI, Analyse, Bericht, Projekt-ZIP.""" d = Path(r["dir"]) its = [("stems", f) for f in r["files"]] for f in r["extra_files"]: its.append(("midi" if f.lower().endswith(".mid") else "analysis", f)) its += [("report", str(d / "report.json")), ("package", r["zip"])] exports.add(sid, d.name, _song_label(str(d)), its) def _exp(request: gr.Request | None, msg: str = "") -> str: return exports.render(_sid(request), msg) def separate(upload, mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, quality, allow_cpu, bleed=0.7, midi_on=True, god_on=False, ana_state=None, profile: gr.OAuthProfile | None = None, progress=gr.Progress()): """Song in Stems trennen. Rückgabe: Status, Stem-Dateien (FLAC 24 bit, MIDI, Analyse), ZIP (inkl. Bericht), Bericht.""" st, r = _separate(upload, mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, quality, allow_cpu, bleed, midi_on, god_on, ana_state, profile, progress) if r is None: raise gr.Error(re.sub(r"<[^>]+>", "", st).strip()) return st, r["files"] + r["extra_files"], r["zip"], r["report"] def separate_ui(upload, mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, quality, allow_cpu, bleed=0.7, midi_on=True, god_on=False, ana_state=None, profile: gr.OAuthProfile | None = None, request: gr.Request = None, progress=gr.Progress()): st, r = _separate(upload, mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, quality, allow_cpu, bleed, midi_on, god_on, ana_state, profile, progress) if r is None: return st, jobs.orb_html(None), None, "", gr.update() _export_job(_sid(request), r) return st, r["orb_html"], r["dir"], _quality_html(r["report"]), _exp(request) def _separate(upload, mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, quality, allow_cpu, bleed, midi_on, god_on, ana_state, profile, progress): god = god_ok(god_on, profile) try: custom_ens, custom_chain = _validate_choice(mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, god) ana = ana_state if isinstance(ana_state, dict) else None r = jobs.run_job(upload, mode, model_key, ens_key, chain_key, quality, bool(allow_cpu), custom_chain=custom_chain, custom_ens=custom_ens, progress=progress, extras=_extras(upload, bleed, midi_on, ana, god)) except (aio.InputError, eng.EngineError, jobs.JobError) as exc: return status("err", "✕ " + str(exc)), None except Exception: # nichts Internes an Nutzer leaken LOG.exception("Trennung fehlgeschlagen") return status("err", "✕ Unerwarteter Fehler bei der Trennung. Bitte erneut versuchen oder ein anderes Modell wählen."), None rep = r["report"] c = rep["closure"] kind = "warn" if r["fallback"] else "ok" msg = (f"{'⚠ CPU-Notbetrieb · ' if r['fallback'] else '✓ '}{len(rep['stems'])} Stems in {rep['total_seconds']:.0f} s " f"({', '.join(dict.fromkeys(rep['devices'])) or 'CPU'}) · Mix-Check: Fehler {c['relative_reconstruction_error_db']} dB " f"({'exakt' if c['consistent'] else ('praktisch exakt' if c['relative_reconstruction_error_db'] < -60 else 'Abweichung – siehe Rest-Stem')})") if rep.get("midi"): msg += f" · MIDI: {', '.join(t['role'] for t in rep['midi']['tracks'])}" if rep["notes"]: msg += " · " + " ".join(rep["notes"]) return status(kind, msg + " · alle Dateien → Export ⑥", ' data-done="1"'), r def after_job(job_dir, guest): """Nach der Trennung: Studio-Stem-Mixer, Tempo/Tonart-Auswahl, Gast-Verlauf (24 h, nur dieser Browser).""" names = studio.stem_names(job_dir) guest = [g for g in (guest or []) if isinstance(g, dict)][-11:] if job_dir: rep = json.loads((Path(job_dir) / "report.json").read_text(encoding="utf-8")) guest = [g for g in guest if g.get("dir") != job_dir] + [{"dir": job_dir, "name": rep["input"]["name"], "t": int(time.time())}] return (gr.update(choices=names, value=[n for n in names if n.lower() != "rest"]), _mixer_html(names), guest, _guest_choices(guest)) def _guest_choices(guest): now = time.time() ch = [(f"{g['name']} · {time.strftime('%d.%m. %H:%M', time.localtime(g['t']))}", g["dir"]) for g in reversed(guest or []) if now - g.get("t", 0) < jobs.TTL_S and Path(g["dir"], "report.json").exists()] return gr.update(choices=ch, value=ch[0][1] if ch else None) def _mixer_html(names: list[str]) -> str: if not names: return '<div class="st-mixer" data-names="[]"><p class="st-note">Nach der Trennung kannst du hier die Stems neu abmischen.</p></div>' return f'<div class="st-mixer" data-names=\'{html.escape(json.dumps(names), quote=True)}\'></div>' # ------------------------------------------------------------------ Batch def batch_run(files, mode, model_key, ens_key, chain_key, quality, allow_cpu, bleed, midi_on, god_on=False, profile: gr.OAuthProfile | None = None, request: gr.Request = None, progress=gr.Progress()): god = god_ok(god_on, profile) paths = [f if isinstance(f, str) else getattr(f, "name", None) for f in (files or [])] paths = [p for p in paths if p][:10] if not paths: return status("err", "✕ Bitte 2–10 Songs für den Batch hochladen."), gr.update() if mode not in {"omega", "single", "ensemble", "chain"}: mode = "omega" try: r = jobs.run_batch(paths, mode, model_key, ens_key, chain_key, quality, bool(allow_cpu), progress=progress, extras_fn=lambda p: _extras(p, bleed, midi_on, None, god)) except Exception: LOG.exception("Batch fehlgeschlagen") return status("err", "✕ Batch fehlgeschlagen."), gr.update() sid = _sid(request) for res in r.get("results") or []: try: _export_job(sid, res) except Exception: LOG.warning("Batch-Export: Song übersprungen") exports.add(sid, Path(r["zip"]).parent.name, f"Batch · {len(paths)} Songs", [("batch", r["zip"])]) ok = sum(1 for x in r["rows"] if x["status"] == "ok") rows = "".join(f'<li class="{"ok" if x["status"] == "ok" else "err"}">{x["nr"]}. {html.escape(x["song"])} – ' f'{"✓ " + str(x["stems"]) + " Stems" if x["status"] == "ok" else "✕ " + html.escape(x.get("grund", ""))}</li>' for x in r["rows"]) return (f'<div class="st-status"><span class="{"ok" if ok == len(paths) else "warn"}">{ok}/{len(paths)} Songs getrennt.</span>' f'<ul class="st-batch">{rows}</ul><span class="st-note">Batch-ZIP und alle Stems → Export ⑥</span></div>'), _exp(request) # ------------------------------------------------------------------ Versteckter Link-Import (Cheat) – Ctrl + 6× Ω def _client_key(request: gr.Request | None) -> str: if request is None: return "anon" try: # wie websec.client_ip: der vom HF-Proxy rechts angehängte Eintrag zählt – der erste ist vom Client fälschbar xs = [x.strip() for v in request.headers.getlist("x-forwarded-for") for x in v.split(",") if x.strip()] return (xs[-1][:64] if xs else "") or (request.client.host if request.client else "") or request.session_hash or "anon" except Exception: return getattr(request, "session_hash", None) or "anon" def cheat_fetch(text: str, request: gr.Request, progress=gr.Progress()): """Suno-/YouTube-Link(s) → Station 1 (ein Song) bzw. Batch (mehrere). Allowlist, HTTPS, SSRF-Schutz, Limits.""" key = _client_key(request) try: urls = fetchlink.parse_batch(text) fetchlink.rate_check(key, cost=1 if len(urls) == 1 else 2) except fetchlink.LinkError as exc: return status("err", "✕ " + str(exc)), gr.update(), gr.update() except Exception: LOG.exception("Link-Prüfung fehlgeschlagen") return status("err", "✕ Link konnte nicht geprüft werden."), gr.update(), gr.update() paths, rows = [], [] for i, u in enumerate(urls): progress(i / len(urls), desc=f"Song {i + 1}/{len(urls)} wird geladen …") try: r = fetchlink.fetch(u, key, rated=True) paths.append(r["path"]) m, s = divmod(int(round(r["info"]["duration"])), 60) rows.append(f'<li class="ok">{i + 1}. {r["kind"]} · {m}:{s:02d} min ✓</li>') except fetchlink.LinkError as exc: rows.append(f'<li class="err">{i + 1}. {html.escape(fetchlink.redact(u))} – ✕ {html.escape(str(exc))}</li>') except Exception: LOG.exception("Link-Import fehlgeschlagen: %s", fetchlink.redact(u)) rows.append(f'<li class="err">{i + 1}. {html.escape(fetchlink.redact(u))} – ✕ unerwarteter Fehler</li>') if not paths: return f'<div class="st-status"><span class="err">✕ Nichts geladen.</span><ul class="st-batch">{"".join(rows)}</ul></div>', gr.update(), gr.update() done = "single" if len(urls) == 1 else "batch" head_ = f'✓ {len(paths)} Song{"s" if len(paths) > 1 else ""} geladen → {"Station 1" if done == "single" else "Batch (Station 1)"}' out = f'<div class="st-status" data-cheat-done="{done}"><span class="ok">{head_}</span><ul class="st-batch">{"".join(rows)}</ul></div>' if done == "single": return out, paths[0], gr.update() return out, gr.update(), paths def god_probe(profile: gr.OAuthProfile | None): if library.is_owner(profile): st = library.status() return (f'<div data-god="1" data-n="{time.time():.3f}" class="st-status"><span class="ok">God-Mode bereit, ' f'{html.escape(profile.username)}.</span> <span class="st-note">Bibliothek: {html.escape(st["reason"])}</span></div>') return (f'<div data-god="0" data-n="{time.time():.3f}" class="st-status"><span class="warn">🔒 Nur für den Inhaber.</span> ' '<span class="st-note">Erst unten mit dem HF-Konto 2Btainment anmelden, dann erneut Strg/⌘ + 9× Ω.</span></div>') # ------------------------------------------------------------------ Station 4 · Tempo & Tonart def retune_ui(job_dir, names, tempo, semis, request: gr.Request = None): if not job_dir: return status("err", "✕ Erst trennen."), gr.update() try: st = {s["name"]: str(Path(job_dir) / s["file"]) for s in json.loads((Path(job_dir) / "report.json").read_text(encoding="utf-8"))["stems"] if s["name"] in (names or [])} if not st: return status("err", "✕ Wähle mindestens einen Stem."), gr.update() r = stretch.retune(st, str(Path(job_dir) / f"retune_T{int(tempo)}_P{int(semis):+d}"), float(tempo), float(semis)) except Exception: LOG.exception("Tempo/Tonart fehlgeschlagen") return status("err", "✕ Tempo/Tonart fehlgeschlagen."), gr.update() note = f"Tempo {tempo:.0f} % · {semis:+.0f} HT" exports.add(_sid(request), Path(job_dir).name, _song_label(job_dir), [("retune", s["file"]) for s in r["stems"]], note) return status("ok", f"✓ {len(r['stems'])} Stems · {note} · {r['engine']} · Drums nie transponiert → Export ⑥"), _exp(request) # ------------------------------------------------------------------ Station 5 · Mastering-Studio (CPU) # Klarer Ablauf: ① Quelle → ② Ziel → ③ Messen (Ist-Werte + Plan) → ④ Mastern (Vorher → Nachher, A/B). Alles nach ITU-R BS.1770. MS_SOURCES = [("Original-Mix", "mix"), ("Orbit-Remix", "stems"), ("Eigene Datei", "own")] def _n(v, d=1) -> str: """Zahl mit echtem Minuszeichen.""" try: return f"{float(v):.{d}f}".replace("-", "−") except (TypeError, ValueError): return "–" def _ms_target(preset: str, settings: dict | None = None) -> tuple[float, float]: p = M.PRESETS.get(M.preset_key(preset), M.PRESETS["streaming"]) st = settings or {} return float(st.get("lufs", p["lufs"])), float(st.get("ceiling", p["ceiling"])) def _ms_args(job_dir, own_file, source, stems_json): """Die Quelle entscheidet ausdrücklich – eine hochgeladene Datei überschreibt nichts mehr still.""" if source == "own": if not own_file: raise studio.StudioError("① Quelle: erst eine eigene Datei wählen.") return None, own_file, {"source": "mix"} if not job_dir: raise studio.StudioError("① Quelle: erst einen Song trennen (Station 3) – oder „Eigene Datei“ wählen.") try: st = json.loads(stems_json or "{}") except ValueError: st = {} return job_dir, None, {"source": "stems" if source == "stems" else "mix", "stems": st if isinstance(st, dict) else {}} def _tile(label, before, unit, after=None, ok=None, hint="", d=1) -> str: cls = "" if ok is None else (" is-ok" if ok else " is-warn") val = (f'<b>{_n(before, d)}</b>' if after is None else f'<s>{_n(before, d)}</s><i aria-hidden="true">→</i><b>{_n(after, d)}</b>') mark = "" if ok is None else (' <span class="st-kpi__ok">✓</span>' if ok else ' <span class="st-kpi__ok">⚠</span>') return (f'<div class="st-kpi{cls}"><dt>{label}</dt><dd>{val}<small>{unit}</small>{mark}</dd>' + (f'<p>{hint}</p>' if hint else "") + "</div>") def _meter_html(m: dict | None, preset: str = "auto", stale: bool = False) -> str: if not m: return ('<div class="st-msm" data-n="0"><p class="st-note">' + ("Quelle oder Ziel geändert – neu messen (oder direkt mastern, das misst auch)." if stale else "Misst Lautheit, True Peak und Dynamik deiner Quelle und zeigt den Plan.") + "</p></div>") a, s = m["before"], m["settings"] tl, tc = _ms_target(preset, s) gain = tl - float(a["lufs"]) plan = [f'Lautheit {"+" if gain >= 0 else "−"}{abs(gain):.1f} dB auf {_n(tl)} LUFS', f'Decke {_n(tc)} dBTP'] if s.get("vb_amount", 0) >= 0.3: plan.append("Virtual Bass") if s.get("comp", 0) >= 0.3: plan.append("Multiband-Glue") if abs(s.get("width", 1) - 1) > 0.04: plan.append(f'Stereo {int(round(100 * s["width"]))} %') tiles = "".join([ _tile("Lautheit", a["lufs"], "LUFS", hint=f"Ziel {_n(tl)}"), _tile("True Peak", a["true_peak"], "dBTP", hint=f"Decke {_n(tc)}"), _tile("Dynamik (LRA)", a.get("lra"), "LU", hint="Lautheits-Spanne"), _tile("Crest", a.get("crest"), "dB", hint="Peak ↔ RMS"), ]) return (f'<div class="st-msm" data-n="1"><p class="st-msm__src">Gemessen: <b>{html.escape(m["label"])}</b>' f'{" · mit Referenz" if m.get("ref") else ""}</p><dl class="st-kpis">{tiles}</dl>' f'<p class="st-plan"><b>Plan</b> {" · ".join(html.escape(x) for x in plan)}</p></div>') def _ab_html(r: dict, n_files: int) -> str: rep = r["report"] b, a = rep["before"], rep["after"] data = {"orig": exports.url(r["original"]), "master": exports.url(r["preview"]) if r["preview"] else None, "lufs_before": b["lufs"], "lufs_after": a["lufs"], "settings": r["settings"], "curve": (rep["chain"].get("reference") or {}).get("curve_db")} reasons = "".join(f"<li>{html.escape(w)}</li>" for w in rep.get("reasons", [])) ok = rep["target_ok"] tl, tc = _ms_target(rep.get("preset", "auto"), r["settings"]) tiles = "".join([ _tile("Lautheit", b["lufs"], "LUFS", a["lufs"], bool(ok["lufs"]), f"Ziel {_n(tl)}"), _tile("True Peak", b["true_peak"], "dBTP", a["true_peak"], bool(ok["true_peak"]), f"Decke {_n(tc)}"), _tile("Dynamik (LRA)", b.get("lra"), "LU", a.get("lra"), None, "Lautheits-Spanne"), _tile("Crest", b["crest"], "dB", a["crest"], None, "Peak ↔ RMS"), ]) return (f'<div class="st-ab" data-ab=\'{html.escape(json.dumps(data), quote=True)}\'>' f'<div class="st-io"><span>IN · {html.escape(rep.get("source_label", "Quelle"))}</span><i aria-hidden="true">→</i>' f'<span>OUT · WAV 24 · FLAC 24 · MP3 320 · Bericht</span>' f'<button type="button" class="st-linkbtn" data-goto="6">{n_files} Dateien im Export ⑥ ↓</button></div>' f'<dl class="st-kpis st-kpis--ba">{tiles}</dl>' f'<div class="st-ab__bar"><button type="button" class="st-btn st-play" data-ab-act="play">▶ Abspielen</button>' f'<div class="st-seg" role="radiogroup" aria-label="A/B-Vergleich">' f'<button type="button" role="radio" aria-checked="false" data-ab-src="orig">A · Vorher</button>' f'<button type="button" role="radio" aria-checked="true" data-ab-src="master">B · Master</button></div>' f'<label class="st-ab__lm" title="Gleiche Lautheit beim Vergleich – damit „lauter“ nicht „besser“ vortäuscht">' f'<input type="checkbox" checked data-ab-lm> pegelgleich</label>' f'<span class="st-ab__time">0:00</span></div>' f'<canvas class="st-ab__spec" aria-label="Spektrum und Pegel"></canvas>' f'<details class="st-why"><summary>Warum so?</summary><ul>{reasons or "<li>Manuelle Einstellungen.</li>"}</ul></details></div>') def _slider_cfg(vals) -> dict: return {f: v for (f, *_), v in zip(SLIDERS, vals)} def studio_measure(job_dir, own_file, source, stems_json, preset, auto, ref_file, ref_amt, *vals): """③ Messen: Ist-Werte + Plan. Bei Auto-Master übernimmt der Plan die Feinschliff-Regler.""" keep = [gr.update() for _ in SLIDERS] try: jd, own, cfg = _ms_args(job_dir, own_file, source, stems_json) m = studio.measure(jd, own, cfg, M.preset_key(preset), ref_file, float(ref_amt or 0.8)) except (studio.StudioError, aio.InputError, ValueError) as exc: return status("err", "✕ " + str(exc)), _meter_html(None), *keep except Exception: LOG.exception("Messung fehlgeschlagen") return status("err", "✕ Messung fehlgeschlagen."), _meter_html(None), *keep if not auto: # manuell: Plan zeigt Ziel aus den Reglern, Regler bleiben m["settings"] = {**m["settings"], **_slider_cfg(vals)} upd = keep else: upd = [gr.update(value=m["settings"].get(f, d)) for f, _, _, _, _, d in SLIDERS] return status("ok", "✓ Gemessen – jetzt ④ Mastern."), _meter_html(m, preset), *upd def studio_render(job_dir, own_file, preset, auto, source, stems_json, ref_file, ref_amt, request: gr.Request = None, progress=gr.Progress(), *vals): # Request/Progress stehen VOR *vals: Gradio injiziert Spezial-Argumente nur bei positionalen Parametern. keep = [gr.update() for _ in SLIDERS] try: jd, own, cfg = _ms_args(job_dir, own_file, source, stems_json) cfg.update(_slider_cfg(vals)) cfg.update({"preset": preset, "ref_amount": ref_amt}) r = studio.render(jd, own, cfg, preset, bool(auto), ref_file, progress=progress) except (studio.StudioError, aio.InputError, ValueError) as exc: return status("err", "✕ " + str(exc)), "", gr.update(), gr.update(), *keep except Exception: LOG.exception("Mastering fehlgeschlagen") return status("err", "✕ Mastering fehlgeschlagen."), "", gr.update(), gr.update(), *keep rep = r["report"] tl, _ = _ms_target(preset, r["settings"]) note = f"{M.PRESETS.get(M.preset_key(preset), {}).get('label', preset)} · {_n(tl)} LUFS" if jd: grp, lab = Path(jd).name, _song_label(jd) else: lab = Path(own).stem or "Eigene Datei" grp = "own:" + lab n = exports.add(_sid(request), grp, lab, [("master", f) for f in r["files"]], note) msg = (f"✓ Master ({rep['source_label']}): {_n(rep['before']['lufs'])} → {_n(rep['after']['lufs'])} LUFS · " f"True Peak {_n(rep['after']['true_peak'])} dBTP · {rep['seconds_total']:.1f} s CPU") meter = _meter_html({"before": rep["before"], "settings": r["settings"], "label": rep["source_label"], "ref": bool(rep["chain"].get("reference"))}, preset) upd = [gr.update(value=r["settings"].get(f)) for f, *_ in SLIDERS] return status("ok", msg, ' data-done="1"'), _ab_html(r, n or len(r["files"])), meter, _exp(request), *upd def remix_export(job_dir, stems_json, request: gr.Request = None): """Station 4: Orbit-Mix (Vol/M/S/Breite) als WAV 32-bit float bouncen → Export.""" try: path, label = studio.export_remix(job_dir, stems_json) except (studio.StudioError, aio.InputError, ValueError) as exc: return status("err", "✕ " + str(exc)), gr.update() except Exception: LOG.exception("Remix-Export fehlgeschlagen") return status("err", "✕ Bounce fehlgeschlagen."), gr.update() exports.add(_sid(request), Path(job_dir).name, _song_label(job_dir), [("bounce", path)], "WAV 32f · ungemastert") return status("ok", "✓ " + label + " → Export ⑥", ' data-done="1"'), _exp(request) def _drop_session(request: gr.Request): exports.drop(_sid(request)) # Tab zu → Register weg (Dateien räumt der 24-h-Cleanup) def export_zip(request: gr.Request = None): try: _, msg = exports.make_zip(_sid(request)) except Exception: LOG.exception("Export-ZIP fehlgeschlagen") msg = "ZIP fehlgeschlagen – bitte einzeln laden." return _exp(request, msg) # ------------------------------------------------------------------ Bibliothek def lib_refresh(profile: gr.OAuthProfile | None): if not library.is_owner(profile): return (status("st-note", "Bibliothek: nur für den Inhaber (HF-Login). Gäste: Verlauf unten, 24 h in diesem Browser."), gr.update(choices=[], value=None)) st = library.status() if not st["active"]: return status("warn", "⚠ " + st["reason"], ' data-owner="1"'), gr.update(choices=[], value=None) ps = library.list_projects(profile) ch = [(f"{p.get('title', p['job'])} · {time.strftime('%d.%m.%Y', time.localtime(p.get('saved', 0)))}", p["job"]) for p in ps] return status("ok", f"✓ Bibliothek aktiv · {len(ch)} Projekte.", ' data-owner="1"'), gr.update(choices=ch, value=ch[0][1] if ch else None) def lib_save(job_dir, title, profile: gr.OAuthProfile | None): if not job_dir: return status("err", "✕ Erst trennen.") try: jid = library.save_project(job_dir, title or "", {}, profile) except PermissionError as exc: return status("err", "✕ " + str(exc)) except Exception as exc: LOG.warning("Bibliothek speichern: %s", type(exc).__name__) return status("err", "✕ Speichern fehlgeschlagen: " + (str(exc)[:160] if isinstance(exc, RuntimeError) else type(exc).__name__)) return status("ok", f"✓ Projekt {jid} privat in der Bibliothek gespeichert.") def _show_result(r: dict, msg: str, request: gr.Request | None = None): _export_job(_sid(request), r) return (status("ok", msg), r["orb_html"], r["dir"], _quality_html(r["report"]), _exp(request)) def lib_load(jid, profile: gr.OAuthProfile | None, request: gr.Request = None): try: d = library.load_project(jid, str(LIB_ROOT), profile) r = jobs.load_result(str(d)) except Exception as exc: msg = str(exc) if isinstance(exc, (PermissionError, ValueError)) else "Laden fehlgeschlagen." return (status("err", "✕ " + msg), *(gr.update(),) * 4) return _show_result(r, f"✓ Projekt {jid} aus der Bibliothek geladen → Export ⑥", request) _GUEST_DIR = re.compile(r"^[0-9a-f]{12}$") def _guest_dir_ok(d) -> bool: """Gast-Verlauf kommt aus dem Browser (fälschbar): nur echte Job-Ordner direkt unter OUT_ROOT – nie lib/, Exporte o. a. Pfade.""" try: p = Path(str(d)).resolve() return p.parent == jobs.OUT_ROOT.resolve() and bool(_GUEST_DIR.match(p.name)) and p.is_dir() except (OSError, ValueError): return False def guest_load(d, guest, request: gr.Request = None): if not d or not _guest_dir_ok(d) or d not in {g.get("dir") for g in (guest or []) if isinstance(g, dict)} \ or not Path(d, "report.json").exists(): return (status("err", "✕ Projekt nicht mehr vorhanden (Gast-Projekte werden nach ~24 h gelöscht)."), *(gr.update(),) * 4) return _show_result(jobs.load_result(d), "✓ Gast-Projekt wieder geöffnet → Export ⑥", request) def presets_sync(direction, presets_json, profile: gr.OAuthProfile | None): if not library.is_owner(profile): return status("err", "✕ Remix-Presets in der Bibliothek nur für den Inhaber (HF-Login 2Btainment)."), gr.update() try: if direction == "save": library.save_presets(json.loads(presets_json or "{}"), profile) return status("ok", "✓ Remix-Presets in der Bibliothek gesichert."), gr.update() p = library.load_presets(profile) return status("ok", f"✓ {len(p)} Remix-Presets aus der Bibliothek geladen."), json.dumps(p, ensure_ascii=False) except PermissionError as exc: return status("err", "✕ " + str(exc)), gr.update() except Exception: return status("err", "✕ Bibliothek nicht erreichbar."), gr.update() def presets_save(presets_json, profile: gr.OAuthProfile | None): return presets_sync("save", presets_json, profile) def presets_load(presets_json, profile: gr.OAuthProfile | None): return presets_sync("load", presets_json, profile) # ------------------------------------------------------------------ Öffentliche API / MCP-Werkzeuge def master(audio: str, preset: str = "auto", settings_json: str = "", reference: str | None = None): """Mastert eine Audiodatei auf der CPU (Virtual Bass, EQ, Multiband, Sättigung, M/S, True-Peak-Limiter). Args: audio: Audiodatei (WAV/FLAC/MP3/M4A/OGG/Opus/AIFF, bis 10 min). preset: Ziel: auto, streaming, apple, club, podcast, youtube, soundcloud, vinyl, lofi, trap oder hifi. settings_json: optional – JSON mit Reglern (z. B. {"vb_amount":0.5,"lufs":-12}); leer = Auto-Master. reference: optional – Referenz-Track für Referenz-Mastering (Lautheit, Breite, Terzband-Match-EQ). Returns: Master-Dateien (WAV 24, FLAC 24, MP3 320, Bericht) und den Messbericht (LUFS/True Peak vorher/nachher). """ try: raw = json.loads(settings_json) if settings_json else {} if not isinstance(raw, dict): raise ValueError("settings_json muss ein JSON-Objekt sein.") r = studio.render(None, audio, raw, M.preset_key(preset), auto=not raw, ref_path=reference) except (studio.StudioError, aio.InputError, ValueError) as exc: raise gr.Error(str(exc)) from None return r["files"], r["report"] def analyze(audio: str) -> dict: """Analysiert einen Song auf der CPU: Tonart (inkl. Camelot), BPM, Akkordfolge je Beat und erkanntes Ziel (Song/Instrumental/Sprache/Live) mit empfohlener Trenn-Einstellung. Args: audio: Audiodatei (bis 10 min, 100 MB). Returns: JSON mit bpm, key, chords, chords_common und goal. """ try: aio.validate_upload(audio) return analysis.analyze_song(aio.read(audio), aio.SR) except aio.InputError as exc: raise gr.Error(str(exc)) from None API_SEPARATE_DOC = ("Trennt einen Song in Stems (ZeroGPU). mode: omega | single | ensemble | chain. model_key/ens_key/chain_key " "aus der Registry. quality: schnell | max. bleed 0..1 = Bleed-Killer, midi = MIDI-Export (Basic Pitch). " "Rückgabe: Status, Orbit-HTML, Dateien (FLAC 24 bit, MIDI, Analyse), ZIP, Bericht.") CREDITS_MD = (ROOT / "CREDITS.md").read_text(encoding="utf-8") if (ROOT / "CREDITS.md").exists() else reg.CREDITS def build() -> gr.Blocks: with gr.Blocks(title="STΩMs · Absolution Audio Stem Engine", delete_cache=(3600, 24 * 3600)) as demo: ana_state = gr.State(None) job_state = gr.State(None) guest_state = gr.BrowserState([], storage_key="stoms_guest_v1") H(INTRO + HERO, padding=False) # ---------------- 1 · Quelle with gr.Column(elem_id="station-1", elem_classes=["vm-station"]): H(head(1, "Quelle", "Song hochladen – WAV, FLAC, MP3, M4A/AAC, OGG, Opus oder AIFF, bis 10 Minuten und 100 MB.")) upload = gr.File(label="Song", file_count="single", type="filepath", file_types=sorted(aio.ALLOWED_EXT), elem_id="st-upload") ex_btn = gr.Button("CC-Beispiel laden (Josh Woodward · „Half Life“, CC BY 4.0)", variant="secondary", size="sm") up_info = H(status("st-note", "Noch keine Datei.")) goal_html = H("", elem_id="st-goal") quick_go = gr.Button("⚡ Stems trennen", variant="primary", elem_classes=["st-go"], elem_id="st-quick-go") with gr.Accordion("Mehrere Songs auf einmal (Batch, bis 10)", open=False, elem_id="st-batch-acc"): batch_files = gr.File(label="Songs (2–10)", file_count="multiple", type="filepath", file_types=sorted(aio.ALLOWED_EXT), elem_id="st-batch-files") batch_go = gr.Button("Batch trennen → Export", variant="secondary") batch_status = H("") # ---------------- 2 · Modus with gr.Column(elem_id="station-2", elem_classes=["vm-station"]): H(head(2, "Modus", "Schon passend vorausgewählt. Hier kannst du es ändern – musst aber nicht.")) mode = gr.Radio(MODES, value="omega", label="Trenn-Modus", elem_classes=["st-modes"]) mode_info = gr.Markdown(MODE_INFO["omega"]) with gr.Group(visible=False) as g_single: model_key = gr.Dropdown(MODEL_CHOICES, value="kim_voc", label="Modell") with gr.Group(visible=False) as g_ens: ens_key = gr.Dropdown(ENS_CHOICES, value="omega_vocals", label="Ensemble-Preset") ens_custom = gr.Checkbox(False, label="Eigenes Ensemble zusammenstellen") ens_models = gr.Dropdown(ENS_MODEL_CHOICES, multiselect=True, max_choices=8, label="Modelle (2–4, gleicher Ziel-Stem)") with gr.Row(): ens_algo = gr.Dropdown(reg.ALGORITHMS, value="avg_fft", label="Algorithmus") ens_target = gr.Radio(["Vocals", "Instrumental"], value="Vocals", label="Ziel-Stem") with gr.Group(visible=False) as g_chain: chain_key = gr.Dropdown(CHAIN_CHOICES, value="studio_vocals", label="Ketten-Preset") chain_custom = gr.Checkbox(False, label="Eigene Kette bauen (bis 3 Schritte)") with gr.Row(): s1m = gr.Dropdown(MODEL_CHOICES, value="kim_voc", label="Schritt 1 · auf den Mix") with gr.Row(): s2m = gr.Dropdown(MODEL_CHOICES, value="kara2", label="Schritt 2 · Modell") s2i = gr.Dropdown(STEM_INPUTS, value="Vocals", label="Schritt 2 · Eingang") with gr.Row(): s3m = gr.Dropdown([("— kein dritter Schritt —", "")] + MODEL_CHOICES, value="", label="Schritt 3 · Modell") s3i = gr.Dropdown(STEM_INPUTS, value="Lead", label="Schritt 3 · Eingang") with gr.Accordion("Feinheiten", open=False): with gr.Row(): quality = gr.Radio([("Schnell", "schnell"), ("Maximal", "max")], value="schnell", label="Qualität", info="Maximal: mehr Überlappung, Demucs-Shifts ×2, VR-TTA – braucht mehr GPU-Zeit.") bleed = gr.Slider(0, 1, value=0.7, step=0.05, label="Bleed-Killer", info="Wiener-Nachfilter gegen Übersprechen. 0 = aus. Σ Stems bleibt = Mix.") with gr.Row(): midi_on = gr.Checkbox(True, label="MIDI für Gesang, Bass, Melodie (Basic Pitch, CPU)") allow_cpu = gr.Checkbox(True, label="CPU-Notbetrieb erlauben", info="Wenn ZeroGPU nicht verfügbar ist: MDX-Net auf der CPU, höchstens 60 s.") # ---------------- 3 · Trennung with gr.Column(elem_id="station-3", elem_classes=["vm-station"]): H(head(3, "Trennung", "Modelle werden vor dem Laden per SHA-256 geprüft. GPU-Zeit wird pro Stufe exakt angefragt.")) go = gr.Button("Stems trennen", variant="primary", elem_classes=["st-go"], elem_id="st-go") run_status = H(status("st-note", "Bereit."), elem_id="st-run-status") qual_html = H("", elem_id="st-quality") # ---------------- 4 · Orbit with gr.Column(elem_id="station-4", elem_classes=["vm-station"]): H(head(4, "Stem-Orbit", "Jeder Stem ist ein Orb. Klick = Solo · Leertaste = Play · 1–6 = Solo · M = alles stumm.")) orbit = H(jobs.orb_html(None), elem_id="st-orbit-wrap", elem_classes=["st-bare"]) with gr.Row(elem_classes=["st-remix-row"]): ms_rx_go = gr.Button("◎ Orbit-Mix bouncen → Export", size="sm", elem_id="st-remix-go") ms_rx_note = H("", elem_id="st-remix-note") with gr.Accordion("Tempo & Tonart je Stem", open=False): with gr.Row(): rt_tempo = gr.Slider(50, 200, value=100, step=1, label="Tempo (%)") rt_semis = gr.Slider(-12, 12, value=0, step=1, label="Tonart (Halbtöne)") rt_stems = gr.CheckboxGroup([], label="Stems (Drums werden nie transponiert)") rt_go = gr.Button("Anwenden → Export", variant="secondary") rt_status = H("") # ---------------- 5 · Mastering-Studio: ① Quelle → ② Ziel → ③ Messen → ④ Mastern with gr.Column(elem_id="station-5", elem_classes=["vm-station"]): H(head(5, "Mastering-Studio", "Vier Schritte. Gemessen nach ITU-R BS.1770 (LUFS, True Peak) – auf der CPU.")) with gr.Column(elem_id="st-ms-s1", elem_classes=["st-step"]): H('<div class="st-step__h"><b>1</b><span>Quelle</span><small>Was wird gemastert?</small></div>') # Quelle + Mix-JSON außerhalb von Akkordeons: stoms.js schreibt dort hinein (müssen immer im DOM sein). ms_source = gr.Radio(MS_SOURCES, value="mix", show_label=False, elem_id="st-ms-source", elem_classes=["st-seg3"]) ms_mixer = H(_mixer_html([]), elem_id="st-mixer-wrap") ms_stems_json = gr.Textbox("{}", elem_id="st-mixer-json", elem_classes=["st-hidden"], show_label=False) ms_own = gr.File(label="Eigene Datei (WAV, FLAC, MP3 …)", type="filepath", file_types=sorted(aio.ALLOWED_EXT), elem_id="st-ms-own") with gr.Column(elem_id="st-ms-s2", elem_classes=["st-step"]): H('<div class="st-step__h"><b>2</b><span>Ziel</span><small>Wo läuft der Song?</small></div>') ms_preset = gr.Radio(PRESET_CHOICES, value="auto", show_label=False, elem_id="st-ms-preset", elem_classes=["st-cards"]) ms_info = H(preset_info("auto"), elem_id="st-ms-info") with gr.Accordion("Klingt wie … (Referenz-Track, optional)", open=False, elem_id="st-ms-ref"): ms_ref = gr.File(label="Referenz-Track", type="filepath", file_types=sorted(aio.ALLOWED_EXT)) ms_ref_amt = gr.Slider(0, 1, value=0.8, step=0.05, label="Match-Stärke") with gr.Accordion("Feinschliff (Regler, optional)", open=False, elem_id="st-ms-fine"): ms_auto = gr.Checkbox(True, label="Auto: Messung setzt die Regler (empfohlen). Regler anfassen = manuell.") sliders = [gr.Slider(lo, hi, value=d, step=st, label=lab, elem_id=f"ms-{f}") for f, lab, lo, hi, st, d in SLIDERS] with gr.Column(elem_id="st-ms-s3", elem_classes=["st-step"]): H('<div class="st-step__h"><b>3</b><span>Messen</span><small>Ist-Werte + Plan</small></div>') ms_measure = gr.Button("◔ Quelle messen", variant="secondary", elem_id="st-ms-measure") ms_meter = H(_meter_html(None), elem_id="st-ms-meter") with gr.Column(elem_id="st-ms-s4", elem_classes=["st-step"]): H('<div class="st-step__h"><b>4</b><span>Mastern</span><small>Vorher → Nachher · A/B</small></div>') ms_go = gr.Button("✨ Mastern", variant="primary", elem_classes=["st-go"], elem_id="st-master-go") ms_status = H("", elem_id="st-ms-status") ms_ab = H("", elem_id="st-ab-wrap", elem_classes=["st-bare"]) # ---------------- 6 · Export – alles, was entsteht, landet hier with gr.Column(elem_id="station-6", elem_classes=["vm-station"]): H(head(6, "Export", "Alles, was du erzeugst, landet automatisch hier – nach Song sortiert, neueste oben. Gast-Dateien ~24 h.")) exp_zip = gr.Button("▣ Alles als ZIP", variant="primary", elem_id="st-exp-zip") exp_html = H(exports.render(None), elem_id="st-export") with gr.Accordion("Meine Projekte", open=False, elem_id="st-lib"): guest_dd = gr.Dropdown([], label="Zuletzt getrennt (dieser Browser, ~24 h)") guest_open = gr.Button("Öffnen", size="sm", variant="secondary") with gr.Row(): gr.LoginButton("Als Inhaber anmelden", logout_value="Abmelden ({})", size="sm") lib_status = H(status("st-note", "Bibliothek: nur für den Inhaber (HF-Login).")) lib_msg = H("") with gr.Group(elem_classes=["st-owner"]): with gr.Row(): lib_title = gr.Textbox(label="Projektname", scale=3) lib_save_btn = gr.Button("In Bibliothek speichern", scale=1) with gr.Row(): lib_dd = gr.Dropdown([], label="Bibliothek", scale=3) lib_load_btn = gr.Button("Laden", scale=1) with gr.Row(): pr_save = gr.Button("Remix-Presets sichern", size="sm") pr_load = gr.Button("Remix-Presets laden", size="sm") presets_json = gr.Textbox("{}", elem_id="st-presets-json", elem_classes=["st-hidden"], show_label=False) with gr.Accordion("Credits & Lizenzen", open=False, elem_id="st-credits"): gr.Markdown(CREDITS_MD) H('<footer class="st-foot">STΩMs · Absolution Audio · Teil von 2Btainment · ' '<a href="#st-credits" data-open="st-credits">Credits & Lizenzen</a> · ' '<button type="button" class="st-linkbtn" data-keys="1">Tastenkürzel (?)</button></footer>') # ---------------- versteckt: Link-Cheat + God-Mode (kein API-Eintrag) with gr.Column(elem_id="st-cheat", elem_classes=["st-modal"]): H('<div class="st-modal__glitch" aria-hidden="true"></div><h2 class="st-modal__h" id="st-cheat-h">Ω · Link-Portal</h2>' '<p class="st-note">Suno- oder YouTube-Link einfügen, Enter. Mehrere Links (bis 10) oder eine öffentliche ' 'Suno-Playlist/-Profil → Batch.</p>') cheat_in = gr.Textbox(show_label=False, placeholder="https://suno.com/song/… · https://youtu.be/…", lines=2, max_lines=6, elem_id="st-cheat-in", autofocus=False) cheat_go = gr.Button("Laden ↵", variant="primary", elem_id="st-cheat-go") cheat_status = H("", elem_id="st-cheat-status") with gr.Column(elem_id="st-god", elem_classes=["st-modal", "st-modal--god"]): god_gate = H("", elem_id="st-god-gate") H('<h2 class="st-modal__h">God-Mode</h2><p class="st-note">Nur serverseitig geprüft (HF-Login 2Btainment). ' 'Alle Modelle, Songs bis 30 min, Ensembles bis 8 Modelle. ZeroGPU bleibt bei max. 300 s pro Stufe.</p>') god_on = gr.Checkbox(False, label="God-Mode aktiv", elem_id="st-god-on") gr.LoginButton("Als Inhaber anmelden", logout_value="Abmelden ({})", size="sm", elem_id="st-god-login") god_btn = gr.Button("probe", elem_id="st-god-probe", elem_classes=["st-hidden"]) # ---------------- Ereignisse P = dict(api_visibility="private") mode_outs = [up_info, goal_html, ana_state, mode, quality, bleed, model_key, mode_info] upload.change(on_upload, [upload, god_on], mode_outs, show_progress="minimal", **P) ex_btn.click(lambda: EXAMPLE, None, upload, **P) mode.change(on_mode, mode, [g_single, g_ens, g_chain, mode_info], **P) sep_in = [upload, mode, model_key, ens_key, ens_custom, ens_models, ens_algo, ens_target, chain_key, chain_custom, s1m, s2m, s2i, s3m, s3i, quality, allow_cpu, bleed, midi_on, god_on, ana_state] sep_out = [run_status, orbit, job_state, qual_html, exp_html] after_out = [rt_stems, ms_mixer, guest_state, guest_dd] go.click(separate_ui, sep_in, sep_out, concurrency_limit=2, concurrency_id="separate", **P) \ .then(after_job, [job_state, guest_state], after_out, **P) quick_go.click(separate_ui, sep_in, sep_out, concurrency_limit=2, concurrency_id="separate", **P) \ .then(after_job, [job_state, guest_state], after_out, **P) batch_go.click(batch_run, [batch_files, mode, model_key, ens_key, chain_key, quality, allow_cpu, bleed, midi_on, god_on], [batch_status, exp_html], concurrency_limit=1, **P) rt_go.click(retune_ui, [job_state, rt_stems, rt_tempo, rt_semis], [rt_status, exp_html], concurrency_limit=2, **P) ms_rx_go.click(remix_export, [job_state, ms_stems_json], [ms_rx_note, exp_html], concurrency_limit=4, **P) ms_in = [job_state, ms_own, ms_preset, ms_auto, ms_source, ms_stems_json, ms_ref, ms_ref_amt, *sliders] ms_go.click(studio_render, ms_in, [ms_status, ms_ab, ms_meter, exp_html, *sliders], concurrency_limit=3, **P) ms_measure.click(studio_measure, [job_state, ms_own, ms_source, ms_stems_json, ms_preset, ms_auto, ms_ref, ms_ref_amt, *sliders], [ms_status, ms_meter, *sliders], concurrency_limit=3, **P) stale = lambda: _meter_html(None, stale=True) # noqa: E731 ms_preset.change(preset_ui, ms_preset, [ms_info, *sliders], queue=False, show_progress="hidden", **P) ms_preset.input(stale, None, ms_meter, queue=False, show_progress="hidden", **P) ms_source.input(stale, None, ms_meter, queue=False, show_progress="hidden", **P) ms_own.upload(lambda: ("own", _meter_html(None, stale=True)), None, [ms_source, ms_meter], queue=False, **P) for s_ in sliders: # Regler anfassen = manuell s_.release(lambda: False, None, ms_auto, **P) exp_zip.click(export_zip, None, exp_html, concurrency_limit=2, **P).then( None, None, None, js="() => { setTimeout(() => { const a = document.querySelector('#st-export .st-exp__zip'); if (a) a.click(); }, 60); }") demo.unload(_drop_session) cheat_go.click(cheat_fetch, cheat_in, [cheat_status, upload, batch_files], concurrency_limit=2, **P) god_btn.click(god_probe, None, god_gate, **P) lib_load_evt = [lib_msg, orbit, job_state, qual_html, exp_html] demo.load(lib_refresh, None, [lib_status, lib_dd], **P) demo.load(lambda g: _guest_choices(g), guest_state, guest_dd, **P) lib_save_btn.click(lib_save, [job_state, lib_title], lib_msg, **P).then(lib_refresh, None, [lib_status, lib_dd], **P) lib_load_btn.click(lib_load, lib_dd, lib_load_evt, **P).then(after_job, [job_state, guest_state], after_out, **P) guest_open.click(guest_load, [guest_dd, guest_state], lib_load_evt, **P).then(after_job, [job_state, guest_state], after_out, **P) pr_save.click(presets_save, presets_json, [lib_msg, presets_json], **P) pr_load.click(presets_load, presets_json, [lib_msg, presets_json], **P) # Öffentliche API (+ MCP): nur /separate, /master, /analyze api_in_audio = gr.File(visible=False, type="filepath") api_preset = gr.Textbox(visible=False) api_settings = gr.Textbox(visible=False) api_ref = gr.File(visible=False, type="filepath") api_files = gr.File(visible=False, file_count="multiple") api_rep = gr.JSON(visible=False) api_btn_m = gr.Button(visible=False) api_btn_a = gr.Button(visible=False) api_btn_s = gr.Button(visible=False) api_zip = gr.File(visible=False) api_st = gr.HTML(visible=False) api_btn_s.click(separate, sep_in, [api_st, api_files, api_zip, api_rep], api_name="separate", api_description=API_SEPARATE_DOC, concurrency_limit=2, concurrency_id="separate") api_btn_m.click(master, [api_in_audio, api_preset, api_settings, api_ref], [api_files, api_rep], api_name="master", concurrency_limit=2) api_btn_a.click(analyze, api_in_audio, api_rep, api_name="analyze", concurrency_limit=3) return demo demo = build() if __name__ == "__main__": from starlette.middleware import Middleware st = library.status() LOG.info("Bibliothek: %s (Secret %s %s, HF_TOKEN %s) · Rubber Band: %s", "aktiv" if st["active"] else "inaktiv", library.SECRET_NAME, "gesetzt" if os.environ.get(library.SECRET_NAME) else "fehlt", "gesetzt" if os.environ.get("HF_TOKEN") else "fehlt", "ja" if stretch.available() else "nein (Notbehelf librosa)") jobs.start_cleanup() demo.queue(default_concurrency_limit=2, max_size=16).launch( server_name="0.0.0.0", server_port=int(os.environ.get("PORT", "7860")), theme=gr.themes.Base(font=["system-ui", "sans-serif"], font_mono=["ui-monospace", "monospace"]), # keine Google-Fonts (CSP + 2 Render-Blocker weniger) css=CSS, head=HEAD, show_error=False, ssr_mode=False, mcp_server=True, max_file_size="100mb", allowed_paths=[str(ASSETS), str(jobs.OUT_ROOT)], app_kwargs={"middleware": [Middleware(websec.SecurityMiddleware, head_style=CRIT_CSS)]}, )
"""STΩMs – Absolution Audio Stem Engine (Gradio 6 · ZeroGPU).
Standardweg (Einfachheit zuerst): Song hochladen → Ziel wird erkannt und vorausgewählt → ein Klick „Stems trennen“.
Alles Weitere (Modelle, Ensembles, Ketten, Studio-Regler, Tempo/Tonart, Batch, Bibliothek) ist eingeklappt.
"""
from __future__ import annotations
import os
# Gradio 6 SSR kollidiert mit dem HF-Space-Runner → Client-Rendering erzwingen.
os.environ["GRADIO_SSR_MODE"] = "false"
# ZeroGPU-Regel: `import spaces` MUSS vor torch kommen.
try:
import spaces # noqa: F401
except ImportError: # lokal ohne spaces
spaces = None
import html
import json
import math
import re
import logging
import time
from pathlib import Path
from typing import Any
import gradio as gr
from stoms import analysis
from stoms import audio_io as aio
from stoms import engine as eng
from stoms import exports
from stoms import fetchlink
from stoms import jobs
from stoms import library
from stoms import master as M
from stoms import registry as reg
from stoms import stretch
from stoms import studio
from stoms import websec
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
for noisy in ("httpx", "audio_separator", "urllib3", "httpcore"):
logging.getLogger(noisy).setLevel(logging.WARNING)
LOG = logging.getLogger("stoms")
ROOT = Path(__file__).resolve().parent
ASSETS = ROOT / "assets"
gr.set_static_paths([str(ASSETS)])
ASSET_URL = "/gradio_api/file=" + str(ASSETS)
V = "mk11"
CSS = (ASSETS / "stoms.css").read_text(encoding="utf-8").replace("__ASSETS__", ASSET_URL)
# Kritisches CSS direkt im index.html: Gradio hängt `head` erst per JS ein – auf langsamen Netzen würde die App
# kurz ungestylt rendern und dann komplett umbrechen (CLS ≈ 1). Gradio montiert zudem erst leere Stations-Hüllen → unsichtbar, bis Hero und Footer gerendert sind (spätestens nach 8 s).
CRIT_CSS = ("html,body{background:#05080d}gradio-app{visibility:hidden;animation:st-rv 0s 8s forwards}"
"gradio-app:has(.st-hero):has(.st-foot){visibility:visible}@keyframes st-rv{to{visibility:visible}}")
# Gradio scoped `css=` unter `.gradio-container .contain` – Media-Queries, Intro, Dock und Modals brauchen zusätzlich ein
# ungescoptes Stylesheet.
(ASSETS / "stoms.built.css").write_text(CSS, encoding="utf-8")
HEAD = (f'<meta name="color-scheme" content="dark"><meta name="theme-color" content="#05080d">'
f'<meta name="description" content="STΩMs – Stems trennen, mastern, MIDI und Analyse. Absolution Audio · 2Btainment.">'
f'<meta property="og:title" content="STΩMs · Absolution Audio Stem Engine">'
f'<meta property="og:description" content="Ein Song rein, saubere Stems raus – plus Mastering-Studio, MIDI und Tonart/BPM.">'
f'<meta property="og:image" content="{ASSET_URL}/og.png"><meta name="twitter:card" content="summary_large_image">'
f'<link rel="icon" type="image/svg+xml" href="{ASSET_URL}/favicon.svg">'
f'<link rel="preload" as="font" type="font/woff2" crossorigin href="{ASSET_URL}/fonts/Figtree-normal-latin.woff2">'
f'<link rel="preload" as="font" type="font/woff2" crossorigin href="{ASSET_URL}/fonts/Syne-normal-latin.woff2">'
f'<link rel="preload" as="image" href="{ASSET_URL}/abyss-poster.webp" media="(min-width: 761px)">'
f'<link rel="preload" as="image" href="{ASSET_URL}/abyss-poster-sm.webp" media="(max-width: 760px)">'
f'<link rel="stylesheet" href="{ASSET_URL}/stoms.built.css?v={V}">'
f'<script type="module" src="{ASSET_URL}/stoms.js?v={V}"></script>')
EXAMPLE = str(ASSETS / "halflife_josh_woodward.flac")
GOD_MAX_S = 1800.0
def H(*args, **kw) -> gr.HTML:
"""gr.HTML ohne Standard-js_on_load (spart 27 Klick-Listener und Function-Kompilate)."""
kw.setdefault("js_on_load", None)
return gr.HTML(*args, **kw)
LIB_ROOT = jobs.OUT_ROOT / "lib"
def lic_badge(m: dict) -> str:
lic = m.get("license", "")
return "MIT" if lic.startswith("MIT") else "GPL-3.0" if "GPL" in lic else "⚠ Lizenz offen"
MODELS = reg.models()
MODEL_CHOICES = [(f"{m['label']} · {lic_badge(m)}", k) for k, m in MODELS.items()]
ENS = reg.ensembles()
ENS_CHOICES = [(e["name"], k) for k, e in ENS.items()]
CHAIN_CHOICES = [(c["name"], k) for k, c in reg.CHAINS.items()]
ENS_MODEL_CHOICES = [(f"{m['label']} · {lic_badge(m)}", m["file"]) for m in MODELS.values() if m["task"] in ("vocals", "instrumental")]
STEM_INPUTS = ["Mix", "Vocals", "Instrumental", "Lead", "Begleitung", "Drums", "Bass", "Other", "Guitar", "Piano", "Trocken"]
MODES = [("Ω-Modus · Demucs v4 + HPSS + Mix-Check", "omega"), ("Einzelmodell", "single"),
("Ensemble", "ensemble"), ("Kette", "chain")]
PRESET_CHOICES = [(f'{p["label"]} · {p["tag"]}', k) for k, p in M.PRESETS.items()]