Spaces:
Running
Running
2B-Studio: DAW-Studio, neue Modelle (YuE2, TangoFlux, AudioGen, AudioLDM2), Lizenz-Badges, HF-Login, Einswarm Schwarz/Gold
c600f78 verified Download studio/ui_extras.py from 2Btainment/2b-studio: direct link, hf CLI and curl.
- Browser
- Download file 15 kB
-
https://huggingface.co/spaces/2Btainment/2b-studio/resolve/main/studio/ui_extras.py
- Command line
-
hf download hf://spaces/2Btainment/2b-studio/studio/ui_extras.py
-
curl -L -o ui_extras.py https://huggingface.co/spaces/2Btainment/2b-studio/resolve/main/studio/ui_extras.py
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 | |