"""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=" 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'') return ( f'{"".join(bars)}' ) # --------------------------------------------------------------------------- # 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 = ( '
Verlauf' f'{len(tracks)} Take{"s" if len(tracks) != 1 else ""}
' ) if not tracks: return ( f'
{head}' '
' "

Noch keine Takes. Sound beschreiben (oder Vorlage wählen) und " "▶ Generieren drücken – oder unten eine WAV importieren.

" ) 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'{short}' if prompt else "" reuse_html = '↺ Einstellungen verfügbar' if reusable else "" cards.append( f'
' f'" + reuse_html + "
" ) return f'
{head}
{"".join(cards)}
' 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'' f'{escape(model.label)}{voc} {model.max_duration_s}s{escape(model.license_badge_label)}' f' – {escape(text)}' ) stamp = datetime.now(_BERLIN).strftime("%H:%M") return ( '
' + "".join(f'{c}' for c in chips) + f'Stand {stamp}
' ) # --------------------------------------------------------------------------- # 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 ( '

Vorlage wählen. 30 Vorlagen für Einsatzzwecke, ' "Genres und Sound-FX. Felder anpassen, Vorschau prüfen, dann In Prompt einsetzen.

" ) 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'{escape(_safe_label(registry, m))}' 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"
  • {escape(n)}
  • " for n in rendered.notes) studio = "" if rendered.studio: studio = "".join( f"
    {escape(k.replace('_', ' ').title())}

    {escape(v)}

    " for k, v in rendered.studio.items() ) studio = f'
    MiniMax Structured Caption{studio}
    ' return f"""

    {title}

    {escape(cat)}{f'{fav}' if fav else ''}

    {desc}

    {f'
    Empfohlen:{rec}
    ' if rec else ''}
    Vorschau für {escape(model_label)}{escape(FAMILY_LABEL.get(rendered.family, ''))}
    Sound

    {escape(rendered.genre)}

    Lyrics
    {lyr}
    Vermeiden

    {escape(rendered.negative) or '–'}

    Dauer

    {rendered.duration_s} s · {'Instrumental' if rendered.instrumental else 'mit Gesang'}

    {studio} {f'
      {notes}
    ' if notes else ''}
    """ 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