File size: 15,034 Bytes
d360571
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
87af966
 
d360571
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3c8a257
 
d360571
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
c600f78
d360571
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
"""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