2b-studio / studio /ui_extras.py
2Btainment's picture
2B-Studio: DAW-Studio, neue Modelle (YuE2, TangoFlux, AudioGen, AudioLDM2), Lizenz-Badges, HF-Login, Einswarm Schwarz/Gold
c600f78 verified
Raw History Blame Contribute Delete
15 kB
"""Neue UI-Bausteine für 2B Studio: Verlauf mit Waveforms, Modell-Status-Chips,
Einstellungen wiederverwenden und die Prompt-Vorlagen-Bibliothek.
Bewusst ohne Seiteneffekte auf Adapter/Worker – alles hier liest nur Session,
Registry und Health-Cache.
"""
from __future__ import annotations
from datetime import datetime
from html import escape
from pathlib import Path
from typing import Any
from zoneinfo import ZoneInfo
import numpy as np
from studio.adapters.router import route_id_for_model
from studio.audio_analysis import _read_audio_as_pcm16
from studio.library import ROLE_LABELS
from studio.model_status import _CACHE as HEALTH_CACHE
from studio.registry import ModelRegistry
from studio.state import StudioSession, Track
from studio.templates import (
CATEGORY_LABEL,
FAMILY_LABEL,
KEY_NONE,
TEMPLATE_BY_ID,
PromptTemplate,
TemplateVars,
defaults_for,
family_for,
find_custom,
render_custom,
render_template,
)
# ---------------------------------------------------------------------------
# Waveform-Peaks
# ---------------------------------------------------------------------------
def waveform_peaks(path: str | Path, bars: int = 72) -> list[float]:
"""Normierte Spitzenwerte (0–1) für eine kompakte Waveform-Vorschau."""
try:
channels, _rate, _frames, raw = _read_audio_as_pcm16(Path(path))
data = np.frombuffer(raw, dtype="<i2").astype(np.float32)
if channels > 1:
data = data[: len(data) // channels * channels].reshape(-1, channels).mean(axis=1)
if data.size == 0:
return [0.0] * bars
chunks = np.array_split(np.abs(data), bars)
peaks = np.array([float(c.max()) if c.size else 0.0 for c in chunks])
top = float(peaks.max()) or 1.0
return [round(float(v) / top, 3) for v in peaks]
except Exception: # noqa: BLE001 – Vorschau darf nie den Flow brechen
return [0.0] * bars
def track_peaks(track: Track, bars: int = 72) -> list[float]:
cached = track.metrics.get("peaks")
if isinstance(cached, list) and len(cached) == bars:
return cached
peaks = waveform_peaks(track.path, bars)
track.metrics["peaks"] = peaks
return peaks
def wave_svg(peaks: list[float], css_class: str = "tb-wave") -> str:
n = max(1, len(peaks))
width = n * 4
bars = []
for i, v in enumerate(peaks):
h = max(1.5, v * 30)
bars.append(f'<rect x="{i * 4}" y="{16 - h / 2:.2f}" width="2.4" height="{h:.2f}" rx="1.2"/>')
return (
f'<svg class="{css_class}" viewBox="0 0 {width} 32" preserveAspectRatio="none" '
f'aria-hidden="true" focusable="false">{"".join(bars)}</svg>'
)
# ---------------------------------------------------------------------------
# Verlauf / Bibliothek
# ---------------------------------------------------------------------------
def _fmt_s(seconds: float) -> str:
seconds = max(0, int(round(seconds)))
return f"{seconds // 60}:{seconds % 60:02d}"
def _model_label(track: Track, registry: ModelRegistry) -> str:
if track.role == "upload":
return "Import · lokal"
model_id = str(track.metadata.get("model_id") or "")
if model_id:
try:
return registry.get(model_id).label
except KeyError:
return model_id
return track.engine.split(":")[0]
def history_html(session: StudioSession | None, selected_id: str | None, registry: ModelRegistry,
scope: str = "create") -> str:
tracks = list(session.tracks) if session else []
head = (
'<div class="tb-hist-head"><span class="tb-kicker">Verlauf</span>'
f'<b>{len(tracks)} Take{"s" if len(tracks) != 1 else ""}</b></div>'
)
if not tracks:
return (
f'<section class="tb-history" data-scope="{scope}">{head}'
'<div class="tb-hist-empty"><svg viewBox="0 0 120 40" aria-hidden="true">'
'<path d="M0 20h18l5-9 6 18 6-26 6 30 6-22 5 9h16l4-6 5 12 5-6h32" /></svg>'
"<p><b>Noch keine Takes.</b> Sound beschreiben (oder Vorlage wählen) und "
"<b>▶ Generieren</b> drücken – oder unten eine WAV importieren.</p></div></section>"
)
counters: dict[str, int] = {}
numbers: dict[str, int] = {}
for t in tracks:
counters[t.role] = counters.get(t.role, 0) + 1
numbers[t.id] = counters[t.role]
cards = []
current = selected_id or (session.current_track().id if session and session.current_track() else None)
for t in reversed(tracks):
meta = t.metadata or {}
advanced = meta.get("advanced") if isinstance(meta.get("advanced"), dict) else {}
seed = meta.get("used_seed") or t.metrics.get("used_seed") or t.metrics.get("seed") or advanced.get("seed")
prompt = str(meta.get("genre_style_instruments") or "").strip()
workflow = str(meta.get("workflow") or advanced.get("workflow") or "")
badge = "Remix" if workflow == "smart_remix" else ROLE_LABELS.get(t.role, t.role)
is_current = " is-current" if t.id == current else ""
took = t.metrics.get("duration_ms")
took_txt = f" · {round(int(took) / 1000)} s Rechenzeit" if took else ""
reusable = bool(prompt) and t.role in {"draft"}
short = escape(prompt[:110]) + ("…" if len(prompt) > 110 else "")
prompt_html = f'<span class="tb-take__prompt">{short}</span>' if prompt else ""
reuse_html = '<span class="tb-take__reuse">↺ Einstellungen verfügbar</span>' if reusable else ""
cards.append(
f'<article class="tb-take{is_current}" data-role="{escape(t.role)}">'
f'<button type="button" class="tb-take__pick" data-track-pick="{escape(t.id)}" data-scope="{scope}" '
f'aria-label="Take {escape(badge)} {numbers[t.id]:02d} laden">'
f'<span class="tb-take__top"><span class="tb-badge tb-badge--{escape(t.role)}">{escape(badge)} {numbers[t.id]:02d}</span>'
f'<span class="tb-take__dur">{_fmt_s(t.duration_s)}</span></span>'
f"{wave_svg(track_peaks(t))}"
f'<span class="tb-take__meta"><b>{escape(_model_label(t, registry))}</b>'
f'{f" · Seed {escape(str(seed))}" if seed else ""}{took_txt}</span>'
+ prompt_html
+ "</button>"
+ reuse_html
+ "</article>"
)
return f'<section class="tb-history" data-scope="{scope}">{head}<div class="tb-takes">{"".join(cards)}</div></section>'
def reuse_values(track_id: str | None, session: StudioSession | None) -> dict[str, Any] | None:
"""Einstellungen eines Takes für das Formular (Modell, Felder, Dauer, Seed …)."""
if not session:
return None
track = session.track_by_id(track_id) if track_id else session.current_track()
if track is None:
return None
meta = track.metadata or {}
if not meta.get("genre_style_instruments") and not meta.get("lyrics"):
return None
advanced = meta.get("advanced") if isinstance(meta.get("advanced"), dict) else {}
lyrics = str(meta.get("lyrics") or "")
instrumental = bool(advanced.get("instrumental")) or lyrics.strip().casefold() in {"", "[instrumental]"}
seed = meta.get("used_seed") or track.metrics.get("used_seed") or track.metrics.get("seed") or advanced.get("seed") or 0
studio = advanced.get("studio") if isinstance(advanced.get("studio"), dict) else {}
return {
"model_id": meta.get("model_id"),
"genre": str(meta.get("genre_style_instruments") or ""),
"lyrics": "[Instrumental]" if instrumental else lyrics,
"negative": str(meta.get("negative") or ""),
"instrumental": instrumental,
"duration_s": int(round(float(meta.get("duration_s") or advanced.get("duration_s") or track.duration_s or 12))),
"seed": int(seed) if str(seed).lstrip("-").isdigit() else 0,
"steps": advanced.get("steps"),
"guidance": advanced.get("guidance"),
"studio": {k: str(v) for k, v in studio.items()},
}
# ---------------------------------------------------------------------------
# Modell-Status-Chips
# ---------------------------------------------------------------------------
_BERLIN = ZoneInfo("Europe/Berlin")
_CHIP_STATE = {
"live": ("live", "Live"),
"sleeping": ("sleep", "Schläft · weckt beim Start"),
"paused": ("paused", "Pausiert · im HF-Dashboard neu starten"),
"mock": ("mock", "Demo-Modus · HF_TOKEN fehlt, nur Test-Audio"),
"broken": ("down", "Defekt"),
"unauthorized": ("lock", "Privat · HF_TOKEN fehlt"),
"private-needs-token": ("lock", "Privat · HF_TOKEN fehlt"),
"unreachable": ("down", "Nicht erreichbar"),
}
def model_chips_html(registry: ModelRegistry, selected: str | None = None) -> str:
chips = []
for model in registry.models:
probe = HEALTH_CACHE.get(model.space_ref) if model.space_ref else {"label": "unreachable"}
label = str(probe.get("label"))
if label == "live" and route_id_for_model(model).endswith("-mock"):
label = "mock"
state, text = _CHIP_STATE.get(label, ("down", label))
voc = "🎤" if model.supports_vocals else "♪"
sel = " is-selected" if model.id == selected else ""
chips.append(
f'<span class="tb-mchip tb-mchip--{state}{sel}" title="{escape(model.label)}: {escape(text)} · max. {model.max_duration_s} s">'
f'<i aria-hidden="true"></i>{escape(model.label)}<small>{voc} {model.max_duration_s}s</small><em class="tb-lic tb-lic--{model.license_badge}">{escape(model.license_badge_label)}</em>'
f'<span class="tb-sr"> – {escape(text)}</span></span>'
)
stamp = datetime.now(_BERLIN).strftime("%H:%M")
return (
'<div class="tb-mchips" role="list" aria-label="Modell-Status">'
+ "".join(f'<span role="listitem">{c}</span>' for c in chips)
+ f'<span class="tb-mchips__stamp">Stand {stamp}</span></div>'
)
# ---------------------------------------------------------------------------
# Vorlagen-Bibliothek
# ---------------------------------------------------------------------------
def template_vars(bpm: float, key: str, mood: str, instruments: str, duration: float, vocals: bool,
voice: str, language: str, title: str, extra: str) -> TemplateVars:
return TemplateVars(
bpm=int(bpm or 0), key=key or KEY_NONE, mood=mood or "Neutral", instruments=instruments or "",
duration_s=int(duration or 30), vocals=bool(vocals), voice=voice or "Weiblich",
language=language or "Deutsch", title=title or "", extra=extra or "",
)
def resolve_template(template_id: str | None, custom: list[dict[str, Any]] | None
) -> tuple[PromptTemplate | None, dict[str, Any] | None]:
if not template_id:
return None, None
if template_id in TEMPLATE_BY_ID:
return TEMPLATE_BY_ID[template_id], None
return None, find_custom(template_id, custom)
def render_any(template_id: str | None, custom: list[dict[str, Any]] | None, model_id: str,
tv: TemplateVars, registry: ModelRegistry):
try:
max_s = int(registry.get(model_id).max_duration_s)
except KeyError:
max_s = 180
max_s = max(5, min(600, max_s))
template, own = resolve_template(template_id, custom)
if template is not None:
return template, own, render_template(template, model_id, tv, max_s)
if own is not None:
return None, own, render_custom(own, tv, family_for(model_id), max_s)
return None, None, None
def template_detail_html(template_id: str | None, custom: list[dict[str, Any]] | None, model_id: str,
tv: TemplateVars, registry: ModelRegistry, favorites: list[str] | None) -> str:
template, own, rendered = render_any(template_id, custom, model_id, tv, registry)
if rendered is None:
return (
'<div class="tb-tpl-detail is-empty"><p><b>Vorlage wählen.</b> 30 Vorlagen für Einsatzzwecke, '
"Genres und Sound-FX. Felder anpassen, Vorschau prüfen, dann <b>In Prompt einsetzen</b>.</p></div>"
)
try:
model_label = registry.get(model_id).label
except KeyError:
model_label = model_id
tid = template.id if template else str(own.get("id"))
fav = "★ Favorit" if tid in set(favorites or []) else ""
if template:
title = f"{template.icon} {escape(template.name)}"
cat = CATEGORY_LABEL.get(template.category, "")
desc = escape(template.description)
rec = "".join(
f'<span class="tb-pill{" is-on" if m == model_id else ""}">{escape(_safe_label(registry, m))}</span>'
for m in template.models
)
else:
title = f"✦ {escape(str(own.get('name')))}"
cat = "Eigene Vorlage"
desc = "Im Browser gespeichert. Platzhalter {bpm}, {key}, {mood}, {title}, {instruments} werden ersetzt."
rec = ""
lyr = escape(rendered.lyrics)
notes = "".join(f"<li>{escape(n)}</li>" for n in rendered.notes)
studio = ""
if rendered.studio:
studio = "".join(
f"<div><b>{escape(k.replace('_', ' ').title())}</b><p>{escape(v)}</p></div>"
for k, v in rendered.studio.items()
)
studio = f'<details class="tb-tpl-studio"><summary>MiniMax Structured Caption</summary>{studio}</details>'
return f"""
<div class="tb-tpl-detail">
<div class="tb-tpl-detail__head"><h4>{title}</h4><span class="tb-tag">{escape(cat)}</span>{f'<span class="tb-tag tb-tag--fav">{fav}</span>' if fav else ''}</div>
<p class="tb-tpl-detail__desc">{desc}</p>
{f'<div class="tb-tpl-detail__rec"><span>Empfohlen:</span>{rec}</div>' if rec else ''}
<div class="tb-tpl-preview">
<div class="tb-tpl-preview__head"><span>Vorschau für <b>{escape(model_label)}</b></span><small>{escape(FAMILY_LABEL.get(rendered.family, ''))}</small></div>
<div class="tb-tpl-preview__grid">
<div><b>Sound</b><p>{escape(rendered.genre)}</p></div>
<div><b>Lyrics</b><pre>{lyr}</pre></div>
<div><b>Vermeiden</b><p>{escape(rendered.negative) or '–'}</p></div>
<div><b>Dauer</b><p>{rendered.duration_s} s · {'Instrumental' if rendered.instrumental else 'mit Gesang'}</p></div>
</div>
{studio}
{f'<ul class="tb-tpl-notes">{notes}</ul>' if notes else ''}
</div>
</div>
"""
def _safe_label(registry: ModelRegistry, model_id: str) -> str:
try:
return registry.get(model_id).label
except KeyError:
return model_id
def template_field_defaults(template_id: str | None, custom: list[dict[str, Any]] | None) -> TemplateVars | None:
template, own = resolve_template(template_id, custom)
if template:
return defaults_for(template)
if own:
return TemplateVars(duration_s=int(own.get("duration_s") or 30), vocals=not bool(own.get("instrumental")))
return None