hf-space: rewrite to route through API — removes local ML, fixes P0+P1 UX issues

app.py

@@ -2,343 +2,499 @@
 Signal Loom AI — HuggingFace Spaces App
 =======================================
 Demo surface for Signal Loom AI.
-Structured media-to-intelligence output with transcription, optional diarization, and machine-readable JSON.
-URL ingestion: YouTube (best-effort), TikTok, Instagram, LinkedIn, Google Drive, Dropbox, direct links.
+Routes all transcription through the Signal Loom API — no local ML.
+
+API: http://localhost:18790
+Auth: Bearer token (demo key hardcoded; replace with your own at signalloomai.com)
 
 Author: Aster Vale / Signal Loom AI
 """
 
-import os
-import subprocess
-import tempfile
+import asyncio
+import httpx
 import json
-from pathlib import Path
-
-# ZeroGPU / CPU-only: disable CUDA before importing torch-based modules
-os.environ["CUDA_VISIBLE_DEVICES"] = ""
+import os
+import time
+from typing import Literal
 
-import whisper
+import gradio as gr
 
-try:
-    from pyannote.audio import Pipeline as DiarizationPipeline
-    PYANNOTE_AVAILABLE = True
-except (ImportError, OSError):
-    PYANNOTE_AVAILABLE = False
+# ── Configuration ────────────────────────────────────────────────────────────
+API_BASE_URL = os.environ.get("SIGNAL_LOOM_API_URL", "http://localhost:18790")
+# Demo API key — replace with your own key from signalloomai.com
+API_KEY = os.environ.get("SIGNAL_LOOM_API_KEY", "slo_oEDM0c-d")
+POLL_INTERVAL_SECONDS = 3
+POLL_TIMEOUT_SECONDS = 300  # 5 minutes
+
+HEADERS = {"Authorization": f"Bearer {API_KEY}"}
+
+# Supported formats
+SUPPORTED_EXTENSIONS = [
+    ".mp3", ".wav", ".m4a", ".flac", ".ogg",
+    ".mp4", ".mov", ".mkv", ".avi", ".webm",
+]
+MAX_FILE_SIZE_MB = 500
+
+OUTPUT_FORMAT_OPTIONS = ["txt", "json", "srt", "vtt"]
+
+
+# ── API Client ─────────────────────────────────────────────────────────────────
+
+async def _submit_url(url: str, language: str | None = None) -> str:
+    """Submit a URL for transcription. Returns job_id."""
+    async with httpx.AsyncClient(timeout=60.0, follow_redirects=True) as client:
+        params = {"url": url}
+        if language:
+            params["language"] = language
+        resp = await client.post(
+            f"{API_BASE_URL}/v1/transcribe",
+            headers=HEADERS,
+            data=params,
+        )
+        if resp.status_code == 429:
+            detail = resp.json().get("detail", "Rate limit reached")
+            raise gr.Error(
+                f"Monthly audio minute limit reached. "
+                f"Upgrade at signalloomai.com/#pricing — {detail}"
+            )
+        if resp.status_code == 401 or resp.status_code == 403:
+            raise gr.Error("Invalid API key. This demo's key may have been revoked.")
+        if resp.status_code == 400:
+            raise gr.Error(f"Bad request: {resp.json().get('detail', resp.text)}")
+        resp.raise_for_status()
+        return resp.json()["job_id"]
+
+
+async def _submit_file(file_path: str, language: str | None = None) -> str:
+    """Upload a file for transcription. Returns job_id."""
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        with open(file_path, "rb") as f:
+            files = {"file": (os.path.basename(file_path), f)}
+            data = {}
+            if language:
+                data["language"] = language
+            resp = await client.post(
+                f"{API_BASE_URL}/v1/transcribe",
+                headers=HEADERS,
+                files=files,
+                data=data,
+            )
+        if resp.status_code == 413:
+            raise gr.Error(f"File too large. Maximum size is {MAX_FILE_SIZE_MB}MB.")
+        if resp.status_code == 429:
+            detail = resp.json().get("detail", "Rate limit reached")
+            raise gr.Error(
+                f"Monthly audio minute limit reached. "
+                f"Upgrade at signalloomai.com/#pricing — {detail}"
+            )
+        if resp.status_code == 401 or resp.status_code == 403:
+            raise gr.Error("Invalid API key. This demo's key may have been revoked.")
+        if resp.status_code == 400:
+            raise gr.Error(f"Bad request: {resp.json().get('detail', resp.text)}")
+        resp.raise_for_status()
+        return resp.json()["job_id"]
 
-try:
-    from sentence_transformers import SentenceTransformer
-    TRANSFORMERS_AVAILABLE = True
-except (ImportError, OSError):
-    TRANSFORMERS_AVAILABLE = False
 
-import gradio as gr
+async def _poll_job(job_id: str, status_md, timeout: int = POLL_TIMEOUT_SECONDS):
+    """Poll job status, yielding status strings as it progresses."""
+    start = time.monotonic()
+    interval = POLL_INTERVAL_SECONDS
+    last_status = "unknown"
 
-DEVICE = "cpu"
+    while time.monotonic() - start < timeout:
+        await asyncio.sleep(interval)
 
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            try:
+                resp = await client.get(
+                    f"{API_BASE_URL}/v1/status/{job_id}",
+                    headers=HEADERS,
+                )
+                resp.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code == 404:
+                    raise gr.Error(f"Job {job_id} not found. It may have expired.")
+                raise gr.Error(f"Status check failed: {e}")
+
+        data = resp.json()
+        status = data.get("status", "unknown")
+
+        if status == last_status and status not in ("queued", "processing", "uploaded"):
+            # No meaningful change; keep polling
+            pass
+        last_status = status
+
+        if status == "queued":
+            yield "status_md", "⏳ **Submitted — Queued for processing...**\n\n_Position unknown. Waiting for a worker slot..._", None
+        elif status == "processing":
+            elapsed = int(time.monotonic() - start)
+            language = data.get("language") or "auto-detected"
+            dur = data.get("duration_seconds")
+            dur_str = f", ~{int(dur)}s audio" if dur else ""
+            yield (
+                "status_md",
+                f"🔄 **Processing...** (`{elapsed}s elapsed`)\n\n"
+                f"Model: `{data.get('model', 'whisper-large-v3-turbo')}` | "
+                f"Language: `{language}`{dur_str}\n\n"
+                f"_Polling every {interval}s — typically 1–3 min for short files._",
+                None,
+            )
+            interval = min(interval * 1.2, 8.0)
+        elif status == "completed":
+            # Done — let the result fetch handle the final output
+            return
+        elif status in ("failed", "error"):
+            failure = data.get("failure_code") or data.get("error") or "unknown"
+            raise gr.Error(
+                f"❌ Transcription failed{f' ({failure})' if failure else ''}.\n\n"
+                f"Try a different file/URL, or check signalloomai.com for support."
+            )
+        elif status in ("cancelled", "expired"):
+            raise gr.Error(
+                f"Job {status}. Results are retained for 7 days after completion. "
+                f"Please submit a new transcription."
+            )
+        else:
+            # Unknown / created / uploaded — keep waiting
+            yield (
+                "status_md",
+                f"🔄 **Status: `{status}`** — waiting for processing...\n\n"
+                f"_Still starting up... ({(time.monotonic() - start):.0f}s elapsed)_",
+                None,
+            )
 
-def get_device_display():
-    if DEVICE == "cuda":
-        return "NVIDIA GPU (cloud)"
-    return "CPU"
+    raise gr.Error(
+        f"⏱ Transcription timed out after {timeout}s. "
+        f"The file may be too long or the service is under load. "
+        f"Check job status at signalloomai.com or try again shortly."
+    )
 
 
-# ── URL Downloader ─────────────────────────────────────────────────────────────
-def download_url(url):
-    """
-    Download media from URL using yt-dlp (YouTube, TikTok, Instagram, etc.)
-    or direct httpx for direct file links. Returns (filepath, title_or_error).
-    """
-    import shutil
-    import httpx
+async def _fetch_result(job_id: str) -> dict:
+    """Fetch the final transcript result."""
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp = await client.get(
+            f"{API_BASE_URL}/v1/result/{job_id}",
+            headers=HEADERS,
+        )
+        if resp.status_code == 202:
+            raise gr.Error(f"Job {job_id} returned unexpected 202 (still processing). Try again shortly.")
+        if resp.status_code == 404:
+            raise gr.Error(f"Result for job {job_id} not found. It may have expired.")
+        if resp.status_code == 410:
+            raise gr.Error(f"Result for job {job_id} has expired. Results are retained for 7 days after completion.")
+        resp.raise_for_status()
+        return resp.json()
+
+
+def _build_outputs(result: dict, requested_formats: list[str]) -> dict:
+    """Build the output dict matching the expected format options."""
+    outputs = {}
+
+    transcript = result.get("transcript") or {}
+    raw_text = result.get("raw_text") or ""
+    srt_text = result.get("srt") or ""
+    vtt_text = result.get("vtt") or ""
+
+    # TXT
+    if "txt" in requested_formats:
+        if raw_text:
+            outputs["txt"] = raw_text.strip()
+        elif transcript:
+            # Reconstruct from segments
+            text = " ".join(seg.get("text", "").strip() for seg in transcript.get("segments", []) if seg.get("text"))
+            outputs["txt"] = text.strip()
+        else:
+            outputs["txt"] = raw_text or "(no transcript available)"
+
+    # JSON
+    if "json" in requested_formats:
+        outputs["json"] = {
+            "status": "success",
+            "job_id": result.get("job_id"),
+            "language": transcript.get("language", "unknown") if isinstance(transcript, dict) else "unknown",
+            "duration_seconds": transcript.get("duration_seconds") if isinstance(transcript, dict) else None,
+            "segments": [
+                {
+                    "start_seconds": round(seg.get("start", seg.get("start_time", 0)), 2),
+                    "end_seconds": round(seg.get("end", seg.get("end_time", 0)), 2),
+                    "speaker": seg.get("speaker", "UNKNOWN"),
+                    "text": seg.get("text", "").strip(),
+                }
+                for seg in (transcript.get("segments", []) if isinstance(transcript, dict) else [])
+                if seg.get("text", "").strip()
+            ],
+        }
 
-    yt_path = shutil.which("yt-dlp")
-    if not yt_path:
-        try:
-            suffix = Path(url).suffix or ".mp4"
-            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
-            with httpx.stream("GET", url, timeout=300, follow_redirects=True) as r:
-                r.raise_for_status()
-            tmp.write(r.read())
-            tmp.close()
-            return tmp.name, Path(url).stem or "media"
-        except Exception as e:
-            return None, f"yt-dlp unavailable and direct download failed: {e}"
+    # SRT
+    if "srt" in requested_formats:
+        outputs["srt"] = srt_text
 
-    try:
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".%(ext)s")
-        tmp_path = tmp.name
-        tmp.close()
-        result = subprocess.run(
-            [
-                yt_path,
-                "--no-playlist",
-                "--extract-audio",
-                "--audio-format", "mp3",
-                "--audio-quality", "0",
-                "--js-runtimes", "node,deno",
-                "--extractor-retries", "2",
-                "--fragment-retries", "2",
-                "--output", tmp_path,
-                "--", url,
-            ],
-            capture_output=True, text=True, timeout=600,
-        )
-        if result.returncode != 0:
-            err = (result.stderr or '').strip()
-            lowered = err.lower()
-            if 'sign in to confirm you\'re not a bot' in lowered or 'cookies-from-browser' in lowered or 'cookies' in lowered:
-                return None, (
-                    'YouTube blocked anonymous extraction for this video. '
-                    'Please fall back to direct upload, or use a Google Drive / Dropbox / direct file link instead.'
-                )
-            if 'no supported javascript runtime could be found' in lowered:
-                return None, (
-                    'This source needs a JavaScript runtime for extraction. '
-                    'Please try again shortly, or fall back to direct upload / non-YouTube hosted links.'
-                )
-            return None, f"Download failed: {err}"
-        import glob
-        files = glob.glob(tmp_path.replace(".%(ext)s", "*"))
-        if files:
-            return files[0], Path(files[0]).stem
-        return None, "Download succeeded but no output file found"
-    except subprocess.TimeoutExpired:
-        return None, "Download timed out (10 min limit)"
-    except Exception as e:
-        return None, f"Download error: {e}"
+    # VTT
+    if "vtt" in requested_formats:
+        outputs["vtt"] = vtt_text
 
+    return outputs
 
-# ── Stage 1: Whisper ──────────────────────────────────────────────────────────
-def transcribe(audio_path, model_name="base", language=None):
-    model = whisper.load_model(model_name, device="cpu")
-    options = {}
-    if language:
-        options["language"] = language
-    options["word_timestamps"] = True
-    return model.transcribe(audio_path, **options)
 
+# ── Pipeline (generator — yields (output_key, value, _) for Gradio streaming) ──
 
-# ── Stage 2: Diarization ─────────────────────────────────────────────────────
-def diarize(audio_path, hf_token=None):
-    if not PYANNOTE_AVAILABLE:
-        return None, "pyannote.audio not installed"
-    if not hf_token:
-        return None, "HF token required for diarization"
-    try:
-        import torch
-        pipeline = DiarizationPipeline.from_pretrained(
-            "pyannote/speaker-diarization-3.1",
-            use_auth_token=hf_token,
-        )
-        pipeline.to(torch.device("cpu"))
-        diarization = pipeline(audio_path)
-        segments = []
-        for turn, _, speaker in diarization.itertracks(yield_label=True):
-            segments.append({"start": round(turn.start, 2), "end": round(turn.end, 2), "speaker": speaker})
-        return segments, None
-    except Exception as e:
-        return None, str(e)
-
-
-# ── Output formatters ──────────────────────────────────────────────────────���──
-def format_srt(segments):
-    lines = []
-    for i, seg in enumerate(segments, 1):
-        def ts(s):
-            h, m, sec = int(s // 3600), int((s % 3600) // 60), int(s % 60)
-            ms = int((s % 1) * 1000)
-            return f"{h:02d}:{m:02d}:{sec:02d},{ms:03d}"
-        lines.append(f"{i}\n{ts(seg['start'])} --> {ts(seg['end'])}\n{seg['text'].strip()}\n")
-    return "\n".join(lines)
-
-
-def format_vtt(segments):
-    lines = ["WEBVTT\n"]
-    for seg in segments:
-        def ts(s):
-            h, m, sec = int(s // 3600), int((s % 3600) // 60), int(s % 60)
-            ms = int((s % 1) * 1000)
-            return f"{h:02d}:{m:02d}:{sec:02d}.{ms:03d}"
-        lines.append(f"{ts(seg['start'])} --> {ts(seg['end'])}\n{seg['text'].strip()}\n")
-    return "\n".join(lines)
-
-
-# ── Main pipeline ─────────────────────────────────────────────────────────────
-def run_pipeline(audio_file, url_input, model_size, language, enable_diarization, hf_token, output_formats):
+async def run_pipeline(
+    audio_file: str | None,
+    url_input: str | None,
+    language: str | None,
+    output_formats: list[str],
+) -> tuple:
     """
-    Full transcription pipeline. Accepts file upload OR URL ingestion.
-    Supported URLs: YouTube, TikTok, Instagram, LinkedIn, Google Drive,
-    Dropbox, Box, Digify, and direct file links.
+    Full transcription pipeline via Signal Loom API.
+    Accepts file upload OR URL ingestion. Yields status/outputs for Gradio streaming.
+    Returns tuple: (status_md_text, txt_output, json_output, srt_output, vtt_output)
     """
-    audio_path = None
+    requested_formats = output_formats or ["txt", "json"]
+
+    # ── Step 0: validate inputs ───────────────────────────────────────────────
+    if url_input and url_input.strip():
+        source_label = f"URL"
+    elif audio_file:
+        source_label = f"File: {os.path.basename(audio_file)}"
+        # Check file size (best-effort — actual limit enforced by API)
+        try:
+            size_mb = os.path.getsize(audio_file) / (1024 * 1024)
+            if size_mb > MAX_FILE_SIZE_MB:
+                raise gr.Error(
+                    f"File too large ({size_mb:.0f}MB). Maximum is {MAX_FILE_SIZE_MB}MB.\n\n"
+                    f"For larger files, use signalloomai.com API."
+                )
+        except OSError:
+            pass
+    else:
+        raise gr.Error("Please paste a URL or upload a file first.")
+
+    # ── Step 1: submit ────────────────────────────────────────────────────────
+    yield (
+        "status_md",
+        f"🚀 **Submitting...** `{source_label}`",
+        None, None, None, None,
+    )
+
     try:
-        # Step 1: resolve source
         if url_input and url_input.strip():
-            url = url_input.strip()
-            yield "Downloading media from URL...", {}
-            audio_path, err = download_url(url)
-            if err:
-                yield f"Download failed: {err}", {}
-                return
-            yield "Download complete. Starting transcription...", {}
-        elif audio_file is not None:
-            audio_path = audio_file
+            job_id = await _submit_url(url_input.strip(), language)
+        elif audio_file:
+            job_id = await _submit_file(audio_file, language)
         else:
-            yield "Please upload a file or enter a URL first.", {}
             return
+    except gr.Error:
+        raise
+    except httpx.HTTPStatusError as e:
+        try:
+            detail = e.response.json().get("detail", e.response.text)
+        except Exception:
+            detail = str(e)
+        raise gr.Error(f"Submission failed: {detail}")
+    except Exception as e:
+        raise gr.Error(f"Submission failed: {e}")
+
+    # Immediate acknowledgement state
+    yield (
+        "status_md",
+        f"✅ **Submitted — Transcription in progress...**\n\n"
+        f"Job ID: `{job_id}`\n\n"
+        f"⏱ Processing typically takes 1–3 minutes depending on length.\n\n"
+        f"_Results are not stored long-term — this is a stateless demo._",
+        None, None, None, None,
+    )
 
-        # Step 2: transcribe
-        yield "Transcribing (Whisper MLX on Apple Silicon)...", {}
-        result = transcribe(audio_path, model_name=model_size, language=language or None)
-        segments = result.get("segments", [])
-
-        # Step 3: diarize
-        speakers = None
-        if enable_diarization and PYANNOTE_AVAILABLE:
-            yield "Detecting speakers (pyannote)...", {}
-            speakers, err = diarize(audio_path, hf_token or None)
-            if err:
-                speakers = None
-
-        # Merge speakers
-        if speakers:
-            for seg in segments:
-                start = seg.get("start", 0)
-                end = seg.get("end", start + 1)
-                seg["speaker"] = "UNKNOWN"
-                for sp in speakers:
-                    if sp["start"] <= start < sp["end"] or sp["start"] < end <= sp["end"]:
-                        seg["speaker"] = sp["speaker"]
-                        break
-
-        # Step 4: format outputs
-        outputs = {}
-        if "txt" in output_formats:
-            outputs["TXT Transcript"] = result.get("text", "")
-        if "json" in output_formats:
-            out = {
-                "status": "success",
-                "language": result.get("language", "unknown"),
-                "segments": [
-                    {
-                        "start_seconds": round(s.get("start", 0), 2),
-                        "end_seconds": round(s.get("end", 0), 2),
-                        "speaker": s.get("speaker", "UNKNOWN"),
-                        "text": s.get("text", "").strip(),
-                    }
-                    for s in segments
-                ],
-            }
-            outputs["JSON (Structured)"] = out
-        if "srt" in output_formats:
-            outputs["SRT Subtitles"] = format_srt(segments)
-        if "vtt" in output_formats:
-            outputs["VTT Captions"] = format_vtt(segments)
-
-        diarization_warning = ""
-        if enable_diarization and not speakers:
-            diarization_warning = " | Warning: transcription succeeded, but speaker diarization did not complete"
-        summary = (
-            f"Done. {len(segments)} segments | "
-            f"Language: {result.get('language', 'unknown')} | "
-            f"Speakers: {len(set(s.get('speaker') for s in segments)) if segments else 'N/A'}"
-            f"{diarization_warning}"
-        )
-        yield summary, outputs
+    # ── Step 2: poll ───────────────────────────────────────────────────────────
+    try:
+        async for update in _poll_job(job_id, None):
+            if update is None:
+                continue
+            key, val = update[0], update[1]
+            if key == "status_md":
+                yield val, None, None, None, None, None
+    except gr.Error:
+        raise
+    except Exception as e:
+        raise gr.Error(f"Polling failed: {e}")
 
-    finally:
-        if audio_path and audio_path != audio_file:
-            try:
-                os.unlink(audio_path)
-            except Exception:
-                pass
+    # ── Step 3: fetch result ──────────────────────────────────────────────────
+    yield (
+        "status_md",
+        f"📥 **Fetching transcript...**",
+        None, None, None, None,
+    )
+
+    try:
+        result = await _fetch_result(job_id)
+    except gr.Error:
+        raise
+    except httpx.HTTPStatusError as e:
+        try:
+            detail = e.response.json().get("detail", e.response.text)
+        except Exception:
+            detail = str(e)
+        raise gr.Error(f"Failed to fetch result: {detail}")
+    except Exception as e:
+        raise gr.Error(f"Failed to fetch result: {e}")
+
+    # ── Step 4: format and return ───────────────────────────────────────────────
+    outputs = _build_outputs(result, requested_formats)
+
+    transcript = result.get("transcript") or {}
+    segments = transcript.get("segments", []) if isinstance(transcript, dict) else []
+    num_speakers = len(set(s.get("speaker") for s in segments if s.get("speaker") and s.get("speaker") != "UNKNOWN")) or "N/A"
+    lang = transcript.get("language", "unknown") if isinstance(transcript, dict) else "unknown"
+    dur = transcript.get("duration_seconds") if isinstance(transcript, dict) else None
+
+    summary = (
+        f"✅ **Done!** `{len(segments)}` segments"
+        f" | Lang: `{lang}`"
+        f" | Speakers: `{num_speakers}`"
+        + (f" | Duration: `{int(dur)}s`" if dur else "")
+    )
+    cta = (
+        "\n\n---\n"
+        "🚀 **Want API access?** "
+        "[Get your free key at signalloomai.com](https://signalloomai.com/signup.html) "
+        "— 100 min/month free, no credit card required."
+    )
+
+    yield (
+        "status_md",
+        summary + cta,
+        outputs.get("txt"),
+        outputs.get("json"),
+        outputs.get("srt"),
+        outputs.get("vtt"),
+    )
 
 
 # ── Gradio Interface ─────────────────────────────────────────────────────────
-with gr.Blocks(title="Signal Loom AI", dark=True) as demo:
+
+_DARK_CSS = """
+    /* Dark ambient background */
+    body { background: #0f1117; }
+    /* Minimal dark chrome */
+    .gradio-container { background: transparent; }
+    /* Card-like panels */
+    .panel-box { background: #161b27; border: 1px solid #1e2535; border-radius: 8px; padding: 16px; }
+    /* Status highlight */
+    .status-ready { color: #34d399; font-weight: 600; }
+    .status-processing { color: #fbbf24; font-weight: 600; }
+    .status-error { color: #f87171; font-weight: 600; }
+    /* Compact markdown in output */
+    .json-output pre { font-size: 12px; }
+    /* Links */
+    a { color: #818cf8; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+"""
+
+with gr.Blocks(
+    title="Signal Loom AI",
+    css=_DARK_CSS,
+) as demo:
+
     gr.Markdown(
-        "## Signal Loom AI\n"
-        "**Demo surface for structured media intelligence** — transcription, optional diarization, and machine-readable JSON.\n\n"
-        "Running here on: Hugging Face CPU demo environment\n\n"
-        "**Signal Loom turns audio/video into structured output for AI workflows.** This HF Space is a demo surface. "
-        "For API access, production workflow, and the main product experience, use "
-        "[signalloomai.com](https://signalloomai.com)."
+        "## ✦ Signal Loom AI\n"
+        "**Structured media intelligence — transcription, speaker diarization, and machine-readable output.**\n\n"
+        "⚡ **Powered by Signal Loom API** — MLX Whisper on Apple Silicon.\n\n"
+        "| | |\n"
+        "|---|---|\n"
+        "| **Free tier** | 100 min/month |\n"
+        "| **Output** | TXT · JSON · SRT · VTT |\n"
+        "| **Sources** | YouTube, direct upload, 30+ platforms |\n\n"
+        "📌 **This is a demo surface.** For API access and production use → **[signalloomai.com](https://signalloomai.com)**\n\n"
+        "---\n"
     )
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### Option 1: Paste a URL")
+    with gr.Row(equal_height=False):
+        # ── LEFT: Inputs ────────────────────────────────────────────────────────
+        with gr.Column(scale=1, min_width=320):
+            gr.Markdown("### 🔗 Option 1: Paste a URL")
             gr.Markdown(
-                "*YouTube (best-effort), TikTok, Instagram, LinkedIn, Google Drive, Dropbox, "
-                "Box, Digify, and direct file links*"
-            )
-            gr.Markdown(
-                "<span style='font-size: 12px; color: #888;'>"
-                "Some YouTube videos may require fallback upload due to platform anti-bot protections. "
-                "Non-YouTube links are the most reliable today."
+                "_YouTube, direct links, Google Drive, Dropbox, and more._\n\n"
+                "<span style='font-size: 12px; color: #6b7280;'>"
+                "Note: Some YouTube videos may be blocked by platform anti-bot protections. "
+                "Direct uploads are the most reliable."
                 "</span>"
             )
             url_input = gr.Textbox(
                 label="Media URL",
                 placeholder="https://www.youtube.com/watch?v=...",
-                info="Paste a link — we'll download and transcribe automatically",
                 lines=2,
+                info="We'll download and transcribe automatically",
             )
 
-            gr.Markdown("### Option 2: Upload a File")
-            gr.Markdown("**Demo note:** No Signal Loom account is required for this HF demo. For API keys and product access, use signalloomai.com.")
+            gr.Markdown("### 📁 Option 2: Upload a File")
+            gr.Markdown(
+                f"**Supported:** mp3 · wav · m4a · flac · ogg · mp4 · mov · mkv · avi · webm  \n"
+                f"**Max size:** {MAX_FILE_SIZE_MB}MB  \n"
+                "<span style='font-size: 12px; color: #6b7280;'>"
+                "Results are not stored long-term — stateless demo surface."
+                "</span>"
+            )
             audio_input = gr.File(
-                label="Upload Audio or Video (max 5 GB)",
-                file_types=[".mp3", ".wav", ".m4a", ".flac", ".ogg", ".mp4", ".mov", ".mkv"],
+                label="Upload Audio or Video",
+                file_types=SUPPORTED_EXTENSIONS,
                 type="filepath",
             )
 
-            with gr.Accordion("Options", open=False):
-                model_size = gr.Dropdown(
-                    label="Whisper Model",
-                    choices=["tiny", "base", "small", "medium", "large-v3-turbo", "large"],
-                    value="base",
-                )
+            with gr.Accordion("⚙️ Options", open=False):
                 language = gr.Dropdown(
                     label="Language (auto-detect if blank)",
-                    choices=["en", "es", "fr", "de", "it", "pt", "zh", "ja", "ko", "ar", "ru"],
-                    value=None,
-                )
-                enable_diarization = gr.Checkbox(
-                    label="Speaker Diarization (pyannote)",
-                    value=False,
-                )
-                hf_token = gr.Textbox(
-                    label="HF Token (for diarization)",
-                    type="password",
-                    placeholder="hf_...",
-                    info="Get free token at huggingface.co/settings/tokens",
+                    choices=["", "en", "es", "fr", "de", "it", "pt", "zh", "ja", "ko", "ar", "ru"],
+                    value="",
                 )
                 output_formats = gr.CheckboxGroup(
                     label="Output Formats",
-                    choices=["txt", "json", "srt", "vtt"],
-                    value=["txt", "json", "srt", "vtt"],
+                    choices=OUTPUT_FORMAT_OPTIONS,
+                    value=["txt", "json"],
                 )
 
-            run_btn = gr.Button("Run Transcription", variant="primary")
+            run_btn = gr.Button("▶  Run Transcription", variant="primary", size="lg")
 
-        with gr.Column(scale=2):
-            status = gr.Markdown("**Ready.** Paste a URL or upload a file, then click Run.")
-            outputs = gr.JSON(label="Output")
+        # ── RIGHT: Outputs ──────────────────────────────────────────────────────
+        with gr.Column(scale=2, min_width=400):
+            status_md = gr.Markdown(
+                "**Ready.** Paste a URL or upload a file, then click **Run Transcription**.\n\n"
+                "⏱ Processing typically takes 1–3 minutes depending on length and queue depth.",
+            )
 
-    run_btn.click(
-        fn=run_pipeline,
-        inputs=[audio_input, url_input, model_size, language, enable_diarization, hf_token, output_formats],
-        outputs=[status, outputs],
-    )
+            gr.Markdown("#### 📄 Transcript (TXT)")
+            txt_output = gr.Textbox(label=None, lines=8, interactive=False, show_label=False)
+
+            gr.Markdown("#### 📊 Structured JSON")
+            json_output = gr.JSON(label=None, show_label=False)
+
+            gr.Markdown("#### 📝 Subtitles (SRT)")
+            srt_output = gr.Textbox(label=None, lines=6, interactive=False, show_label=False)
 
+            gr.Markdown("#### 🎬 Captions (VTT)")
+            vtt_output = gr.Textbox(label=None, lines=6, interactive=False, show_label=False)
+
+    # Footer
     gr.Markdown(
         "---\n"
-        "**Signal Loom AI** — *Media In. Machine Intelligence Out.*\n"
-        "This HF Space is a demo surface. Want API access and the main product workflow? "
-        "[Get your free key at signalloomai.com](https://signalloomai.com/signup.html) | "
-        "[Homepage](https://signalloomai.com) | "
+        "**Signal Loom AI** — _Media In. Machine Intelligence Out._  \n"
+        "This HuggingFace Space is a **demo surface**. For full API access, billing, and production use → "
+        "[**signalloomai.com**](https://signalloomai.com) | "
+        "[Get free API key](https://signalloomai.com/signup.html) | "
         "[HuggingFace Org](https://huggingface.co/signalloom-ai)"
     )
 
-demo.launch(max_file_size=5 * 1024 * 1024 * 1024)
+    # ── Event binding ─────────────────────────────────────────────────────────
+    run_btn.click(
+        fn=run_pipeline,
+        inputs=[audio_input, url_input, language, output_formats],
+        outputs=[status_md, txt_output, json_output, srt_output, vtt_output],
+        queue=True,
+        concurrency_limit=None,
+    )
+
+
+# ── Local launch ─────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    import sys
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 18791
+    demo.launch(server_port=port, server_name="0.0.0.0")

requirements.txt

@@ -1,5 +1,2 @@
-openai-whisper
-pyannote.audio>=3.0
-soundfile
-sentence-transformers
-yt-dlp
+httpx>=0.27.0
+gradio>=5.0.0

space.yaml

@@ -0,0 +1,23 @@
+# Signal Loom AI — HuggingFace Spaces Configuration
+# https://huggingface.co/docs/hub/spaces
+
+sdk: gradio
+app_path: app.py
+name: signal-loom-ai
+title: Signal Loom AI
+description: |
+  Structured media intelligence — transcription, speaker diarization, 
+  and machine-readable output (TXT, JSON, SRT, VTT).
+  Powered by Signal Loom API · MLX Whisper on Apple Silicon.
+emoji: 🎙
+color: indigo
+tags:
+  - transcription
+  - whisper
+  - audio
+  - video
+  - diarization
+  - speech-to-text
+  - artificial-intelligence
+  - mlx
+license: apache-2.0