"""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''
f''
f''
f''
f''
f''
f''
f''
f''
f''
f''
f'')
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'
')
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'')
bars = "".join(f''
for i, h in enumerate([7, 15, 22, 13, 8]))
pl = ' pathLength="100"' if anim else ""
return (f'')
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''
for i, h in enumerate(hs))
return (f'')
def _ekg() -> str:
# EKG-Linie quer durch die Mitte des Ω (Ruhe – P – QRS – T – Ruhe) + Stern für den einmaligen Glanz
return (''
'')
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'" for d, c, w, o, k in ps)
sparks = "".join(f'' 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'')
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'Ω{_ekg()}' if intro else
f'')
sr = (lambda t: "") if intro else (lambda t: f'{t}')
return (_ribbons(uid) + wavemark(uid + "w", "st-mark st-logo__mark st-neon st-neon--b")
+ f'{sr("ST")}' + om
+ f'{sr("Ms")}')
# Ü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''
f'{html.escape(text)}')
INTRO = f"""
{logo("il", intro=True)}
Absolution Audio · Stem Engine
"""
HERO = """
Absolution Audio · Stem Engine
""" + logo("hl") + """
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.
bis 10 min · 100 MBFLAC 24 bit · MIDI · BerichtMastering auf CPU – keine GPU-VerschwendungTaste ? = Tastenkürzel
'
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'Tonart {html.escape(k["key"])} · {html.escape(k.get("camelot", ""))}')
if a.get("bpm"):
chips.append(f'{a["bpm"]:.0f} BPM')
if a.get("chords_common"):
chips.append(f'Akkorde {html.escape(" · ".join(a["chords_common"][:5]))}')
return (f'
Erkannt: {html.escape(g.get("label", "?"))} '
f'({int(round(100 * g.get("confidence", 0)))} %) {html.escape(g.get("reason", ""))} '
f'Schon vorausgewählt – du musst nur noch trennen. Ändern kannst du alles in Station 2.'
f'
{"".join(chips)}
')
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'
'), _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'
{i + 1}. {r["kind"]} · {m}:{s:02d} min ✓
')
except fetchlink.LinkError as exc:
rows.append(f'
🔒 Nur für den Inhaber. '
'Erst unten mit dem HF-Konto 2Btainment anmelden, dann erneut Strg/⌘ + 9× Ω.
')
# ------------------------------------------------------------------ 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'{_n(before, d)}' if after is None else
f'{_n(before, d)}→{_n(after, d)}')
mark = "" if ok is None else (' ✓' if ok else ' ⚠')
return (f'
'
+ ("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.") + "
")
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'
Gemessen: {html.escape(m["label"])}'
f'{" · mit Referenz" if m.get("ref") else ""}
{tiles}
'
f'
Plan {" · ".join(html.escape(x) for x in plan)}
')
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"