Change to playground

README.md

@@ -1,6 +1,6 @@
 ---
-title: Z Image Turbo
-emoji: 🖼️
+title: HF Model Playground
+emoji: 🤗
 colorFrom: yellow
 colorTo: yellow
 sdk: gradio
@@ -9,4 +9,16 @@ app_file: app.py
 pinned: true
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤗 HuggingFace Model Playground
+
+Enter any HuggingFace model ID — auto-detects the task and adapts the UI.
+
+**Supported tasks:**
+- 💬 Text Generation (chat, completion, translate via prompt)
+- 📝 Summarization
+- 🌐 Translation
+- 🎨 Image Generation (with live step preview)
+- 🔊 Text-to-Speech
+- 🧠 Thinking models (DeepSeek-R1, QwQ)
+
+**Quick-select presets** for popular small models in each category.

app.py

@@ -1,107 +1,161 @@
-import spaces
-import queue
-import threading
-import asyncio
-import io
-import json
-import base64
-import torch
+"""
+HuggingFace Model Playground
+- Input any HF model ID → auto-detects task → shows suitable UI
+- Text gen (chat/completion/translate), summarization, translation, image gen, TTS
+- Thinking model support (DeepSeek-R1, QwQ, etc.)
+- Quick-select presets for popular models
+"""
+import spaces  # MUST be first — signals ZeroGPU to allocate GPU worker
+
 import gradio as gr
-from diffusers import DiffusionPipeline
+import torch
 import os
-from typing import List
-
-# Load the pipeline once at startup (CPU-optimized: float32, attention slicing)
-print("Loading Z-Image-Turbo pipeline...")
-pipe = DiffusionPipeline.from_pretrained(
-    "Tongyi-MAI/Z-Image-Turbo",
-    torch_dtype=torch.float32,
-    low_cpu_mem_usage=True,
+import re
+import json
+import threading
+import queue
+import time
+import traceback
+import numpy as np
+import asyncio
+import sys
+from typing import Optional, Dict, Any, List, Tuple, Generator
+from huggingface_hub import HfApi
+
+from transformers import (
+    AutoConfig, AutoTokenizer, AutoModelForCausalLM, AutoModelForSeq2SeqLM,
+    pipeline as hf_pipeline, set_seed, TextIteratorStreamer
 )
-device = "cpu"
-pipe.to(device)
-pipe.enable_attention_slicing()
-print("Pipeline loaded!")
+from diffusers import DiffusionPipeline
 
-# Global state for cancellation
-_generation_lock = threading.Lock()
-_current_interrupt = None
+# Python 3.10 asyncio cleanup fix: suppress "Invalid file descriptor: -1" on shutdown
+# https://bugs.python.org/issue46370
+if sys.version_info >= (3, 10) and sys.platform == 'linux':
+    try:
+        _cls = asyncio.selector_events.BaseSelectorEventLoop
+        _orig = _cls._close_self_pipe
+        def _safe_close_self_pipe(self):
+            try:
+                _orig(self)
+            except ValueError:
+                pass
+        _cls._close_self_pipe = _safe_close_self_pipe
+    except Exception:
+        pass
 
+torch.set_grad_enabled(False)
 
-def decode_latents(latents):
-    """Decode latents to a PIL image using the same recipe as the pipeline."""
-    l = latents.to(pipe.vae.dtype)
-    scaling_factor = pipe.vae.config.scaling_factor
-    shift_factor = getattr(pipe.vae.config, "shift_factor", 0)
-    l = (l / scaling_factor) + shift_factor
-    with torch.no_grad():
-        image = pipe.vae.decode(l, return_dict=False)[0]
-    return pipe.image_processor.postprocess(image, output_type="pil")[0]
-
-
-def generate_image(prompt, height, width, num_inference_steps, seed, randomize_seed, progress=gr.Progress(track_tqdm=True)):
-    """Generate an image from the given prompt, yielding a preview after each denoising step.
-    Cancels any previous generation automatically.
-    """
-    global _current_interrupt
-
-    # Signal cancellation of previous generation (if any)
-    with _generation_lock:
-        if _current_interrupt is not None:
-            _current_interrupt.set()  # Signal previous thread to stop
-            pipe._interrupt = True    # Diffusers pipeline respects this flag
-        # Create new interrupt event for this generation
-        _current_interrupt = threading.Event()
-        pipe._interrupt = False
+# ── GPU Workers (must be module-level @spaces.GPU) ──
 
-    interrupt_event = _current_interrupt
+@spaces.GPU
+def gpu_text_generate(model_id: str, messages: list, gen_kwargs: dict):
+    """Text generation on GPU. Model is cached in the GPU worker across calls."""
+    import torch as _torch
+    from transformers import AutoModelForCausalLM as _AutoModelForCausalLM
+    from transformers import AutoTokenizer as _AutoTokenizer
+    from transformers import TextIteratorStreamer as _TextIteratorStreamer
+    from threading import Thread as _Thread
+
+    cache = gpu_text_generate.__dict__.setdefault('_cache', {})
+    if model_id not in cache:
+        tok = _AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+        if tok.pad_token is None:
+            tok.pad_token = tok.eos_token
+        model = _AutoModelForCausalLM.from_pretrained(
+            model_id, torch_dtype=_torch.bfloat16, device_map="auto",
+            low_cpu_mem_usage=True, trust_remote_code=True,
+        )
+        model.eval()
+        cache[model_id] = (model, tok)
 
-    if randomize_seed:
-        seed = torch.randint(0, 2**32 - 1, (1,)).item()
+    model, tokenizer = cache[model_id]
+    prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    streamer = _TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+    kw = {**gen_kwargs, "streamer": streamer}
+    _Thread(target=model.generate, args=(inputs.input_ids,), kwargs=kw).start()
+    for text in streamer:
+        yield text
 
-    generator = torch.Generator(device).manual_seed(int(seed))
 
-    previews = queue.Queue()
+@spaces.GPU
+def gpu_image_generate(model_id: str, prompt: str, height: int, width: int, steps: int, seed: int):
+    """Image generation on GPU."""
+    import torch as _torch
+    from diffusers import DiffusionPipeline as _DP
+
+    pipe = _DP.from_pretrained(
+        model_id, torch_dtype=_torch.bfloat16, low_cpu_mem_usage=True,
+    )
+    pipe.to("cuda")
+    if hasattr(pipe, "enable_attention_slicing"):
+        pipe.enable_attention_slicing()
+    gen = _torch.Generator("cuda").manual_seed(seed)
+    result = pipe(prompt=prompt, height=height, width=width,
+                  num_inference_steps=steps, generator=gen)
+    return result.images[0]
+
+
+@spaces.GPU
+def gpu_image_generate_stream(model_id: str, prompt: str, height: int, width: int,
+                               steps: int, seed: int):
+    """Image generation on GPU with step-by-step preview."""
+    import torch as _torch
+    from diffusers import DiffusionPipeline as _DP
+    from PIL import Image as _Image
+    import io as _io
+    import queue as _queue
+    import threading as _threading
+
+    pipe = _DP.from_pretrained(
+        model_id, torch_dtype=_torch.bfloat16, low_cpu_mem_usage=True,
+    )
+    pipe.to("cuda")
+    if hasattr(pipe, "enable_attention_slicing"):
+        pipe.enable_attention_slicing()
+
+    has_vae = hasattr(pipe, "vae") and hasattr(pipe, "image_processor")
+    gen = _torch.Generator("cuda").manual_seed(seed)
+    previews = _queue.Queue()
     step_counter = {"i": 0}
 
-    def callback_on_step_end(pipe, i, t, callback_kwargs):
-        # Check for cancellation at each step
-        if interrupt_event.is_set():
-            raise InterruptedError("Generation cancelled by user")
+    def decode_latents(latents):
+        l = latents.to(pipe.vae.dtype)
+        sf = pipe.vae.config.scaling_factor
+        sh = getattr(pipe.vae.config, "shift_factor", None) or 0
+        l = (l / sf) + sh
+        with _torch.no_grad():
+            img = pipe.vae.decode(l, return_dict=False)[0]
+        return pipe.image_processor.postprocess(img, output_type="pil")[0]
+
+    def cb(pipe, i, t, kw):
         step_counter["i"] += 1
-        latents = callback_kwargs["latents"]
-        img = decode_latents(latents)
-        previews.put((img, step_counter["i"]))
-        return callback_kwargs
+        if has_vae and "latents" in kw:
+            try:
+                previews.put((decode_latents(kw["latents"]), step_counter["i"]))
+            except Exception:
+                pass
+        return kw
 
     result = {}
-    thread_exc = {}
+    exc = {}
 
     def run():
         try:
-            out = pipe(
-                prompt=prompt,
-                height=int(height),
-                width=int(width),
-                num_inference_steps=int(num_inference_steps),
-                guidance_scale=0.0,
-                generator=generator,
-                output_type="latent",
-                callback_on_step_end=callback_on_step_end,
-                callback_on_step_end_tensor_inputs=["latents"],
-            )
-            if not interrupt_event.is_set():
-                # Keep batch dim: out.images is [1, C, H, W], not [0] which gives [C, H, W]
-                final = decode_latents(out.images)
-                result["final"] = final
-            previews.put(None)  # sentinel: done
+            kw = dict(prompt=prompt, height=height, width=width,
+                      num_inference_steps=steps, generator=gen)
+            if has_vae:
+                kw["output_type"] = "latent"
+                kw["callback_on_step_end"] = cb
+                kw["callback_on_step_end_tensor_inputs"] = ["latents"]
+            out = pipe(**kw)
+            result["img"] = decode_latents(out.images) if has_vae else out.images[0]
+            previews.put(None)
         except Exception as e:
-            thread_exc["exc"] = e
+            exc["e"] = e
             previews.put(None)
 
-    thread = threading.Thread(target=run)
-    thread.start()
-
+    _threading.Thread(target=run).start()
     last = None
     while True:
         item = previews.get()
@@ -109,587 +163,1119 @@ def generate_image(prompt, height, width, num_inference_steps, seed, randomize_s
             break
         img, step = item
         last = img
-        yield img, seed, f"Step {step} / {int(num_inference_steps)}"
+        yield img, seed, f"Step {step}/{steps}"
+
+    if "e" in exc:
+        raise exc["e"]
+    yield result.get("img", last), seed, f"Done ({steps} steps)"
+
+
+_gpu_flag = False
+_cancel_flag = [False]
+
+def _use_gpu() -> bool:
+    return _gpu_flag
+
+def _set_gpu_flag(val: bool):
+    global _gpu_flag
+    _gpu_flag = val
+
+# ============================================================
+# CONSTANTS
+# ============================================================
+
+
+ARCH_TASK_MAP: Dict[str, str] = {
+    "LlamaForCausalLM": "text-generation",
+    "GPT2LMHeadModel": "text-generation",
+    "PhiForCausalLM": "text-generation",
+    "Phi3ForCausalLM": "text-generation",
+    "Phi3SmallForCausalLM": "text-generation",
+    "GemmaForCausalLM": "text-generation",
+    "Gemma2ForCausalLM": "text-generation",
+    "Gemma3ForCausalLM": "text-generation",
+    "Qwen2ForCausalLM": "text-generation",
+    "Qwen2MoeForCausalLM": "text-generation",
+    "MistralForCausalLM": "text-generation",
+    "MixtralForCausalLM": "text-generation",
+    "OPTForCausalLM": "text-generation",
+    "BloomForCausalLM": "text-generation",
+    "StableLmForCausalLM": "text-generation",
+    "FalconForCausalLM": "text-generation",
+    "GPTNeoXForCausalLM": "text-generation",
+    "DeepseekForCausalLM": "text-generation",
+    "DeepseekV2ForCausalLM": "text-generation",
+    "DeepseekV3ForCausalLM": "text-generation",
+    "OlmoForCausalLM": "text-generation",
+    "CohereForCausalLM": "text-generation",
+    "DbrxForCausalLM": "text-generation",
+    "MptForCausalLM": "text-generation",
+    "Starcoder2ForCausalLM": "text-generation",
+    "XGLMForCausalLM": "text-generation",
+    "PhiMoEForCausalLM": "text-generation",
+    "GraniteForCausalLM": "text-generation",
+    "GraniteMoeForCausalLM": "text-generation",
+    "ExaoneForCausalLM": "text-generation",
+    "RWForCausalLM": "text-generation",
+    "LlavaForConditionalGeneration": "text-generation",
+    "Qwen2VLForConditionalGeneration": "text-generation",
+    "T5ForConditionalGeneration": "text2text-generation",
+    "FlanT5ForConditionalGeneration": "text2text-generation",
+    "BartForConditionalGeneration": "summarization",
+    "PegasusForConditionalGeneration": "summarization",
+    "LongT5ForConditionalGeneration": "summarization",
+    "LEDForConditionalGeneration": "summarization",
+    "MarianMTModel": "translation",
+    "M2M100ForConditionalGeneration": "translation",
+    "NLLBForConditionalGeneration": "translation",
+    "NLLBMoeForConditionalGeneration": "translation",
+}
+
+DIFFUSION_ARCHS = {
+    "StableDiffusionPipeline", "StableDiffusionXLPipeline", "FluxPipeline",
+    "FluxFillPipeline", "LatentConsistencyModelPipeline",
+    "StableDiffusion3Pipeline", "WuerstchenPipeline",
+    "KandinskyPipeline", "KandinskyV22Pipeline",
+    "PixArtAlphaPipeline", "PixArtSigmaPipeline",
+    "StableCascadeCombinedPipeline", "CogView4Pipeline",
+}
+
+TTS_ARCHS = {
+    "SpeechT5ForTextToSpeech", "BarkModel", "BarkCausalModel",
+    "VitsModel", "MmsTextToSpeech", "MusicgenForConditionalGeneration",
+}
+
+THINKING_PATTERNS = [re.compile(p) for p in [
+    r"deepseek.*r1", r"qwq", r"thinking", r"reasoning", r"r1-distill",
+]]
+
+PIPELINE_TAG_MAP = {
+    "text-generation": "text-generation",
+    "text2text-generation": "text2text-generation",
+    "summarization": "summarization",
+    "translation": "translation",
+    "text-to-image": "image-generation",
+    "image-to-image": "image-generation",
+    "image-segmentation": "image-generation",
+    "text-to-speech": "text-to-speech",
+    "fill-mask": "text-generation",
+    "feature-extraction": "text-generation",
+}
+
+TASK_UI_ORDER = ["text-generation", "text2text-generation", "summarization",
+                 "translation", "image-generation", "text-to-speech"]
+
+# ============================================================
+# MODEL STATE
+# ============================================================
+
+_model_lock = threading.Lock()
+_state = {
+    "model_id": None, "task": None, "pipeline": None,
+    "tokenizer": None, "model": None, "config": None,
+    "processor": None, "vocoder": None, "is_thinking": False,
+    "model_info": None, "device": "cpu",
+}
+
+
+def _is_thinking(model_id: str) -> bool:
+    return any(p.search(model_id.lower()) for p in THINKING_PATTERNS)
+
+
+def _clear_state():
+    for k in list(_state.keys()):
+        v = _state[k]
+        if v is not None and hasattr(v, "__del__"):
+            try:
+                del v
+            except Exception:
+                pass
+        _state[k] = None
+    _state["model_id"] = None
+    _state["is_thinking"] = False
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+# ============================================================
+# MODEL DETECTION
+# ============================================================
+
+def detect_task(model_id: str) -> str:
+    try:
+        info = HfApi().model_info(model_id, timeout=10)
+        _state["model_info"] = info
+        tag = info.pipeline_tag
+        if tag and tag in PIPELINE_TAG_MAP:
+            return PIPELINE_TAG_MAP[tag]
+    except Exception:
+        pass
+    try:
+        config = AutoConfig.from_pretrained(model_id, trust_remote_code=True)
+        _state["config"] = config
+        archs = config.architectures or []
+        for arch in archs:
+            if arch in ARCH_TASK_MAP:
+                return ARCH_TASK_MAP[arch]
+            if arch in DIFFUSION_ARCHS:
+                return "image-generation"
+            if arch in TTS_ARCHS:
+                return "text-to-speech"
+        mt = getattr(config, "model_type", "")
+        if mt in ("llama", "gpt2", "phi", "phi3", "gemma", "gemma2",
+                  "qwen2", "mistral", "mixtral", "opt", "bloom",
+                  "falcon", "gpt_neox", "deepseek", "olmo", "cohere",
+                  "stablelm", "mpt", "starcoder2", "exaone", "dbrx"):
+            return "text-generation"
+        if mt in ("t5", "mt5", "bart", "pegasus", "longt5", "led"):
+            return "text2text-generation"
+        if mt in ("marian", "m2m_100", "nllb"):
+            return "translation"
+        if mt in ("speecht5", "bark", "vits", "mms"):
+            return "text-to-speech"
+    except Exception:
+        pass
+    # Diffusers fallback: check model_index.json (hallmark of diffusers pipelines)
+    try:
+        from huggingface_hub import hf_hub_url
+        import requests as _req
+        r = _req.get(hf_hub_url(model_id, "model_index.json"), timeout=5)
+        if r.status_code == 200:
+            return "image-generation"
+    except Exception:
+        pass
+    return "text-generation"
+
+
+# ============================================================
+# MODEL LOADING
+# ============================================================
+
+def load_model(model_id: str, progress=gr.Progress()):
+    with _model_lock:
+        if _state["model_id"] == model_id and _state["model"] is not None:
+            return _build_load_result()
+        _clear_state()
+
+        progress(0, desc="Detecting model type...")
+        task = detect_task(model_id)
+        is_thinking = _is_thinking(model_id)
+
+        try:
+            if task in ("text-generation", "text2text-generation", "summarization", "translation"):
+                _load_text_model(model_id, task, progress)
+            elif task == "image-generation":
+                _load_image_model(model_id, progress)
+            elif task == "text-to-speech":
+                _load_tts_model(model_id, progress)
+            else:
+                _load_text_model(model_id, "text-generation", progress)
+
+            _state["task"] = task
+            _state["is_thinking"] = is_thinking
+            _state["model_id"] = model_id
+        except Exception as e:
+            _clear_state()
+            raise gr.Error(f"Load failed: {e}\n{traceback.format_exc()}")
+
+    return _build_load_result()
+
+
+def _build_load_result():
+    info = _state["model_info"]
+    parts = []
+    if info:
+        if getattr(info, "author", None):
+            parts.append(f"**Author:** {info.author}")
+        if getattr(info, "pipeline_tag", None):
+            parts.append(f"**Task:** {info.pipeline_tag}")
+    parts.append(f"**Detected:** {_state['task']}")
+    if _state["is_thinking"]:
+        parts.append("🧠 **Thinking Model**")
+    return _state["task"], _state["is_thinking"], " · ".join(parts)
+
+
+def _load_text_model(model_id: str, task: str, progress):
+    progress(0.2, desc="Loading tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    progress(0.4, desc="Loading model...")
+    if task == "text-generation":
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id, torch_dtype=torch.bfloat16,
+            low_cpu_mem_usage=True, trust_remote_code=True,
+        )
+    else:
+        model = AutoModelForSeq2SeqLM.from_pretrained(
+            model_id, torch_dtype=torch.bfloat16,
+            low_cpu_mem_usage=True, trust_remote_code=True,
+        )
+
+    # Always load on CPU for the fallback path.
+    # GPU inference goes through @spaces.GPU workers which handle CUDA internally.
+    model.to("cpu")
+    model.eval()
+
+    progress(0.8, desc="Ready!")
+    _state["model"] = model
+    _state["tokenizer"] = tokenizer
+    _state["device"] = "cpu"
+
+
+def _load_image_model(model_id: str, progress):
+    progress(0.3, desc="Loading image model...")
+    pipe = DiffusionPipeline.from_pretrained(
+        model_id, torch_dtype=torch.bfloat16, low_cpu_mem_usage=True,
+    )
+    pipe.to("cpu")
+    pipe.enable_attention_slicing()
+    progress(0.8, desc="Ready!")
+    _state["pipeline"] = pipe
+    _state["device"] = "cpu"
+
+
+def _load_tts_model(model_id: str, progress):
+    import torch as _torch
+    if "speecht5" in model_id.lower():
+        progress(0.3, desc="Loading SpeechT5 model...")
+        from transformers import AutoTokenizer as _AT
+        from transformers import SpeechT5ForTextToSpeech as _SFTTS
+        tokenizer = _AT.from_pretrained(model_id)
+        model = _SFTTS.from_pretrained(model_id)
+        model.eval()
+        progress(0.5, desc="Loading speaker embedding...")
+        speaker_embeddings = None
+        try:
+            from datasets import load_dataset as _load_ds
+            emb_ds = _load_ds("Matthijs/cmu-arctic-xvectors", split="training")
+            speaker_embeddings = _torch.tensor(emb_ds[7306]["xvector"]).unsqueeze(0)
+        except Exception:
+            speaker_embeddings = _torch.zeros((1, 512))
+        progress(0.8, desc="Ready!")
+        _state["model"] = model
+        _state["tokenizer"] = tokenizer
+        _state["speaker_embeddings"] = speaker_embeddings
+        _state["pipeline"] = None
+        _state["device"] = "cpu"
+    else:
+        progress(0.3, desc="Loading TTS model...")
+        pipe = hf_pipeline("text-to-speech", model=model_id, device=-1)
+        progress(0.8, desc="Ready!")
+        _state["pipeline"] = pipe
+        _state["device"] = "cpu"
+
+
+# ============================================================
+# GENERATION HELPERS
+# ============================================================
+
+def _gen_kwargs(max_tokens, temperature, top_p, top_k, repetition, sample):
+    return {
+        "max_new_tokens": int(max_tokens),
+        "temperature": float(temperature),
+        "top_p": float(top_p),
+        "top_k": int(top_k) if top_k > 0 else None,
+        "repetition_penalty": float(repetition),
+        "do_sample": bool(sample),
+}
+
+PRESET_CHOICES = [
+    ("💬 gemma-3-1b-it", "google/gemma-3-1b-it"),
+    ("💬 Qwen3-4B-Instruct", "Qwen/Qwen3-4B-Instruct-2507"),
+    ("💬 Phi-4-mini", "microsoft/Phi-4-mini-instruct"),
+    ("💬 SmolLM3-3B", "HuggingFaceTB/SmolLM3-3B"),
+    ("💬 Qwen2.5-3B", "Qwen/Qwen2.5-3B-Instruct"),
+    ("💬 LFM2.5-1.2B", "LiquidAI/LFM2.5-1.2B-Instruct"),
+    ("🧠 DeepSeek-R1-1.5B", "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"),
+    ("🧠 Qwen3-4B-Thinking", "Qwen/Qwen3-4B-Thinking-2507"),
+    ("🧠 Gemma-2-2B", "google/gemma-2-2b-it"),
+    ("🧠 LFM2.5-1.2B-Thinking", "LiquidAI/LFM2.5-1.2B-Thinking"),
+    ("🔤 FLAN-T5-Small", "google/flan-t5-small"),
+    ("🔤 FLAN-T5-Base", "google/flan-t5-base"),
+    ("📝 BART-Large-CNN", "facebook/bart-large-cnn"),
+    ("🌐 OPUS-EN→ES", "Helsinki-NLP/opus-mt-en-es"),
+    ("🌐 OPUS-EN→FR", "Helsinki-NLP/opus-mt-en-fr"),
+    ("🌐 NLLB-600M", "facebook/nllb-200-distilled-600M"),
+    ("🎨 Z-Image-Turbo", "Tongyi-MAI/Z-Image-Turbo"),
+    ("🎨 SD1.5", "runwayml/stable-diffusion-v1-5"),
+    ("🎨 SDXL-Turbo", "stabilityai/sdxl-turbo"),
+    ("🔊 SpeechT5", "microsoft/speecht5_tts"),
+    ("🔊 Bark-Small", "suno/bark-small"),
+    ("🔊 MMS-TTS-ENG", "facebook/mms-tts-eng"),
+    ("🔊 Bark", "suno/bark"),
+]
+
+
+def _apply_template(tokenizer, messages, is_thinking=False):
+    try:
+        kwargs = {"tokenize": False, "add_generation_prompt": True}
+        if is_thinking:
+            try:
+                kwargs["enable_thinking"] = True
+            except TypeError:
+                pass
+        return tokenizer.apply_chat_template(messages, **kwargs)
+    except Exception:
+        return messages[-1]["content"]
+
+
+def _stream(model, tokenizer, prompt, kwargs):
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+    kwargs["streamer"] = streamer
+    t = threading.Thread(target=model.generate, args=(inputs.input_ids,), kwargs=kwargs)
+    t.start()
+    for text in streamer:
+        yield text
+
+
+# ============================================================
+# INFERENCE FUNCTIONS
+# ============================================================
+
+def _build_messages(history, message, system_prompt):
+    msgs = [{"role": "system", "content": system_prompt or "You are a helpful assistant."}]
+    if history:
+        msgs.extend(history)
+    msgs.append({"role": "user", "content": message})
+    return msgs
+
+
+def chat_respond(message, history, system_prompt, max_tokens, temperature,
+                 top_p, top_k, repetition, sample, thinking):
+    s = _state
+    if s["model"] is None:
+        raise gr.Error("No model loaded.")
+    history = history or []
+    is_thinking = thinking if thinking is not None else s["is_thinking"]
+    msgs = _build_messages(history, message, system_prompt)
+    kwargs = _gen_kwargs(max_tokens, temperature, top_p, top_k, repetition, sample)
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": ""})
+
+    if _use_gpu() and s["task"] == "text-generation":
+        for chunk in gpu_text_generate(s["model_id"], msgs, kwargs):
+            history[-1]["content"] = chunk
+            yield history, ""
+    else:
+        prompt = _apply_template(s["tokenizer"], msgs, is_thinking)
+        full = ""
+        for chunk in _stream(s["model"], s["tokenizer"], prompt, kwargs):
+            full += chunk
+            history[-1]["content"] = full
+            yield history, ""
+    yield history, ""
+
+
+def completion_fn(prompt, max_tokens, temperature,
+                  top_p, top_k, repetition, sample, thinking):
+    s = _state
+    if s["model"] is None:
+        raise gr.Error("No model loaded.")
+    kwargs = _gen_kwargs(max_tokens, temperature, top_p, top_k, repetition, sample)
+    _cancel_flag[0] = False
+
+    if _use_gpu() and s["task"] == "text-generation":
+        msgs = [{"role": "user", "content": prompt}]
+        full = prompt + "\n"
+        for chunk in gpu_text_generate(s["model_id"], msgs, kwargs):
+            if _cancel_flag[0]:
+                break
+            full += chunk
+            yield full
+    else:
+        full = prompt
+        for chunk in _stream(s["model"], s["tokenizer"], prompt, kwargs):
+            if _cancel_flag[0]:
+                break
+            full += chunk
+            yield full
+
+
+def translate_fn(text, src_lang, tgt_lang, max_tokens, temperature,
+                 top_p, top_k, repetition, sample, thinking):
+    s = _state
+    if s["model"] is None:
+        raise gr.Error("No model loaded.")
+    is_thinking = thinking if thinking is not None else s["is_thinking"]
+    kwargs = _gen_kwargs(max_tokens, temperature, top_p, top_k, repetition, sample)
+
+    if _use_gpu() and s["task"] == "text-generation":
+        sp = f"Translate {src_lang} to {tgt_lang}. Output only the translation."
+        msgs = [{"role": "system", "content": sp}, {"role": "user", "content": text}]
+        for chunk in gpu_text_generate(s["model_id"], msgs, kwargs):
+            yield chunk
+        return
+
+    if s["task"] == "translation":
+        prompt = text
+    else:
+        sp = f"Translate {src_lang} to {tgt_lang}. Output only the translation."
+        if s["tokenizer"].chat_template:
+            msgs = [{"role": "system", "content": sp}, {"role": "user", "content": text}]
+            prompt = _apply_template(s["tokenizer"], msgs, is_thinking)
+        else:
+            prompt = f"{sp}\n\n{text}"
+    full = ""
+    for chunk in _stream(s["model"], s["tokenizer"], prompt, kwargs):
+        full += chunk
+        yield full
+
+
+def summarize_fn(text, max_tokens, temperature, top_p, top_k, repetition, sample):
+    s = _state
+    if s["model"] is None:
+        raise gr.Error("No model loaded.")
+    kwargs = _gen_kwargs(max_tokens, temperature, top_p, top_k, repetition, sample)
+    if s["tokenizer"].chat_template:
+        msgs = [{"role": "user", "content": f"Summarize:\n\n{text}"}]
+        prompt = _apply_template(s["tokenizer"], msgs)
+    else:
+        prompt = f"Summarize the following:\n\n{text}\n\nSummary:"
+    full = ""
+    for chunk in _stream(s["model"], s["tokenizer"], prompt, kwargs):
+        full += chunk
+        yield full
+
+
+# --- Image Generation ---
+
+_img_lock = threading.Lock()
+_img_interrupt = None
+
+
+def _decode_latents(latents, pipe):
+    l = latents.to(pipe.vae.dtype)
+    sf = pipe.vae.config.scaling_factor
+    sh = getattr(pipe.vae.config, "shift_factor", None) or 0
+    l = (l / sf) + sh
+    with torch.no_grad():
+        img = pipe.vae.decode(l, return_dict=False)[0]
+    return pipe.image_processor.postprocess(img, output_type="pil")[0]
+
+
+def generate_image(prompt, height, width, steps, seed, randomize, progress=gr.Progress(track_tqdm=True)):
+    global _img_interrupt
+    s = _state
+    model_id = s["model_id"]
+
+    if _use_gpu() and model_id:
+        if randomize:
+            seed = torch.randint(0, 2**32 - 1, (1,)).item()
+        for img, used_seed, status in gpu_image_generate_stream(
+            model_id, prompt, int(height), int(width), int(steps), int(seed),
+        ):
+            yield img, used_seed, status
+        return
+
+    pipe = s.get("pipeline")
+    if pipe is None:
+        raise gr.Error("No image model loaded.")
+
+    with _img_lock:
+        if _img_interrupt is not None:
+            _img_interrupt.set()
+            pipe._interrupt = True
+        _img_interrupt = threading.Event()
+        pipe._interrupt = False
+
+    ev = _img_interrupt
+    if randomize:
+        seed = torch.randint(0, 2**32 - 1, (1,)).item()
+    gen = torch.Generator(device=s["device"]).manual_seed(int(seed))
+
+    has_preview = hasattr(pipe, "vae") and hasattr(pipe, "image_processor")
+    q = queue.Queue()
+    cnt = {"i": 0}
+
+    def cb(pipe, i, t, kw):
+        if ev.is_set():
+            raise InterruptedError()
+        cnt["i"] += 1
+        if has_preview and "latents" in kw:
+            try:
+                q.put((_decode_latents(kw["latents"], pipe), cnt["i"]))
+            except Exception:
+                pass
+        return kw
+
+    res = {}
+    exc = {}
+
+    def run():
+        try:
+            kw = dict(prompt=prompt, height=int(height), width=int(width),
+                      num_inference_steps=int(steps), generator=gen)
+            if has_preview:
+                kw["output_type"] = "latent"
+                kw["callback_on_step_end"] = cb
+                kw["callback_on_step_end_tensor_inputs"] = ["latents"]
+            out = pipe(**kw)
+            if not ev.is_set():
+                if has_preview:
+                    res["final"] = _decode_latents(out.images, pipe)
+                else:
+                    res["final"] = out.images[0]
+            q.put(None)
+        except InterruptedError:
+            q.put(None)
+        except Exception as e:
+            exc["e"] = e
+            q.put(None)
 
-    thread.join()
+    threading.Thread(target=run).start()
 
-    # Re-raise any exception from the thread
-    if "exc" in thread_exc:
-        raise thread_exc["exc"]
+    last = None
+    while True:
+        item = q.get()
+        if item is None:
+            break
+        img, step = item
+        last = img
+        yield img, seed, f"Step {step}/{int(steps)}"
 
-    if interrupt_event.is_set():
-        # Generation was cancelled - don't yield final, just return last preview
+    if "e" in exc:
+        raise exc["e"]
+    if ev.is_set():
         yield last, seed, "Cancelled"
     else:
-        yield result["final"], seed, f"Done ({int(num_inference_steps)} steps)"
-
-
-# ---------------------------------------------------------------------------
-# Hidden "conflict_check" API function (wired to a hidden .click handler below)
-# ---------------------------------------------------------------------------
-def _resolve_file_bytes(entry):
-    """Turn a gr.File value into (filename, raw_bytes).
-
-    Handles all the ways a file can arrive:
-      * a plain filepath string (uploaded via /upload)
-      * a FileData dict with a `path` (uploaded)
-      * a FileData dict with an inline base64 `data:` URI (used when the
-        caller cannot reach /upload, e.g. behind a proxy)
-      * a bare `data:` URI string
-    """
-    if isinstance(entry, str):
-        if entry.startswith("data:"):
-            _, _, payload = entry.partition(",")
-            return "upload", base64.b64decode(payload)
-        with open(entry, "rb") as fh:
-            return os.path.basename(entry), fh.read()
-    if isinstance(entry, dict):
-        name = entry.get("orig_name") or entry.get("name") or "upload"
-        path = entry.get("path")
-        if path:
-            with open(path, "rb") as fh:
-                return os.path.basename(path), fh.read()
-        url = entry.get("url") or ""
-        if url.startswith("data:"):
-            _, _, payload = url.partition(",")
-            return name, base64.b64decode(payload)
-        if url:
-            import urllib.request as _ur
-            with _ur.urlopen(url, timeout=30) as resp:
-                return name, resp.read()
-    raise ValueError(f"Unsupported file value: {entry!r}")
-
-
-def _conflict_check_fn(files, config):
-    """Hidden Gradio API (api_name="conflict_check"): compare uploaded files
-    for conflicts. `files` is the hidden gr.JSON input (list of FileData dicts,
-    each typically carrying an inline base64 `data:` URI, or a single dict).
-    `config` is a gr.JSON dict of generation settings (model id + params)."""
-    if not files:
-        return {
-            "conflicts_found": False,
-            "summary": "No files were uploaded.",
-            "conflicts": [],
-        }
-    if isinstance(files, (str, dict)):
-        files = [files]
-    raw_docs = []
-    for entry in files:
+        yield res.get("final", last), seed, f"Done ({int(steps)} steps)"
+
+
+# --- TTS ---
+
+def generate_speech(text):
+    pipe = _state.get("pipeline")
+    model = _state.get("model")
+    tokenizer = _state.get("tokenizer")
+
+    if pipe is not None:
         try:
-            fname, content_bytes = _resolve_file_bytes(entry)
+            result = pipe(text)
         except Exception as e:
-            raw_docs.append({"filename": str(entry), "content": f"[Could not read file: {e}]"})
-            continue
-        raw_docs.append({
-            "filename": fname,
-            "content": _read_upload(fname, content_bytes),
-        })
-    try:
-        if config and config.get("gpu"):
-            return _analyze_conflicts_gpu(raw_docs, config)
-        return _analyze_conflicts_cpu(raw_docs, config)
-    except Exception as e:
-        import traceback
-        tb = traceback.format_exc()
-        return {
-            "conflicts_found": False,
-            "summary": f"Conflict analysis failed: {type(e).__name__}: {e}",
-            "conflicts": [],
-            "error": tb[-3000:],
-        }
-
-
-# Example prompts
-examples = [
-    ["Young Chinese woman in red Hanfu, intricate embroidery. Impeccable makeup, red floral forehead pattern. Elaborate high bun, golden phoenix headdress, red flowers, beads. Holds round folding fan with lady, trees, bird. Neon lightning-bolt lamp, bright yellow glow, above extended left palm. Soft-lit outdoor night background, silhouetted tiered pagoda, blurred colorful distant lights."],
-    ["A majestic dragon soaring through clouds at sunset, scales shimmering with iridescent colors, detailed fantasy art style"],
-    ["Cozy coffee shop interior, warm lighting, rain on windows, plants on shelves, vintage aesthetic, photorealistic"],
-    ["Astronaut riding a horse on Mars, cinematic lighting, sci-fi concept art, highly detailed"],
-    ["Portrait of a wise old wizard with a long white beard, holding a glowing crystal staff, magical forest background"],
-]
+            raise gr.Error(f"TTS failed: {e}")
+        sr = result.get("sampling_rate", 22050)
+        audio = result["audio"]
+    elif model is not None and tokenizer is not None:
+        speaker_embedding = _state.get("speaker_embeddings")
+        import torch as _torch
+        inputs = tokenizer(text, return_tensors="pt").to(model.device)
+        with _torch.no_grad():
+            speech = model.generate(input_ids=inputs["input_ids"], speaker_embeddings=speaker_embedding)
+        sr = 16000
+        audio = speech[0].cpu().numpy()
+    else:
+        raise gr.Error("No TTS model loaded.")
+    if isinstance(audio, list):
+        audio = audio[0]
+    if isinstance(audio, torch.Tensor):
+        audio = audio.cpu().numpy()
+    return (sr, audio)
 
-# Custom theme with modern aesthetics (Gradio 6)
-custom_theme = gr.themes.Soft(
-    primary_hue="yellow",
-    secondary_hue="amber",
-    neutral_hue="slate",
-    font=gr.themes.GoogleFont("Inter"),
-    text_size="lg",
-    spacing_size="md",
-    radius_size="lg"
-).set(
-    button_primary_background_fill="*primary_500",
-    button_primary_background_fill_hover="*primary_600",
-    block_title_text_weight="600",
-)
 
-# Build the Gradio interface
-with gr.Blocks(fill_height=True) as demo:
-    # Header
-    gr.Markdown(
-        """
-        # 🎨 Z-Image-Turbo
-        **Ultra-fast AI image generation** • CPU mode • 256×256 default • live step-by-step preview
-        """,
-        elem_classes="header-text"
-    )
+# --- Code Templates ---
 
-    with gr.Row(equal_height=False):
-        # Left column - Input controls
-        with gr.Column(scale=1, min_width=320):
-            prompt = gr.Textbox(
-                label="✨ Your Prompt",
-                placeholder="Describe the image you want to create...",
-                lines=5,
-                max_lines=10,
-                autofocus=True,
-            )
-
-            with gr.Accordion("⚙️ Advanced Settings", open=False):
-                with gr.Row():
-                    height = gr.Slider(
-                        minimum=32,
-                        maximum=1024,
-                        value=256,
-                        step=32,
-                        label="Height",
-                        info="Image height in pixels"
-                    )
-                    width = gr.Slider(
-                        minimum=32,
-                        maximum=1024,
-                        value=256,
-                        step=32,
-                        label="Width",
-                        info="Image width in pixels"
-                    )
-
-                num_inference_steps = gr.Slider(
-                    minimum=1,
-                    maximum=20,
-                    value=9,
-                    step=1,
-                    label="Inference Steps",
-                    info="9 steps = 8 DiT forwards (recommended)"
-                )
+TEMPLATES = {
+    "Custom": "# Write any Python code here\n# Model state: model, tokenizer, pipe, device\nprint('Hello from HF Playground!')",
+    "💬 Chat": '''# Chat with the loaded model
+import torch
 
-                with gr.Row():
-                    randomize_seed = gr.Checkbox(
-                        label="🎲 Random Seed",
-                        value=True,
-                    )
-                    seed = gr.Number(
-                        label="Seed",
-                        value=42,
-                        precision=0,
-                        visible=False,
-                    )
-
-                def toggle_seed(randomize):
-                    return gr.Number(visible=not randomize)
-
-                randomize_seed.change(
-                    toggle_seed,
-                    inputs=[randomize_seed],
-                    outputs=[seed]
-                )
+messages = [{"role": "system", "content": "You are a helpful assistant."}]
+messages.append({"role": "user", "content": "What is the capital of France?"})
 
-            generate_btn = gr.Button(
-                "🚀 Generate Image",
-                variant="primary",
-                size="lg",
-                scale=1
-            )
-
-            # Example prompts
-            gr.Examples(
-                examples=examples,
-                inputs=[prompt],
-                label="💡 Try these prompts",
-                examples_per_page=5,
-            )
-
-        # Right column - Output
-        with gr.Column(scale=1, min_width=320):
-            output_image = gr.Image(
-                label="Generated Image",
-                type="pil",
-                format="png",
-                show_label=False,
-                height=512,
-                buttons=["download", "share"],
-            )
-
-            status = gr.Textbox(
-                label="🔄 Progress",
-                value="Idle",
-                interactive=False,
-            )
-
-            used_seed = gr.Number(
-                label="🎲 Seed Used",
-                interactive=False,
-                container=True,
-            )
-
-    # Footer credits
-    gr.Markdown(
-        """
-        ---
-        <div style="text-align: center; opacity: 0.7; font-size: 0.9em; margin-top: 1rem;">
-        <strong>Model:</strong> <a href="https://huggingface.co/Tongyi-MAI/Z-Image-Turbo" target="_blank">Tongyi-MAI/Z-Image-Turbo</a> (Apache 2.0 License) • 
-        <strong>Demo by:</strong> <a href="https://x.com/realmrfakename" target="_blank">@mrfakename</a> • 
-        <strong>Redesign by:</strong> AnyCoder • 
-        <strong>CPU + step-preview mod</strong>
-        </div>
-        """,
-        elem_classes="footer-text"
-    )
+if tokenizer.chat_template:
+    prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+else:
+    prompt = messages[-1]["content"]
 
-    # Connect the generate button - new clicks cancel previous generation
-    generate_event = generate_btn.click(
-        fn=generate_image,
-        inputs=[prompt, height, width, num_inference_steps, seed, randomize_seed],
-        outputs=[output_image, used_seed, status],
-    )
+inputs = tokenizer(prompt, return_tensors="pt").to(device)
+with torch.no_grad():
+    out = model.generate(**inputs, max_new_tokens=256, temperature=0.7, do_sample=True)
+resp = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+print("Response:", resp)''',
+    "✏️ Completion": '''# Raw text completion
+import torch
 
-    # Also allow generating by pressing Enter in the prompt box - cancels previous
-    prompt_event = prompt.submit(
-        fn=generate_image,
-        inputs=[prompt, height, width, num_inference_steps, seed, randomize_seed],
-        outputs=[output_image, used_seed, status],
-    )
+prompt = "Once upon a time, in a land far away,"
+inputs = tokenizer(prompt, return_tensors="pt").to(device)
+with torch.no_grad():
+    out = model.generate(**inputs, max_new_tokens=256, temperature=0.7, do_sample=True)
+completion = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+print(prompt + completion)''',
+    "🧠 Reasoning": '''# Step-by-step reasoning (for thinking models)
+import torch
 
-    # Cross-cancel: button click cancels prompt submit and vice versa
-    generate_event.cancels = [prompt_event]
-    prompt_event.cancels = [generate_event]
-
-    # Hidden conflict-check API (no visible UI). The components live in the
-    # layout but are visually hidden via CSS (`.hidden_conflict`); the button's
-    # .click handler is exposed as the /gradio_api/conflict_check endpoint.
-    # Input is a gr.JSON that carries FileData dicts (inline base64 `data:` URIs)
-    # so callers behind a proxy that blocks /upload can still send files.
-    conflict_files = gr.JSON(label="files", elem_classes="hidden_conflict")
-    conflict_cfg = gr.JSON(label="config", elem_classes="hidden_conflict", value={})
-    conflict_out = gr.JSON(label="result", elem_classes="hidden_conflict")
-    conflict_btn = gr.Button("Conflict check", elem_classes="hidden_conflict")
-    conflict_btn.click(
-        _conflict_check_fn,
-        inputs=[conflict_files, conflict_cfg],
-        outputs=[conflict_out],
-        api_name="conflict_check",
-    )
+prompt = "How many r's are in the word 'strawberry'? Think step by step."
+messages = [{"role": "system", "content": "Please reason step by step."},
+            {"role": "user", "content": prompt}]
+
+if tokenizer.chat_template:
+    full = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+else:
+    full = prompt
+
+inputs = tokenizer(full, return_tensors="pt").to(device)
+with torch.no_grad():
+    out = model.generate(**inputs, max_new_tokens=512, temperature=0.6, do_sample=True)
+resp = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+print(resp)''',
+    "🌐 Translate": '''# Translation
+import torch
 
+src, tgt = "English", "Spanish"
+text = "Hello, how are you today?"
+prompt = f"Translate {src} to {tgt}: {text}"
 
-# ---------------------------------------------------------------------------
-# Hidden "conflict-check" API (NOT wired to any UI component)
-# ---------------------------------------------------------------------------
-# Model used for conflict analysis. Runs entirely on CPU (no GPU usage).
-CONFLICT_MODEL_ID = "google/gemma-4-E4B-it"
-
-_CONFLICT_MODEL_ID = None  # currently loaded model (single-slot cache)
-_CONFLICT_MODEL = None
-_CONFLICT_TOKENIZER = None
-
-CONFLICT_SYSTEM_PROMPT = """You are an expert Talent Acquisition Conflict Analyst. Compare multiple job description documents and identify conflicts, discrepancies, and items that need verification.
-
-### Instructions:
-1. Compare ALL provided documents carefully, including JSON fields (jdFormat, jdPublicFormat, etc.), PDFs, text files, and any other uploads.
-2. Focus on these critical fields:
-   - Identity: job_title, company, department
-   - Role: seniority_level, contract_type, employment_type, reporting_to, team_size
-   - Location: work_location, office_address, region, country, travel_requirements
-   - Policy: work_policy (remote/hybrid/onsite), working_hours, timezone
-   - Compensation: salary_range, currency, benefits, equity/stock, bonus
-   - Requirements: must_have_skills, nice_to_have_skills, education_level, years_experience, certifications
-   - Responsibilities: tasks_and_duties, key_responsibilities, kpis
-   - Others: posting_date, closing_date, job_id, hiring_manager, language
-3. If a field conflicts, include ALL document values. If a document doesn't have the field, skip it (don't include as null).
-4. If a field is ambiguous, incomplete, or varies slightly between documents (e.g. "3-5 years" vs "5+ years"), mark severity as need_check.
-5. Track which document each value came from, and include the field path/location within the document for easy cross-reference.
-6. Output ONLY valid JSON. Do not wrap it in markdown code fences or add any commentary before or after the JSON.
-
-### Severity Levels:
-- **high**: Direct contradiction (e.g. "remote" vs "on-site", different salary ranges)
-- **medium**: Notable difference that affects the role (e.g. different team sizes, missing vs present benefits)
-- **low**: Minor wording differences that likely mean the same thing
-- **need_check**: Ambiguous, incomplete, or potentially conflicting but needs human verification
-
-### Output JSON Schema:
-{
-  "conflicts_found": true | false,
-  "summary": "Brief overall comparison summary",
-  "conflicts": [
-    {
-      "field": "field_name",
-      "severity": "high | medium | low | need_check",
-      "values": [
-        {
-          "document": "filename",
-          "value": "the value",
-          "path": "field path within the document (e.g. jdFormat.location.type, or 'page 1 paragraph 2')"
-        }
-      ],
-      "details": "Description of the discrepancy and why it matters"
+inputs = tokenizer(prompt, return_tensors="pt").to(device)
+with torch.no_grad():
+    out = model.generate(**inputs, max_new_tokens=128, temperature=0.3)
+result = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+print(result)''',
+    "📝 Summarize": '''# Summarization
+import torch
+
+doc = """The quick brown fox jumps over the lazy dog. \
+This sentence contains every letter of the alphabet at least once. \
+It is commonly used for typing practice and font display."""
+
+inputs = tokenizer(doc, return_tensors="pt", truncation=True, max_length=512).to(device)
+with torch.no_grad():
+    out = model.generate(**inputs, max_new_tokens=128, temperature=0.3, do_sample=False)
+summary = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+print("Summary:", summary)''',
+    "🎨 Image Gen": '''# Generate an image using the loaded pipeline
+import torch
+
+prompt = "A beautiful sunset over mountains, digital art"
+height, width, steps = 256, 256, 9
+seed = 42
+
+if pipe is not None:
+    gen = torch.Generator(device=device).manual_seed(seed)
+    result = pipe(prompt=prompt, height=height, width=width,
+                  num_inference_steps=steps, generator=gen)
+    img = result.images[0]
+    img.save("output.png")
+    print("Saved to output.png")
+else:
+    print("No image pipeline loaded. Load a diffusers model first.")''',
+    "🔊 TTS": '''# Generate speech
+text = "Hello, welcome to the Hugging Face playground."
+
+if pipe is not None:
+    result = pipe(text)
+    sr, audio = result["sampling_rate"], result["audio"]
+    import scipy.io.wavfile as wav
+    wav.write("output.wav", sr, audio)
+    print("Saved to output.wav")
+else:
+    print("No TTS pipeline loaded. Load a TTS model first.")''',
+    "📂 Read File": '''# Read and process a file from the workspace
+import os
+
+path = "README.md"
+if os.path.exists(path):
+    with open(path, "r") as f:
+        content = f.read()
+    # Process with model
+    inputs = tokenizer(f"Summarize this:\\n{content[:500]}", return_tensors="pt").to(device)
+    with torch.no_grad():
+        out = model.generate(**inputs, max_new_tokens=128)
+    result = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+    print(result)
+else:
+    print(f"File not found: {path}")''',
+    "#! Shell": '''# Shell commands with #! prefix
+#!ls -la
+#!pwd
+#!echo "Hello from shell!"
+
+# Mix with Python
+import os
+print("Python says:", os.getcwd())''',
+}
+
+TASK_TEMPLATE_MAP = {
+    "text-generation": "💬 Chat",
+    "text2text-generation": "✏️ Completion",
+    "summarization": "📝 Summarize",
+    "translation": "🌐 Translate",
+    "image-generation": "🎨 Image Gen",
+    "text-to-speech": "🔊 TTS",
+}
+
+
+# --- Custom Code ---
+
+def run_custom_code(code):
+    import io as _io, sys as _sys, subprocess as _sp, traceback as _tb, shlex as _shlex
+    s = _state
+    env = {
+        "model": s.get("model"),
+        "tokenizer": s.get("tokenizer"),
+        "pipe": s.get("pipeline"),
+        "device": s.get("device", "cpu"),
+        "state": s,
+        "__builtins__": __builtins__,
     }
-  ]
-}"""
-
-
-def _load_conflict_model(model_id, device="cpu"):
-    """Lazily load the conflict-analysis model. `device` is "cpu" or "cuda".
-    Caches a single model keyed by (model_id, device); switching either reloads
-    it (keeps RAM bounded for large models). Gemma 4 models use
-    `apply_chat_template` for correct prompting; the tokenizer carries the
-    template so we avoid the heavy `torchvision` image dependency."""
-    global _CONFLICT_MODEL_ID, _CONFLICT_TOKENIZER, _CONFLICT_MODEL
-    cache_key = (model_id, device)
-    if _CONFLICT_MODEL is None or _CONFLICT_MODEL_ID != cache_key:
-        from transformers import AutoModelForCausalLM, AutoTokenizer
-        print(f"Loading conflict-analysis model {model_id} on {device}...")
-        _CONFLICT_TOKENIZER = AutoTokenizer.from_pretrained(model_id)
-        load_kwargs = dict(torch_dtype=torch.bfloat16, low_cpu_mem_usage=True)
-        if device != "cpu":
-            load_kwargs["device_map"] = "auto"
-        _CONFLICT_MODEL = AutoModelForCausalLM.from_pretrained(model_id, **load_kwargs)
-        # Note: with low_cpu_mem_usage=True the model is already materialised on
-        # CPU, so do NOT call .to("cpu") (it would fail on the meta tensors).
-        _CONFLICT_MODEL.eval()
-        _CONFLICT_MODEL_ID = cache_key
-        print("Conflict-analysis model loaded!")
-    return _CONFLICT_TOKENIZER, _CONFLICT_MODEL
-
-
-def _simplify_json(data):
-    """Recursively prune JSON: drop null/empty values, ids (except root `id`
-    inside the `data` object), timestamps, single-field wrappers, and
-    de-duplicate createdAt arrays to their first item."""
-    def clean_obj(obj, is_data_root=False):
-        if isinstance(obj, dict):
-            cleaned_dict = {}
-            for k, v in obj.items():
-                cleaned_val = clean_obj(v)
-                if cleaned_val in (None, [], {}):
-                    continue
-                if k == "id" and not is_data_root:
-                    continue
-                if k in ("createAt", "createdAt", "creatorId", "contactPoints") or k.endswith("Id"):
-                    continue
-                cleaned_dict[k] = cleaned_val
-            while isinstance(cleaned_dict, dict) and len(cleaned_dict) == 1:
-                cleaned_dict = cleaned_dict[list(cleaned_dict.keys())[0]]
-            return cleaned_dict
-        elif isinstance(obj, list):
-            if not obj:
-                return []
-            has_created_at = any(
-                isinstance(item, dict) and ("createAt" in item or "createdAt" in item)
-                for item in obj
-            )
-            if has_created_at:
-                return clean_obj(obj[0])
-            cleaned_list = []
-            for item in obj:
-                cleaned_item = clean_obj(item)
-                if cleaned_item not in (None, [], {}):
-                    cleaned_list.append(cleaned_item)
-            return cleaned_list
-        return obj
-
-    return clean_obj(data, True)
-
-
-def _read_upload(filename: str, raw: bytes) -> str:
-    """Decode an uploaded file into a plain-text representation."""
-    lower = filename.lower()
-    if lower.endswith(".json"):
+    old_out, old_err = _sys.stdout, _sys.stderr
+    _sys.stdout = _io.StringIO()
+    _sys.stderr = _io.StringIO()
+    try:
+        py_blocks = []
+        for line in code.split("\n"):
+            if line.startswith("#!"):
+                if py_blocks:
+                    exec("\n".join(py_blocks), env)
+                    py_blocks = []
+                cmd = line[2:].strip()
+                result = _sp.run(cmd, shell=True, capture_output=True, text=True)
+                print(result.stdout, end="")
+                if result.stderr:
+                    print(result.stderr, file=_sys.stderr, end="")
+            else:
+                py_blocks.append(line)
+        if py_blocks:
+            exec("\n".join(py_blocks), env)
+    except Exception:
+        print(_tb.format_exc(), file=_sys.stderr)
+    out = _sys.stdout.getvalue()
+    err = _sys.stderr.getvalue()
+    _sys.stdout, _sys.stderr = old_out, old_err
+    if err:
+        out += "\n--- stderr ---\n" + err
+    return out
+
+
+# ============================================================
+# UI
+# ============================================================
+
+CSS = """
+.gradio-container { max-width:1400px;margin:0 auto; }
+@media(max-width:768px){ h1{font-size:1.5rem} }
+"""
+
+theme = gr.themes.Soft(
+    primary_hue="yellow", secondary_hue="amber", neutral_hue="slate",
+    font=gr.themes.GoogleFont("Inter"), text_size="lg", spacing_size="md", radius_size="lg",
+).set(button_primary_background_fill="*primary_500",
+      button_primary_background_fill_hover="*primary_600",
+      block_title_text_weight="600")
+
+
+def build_app():
+    gr.Markdown("# 🤗 **HF Playground** — enter any model ID to test")
+
+    with gr.Row(equal_height=True):
+        model_input = gr.Dropdown(
+            label="Model ID", scale=5, container=True,
+            choices=PRESET_CHOICES, value="google/gemma-3-1b-it",
+            allow_custom_value=True,
+        )
+        load_btn = gr.Button("🚀 Load", variant="primary", scale=1, min_width=80)
+        use_gpu = gr.Checkbox(label="GPU", value=False, scale=1, show_label=False)
+
+    use_gpu.change(fn=_set_gpu_flag, inputs=[use_gpu], outputs=[])
+
+    model_info = gr.Markdown("_No model loaded_")
+
+    task_state = gr.State("text-generation")
+    thinking_state = gr.State(False)
+
+    # --- Always-visible Code + File Browser ---
+    with gr.Accordion("🐍 Python + 📁 Files", open=True):
+        with gr.Row():
+            with gr.Column(scale=1, min_width=280):
+                gr.Markdown("### 📁 Files")
+                file_list = gr.Dropdown(label="Workspace Files", choices=[], interactive=True, container=True)
+                refresh_btn = gr.Button("🔄 Refresh", scale=1)
+                gr.Markdown("---")
+                preview_img = gr.Image(label="Preview", type="filepath", visible=False, height=400)
+                preview_aud = gr.Audio(label="Preview", type="filepath", visible=False)
+                preview_vid = gr.Video(label="Preview", visible=False, height=400)
+                preview_txt = gr.Textbox(label="File Content", lines=20, visible=False)
+            with gr.Column(scale=2):
+                gr.Markdown("### 🐍 Python")
+                template_dd = gr.Dropdown(
+                    label="Template", choices=list(TEMPLATES.keys()),
+                    value="Custom", container=True,
+                )
+                custom_code = gr.Code(label="Code", language="python", lines=12,
+                    value=TEMPLATES["Custom"])
+                with gr.Row():
+                    custom_run = gr.Button("▶ Run", variant="primary")
+                custom_out = gr.Textbox(label="Output", lines=8)
+
+    # ── Columns for each task type ──
+    cols = {}
+
+    # --- TEXT GENERATION ---
+    with gr.Column(visible=False) as c_text:
+        cols["text-generation"] = c_text
+        cols["text2text-generation"] = c_text
+        gr.Markdown("### 💬 Text Generation")
+        with gr.Tabs():
+            with gr.TabItem("💬 Chat"):
+                chatbot = gr.Chatbot(label="Conversation", height=400)
+                chat_msg = gr.Textbox(label="Message", placeholder="Type...", scale=4, container=True)
+                with gr.Row():
+                    chat_btn = gr.Button("Send", variant="primary")
+                    chat_clr = gr.Button("🗑 Clear")
+                chat_sys = gr.Textbox(label="System Prompt", value="You are a helpful assistant.", lines=2)
+            with gr.TabItem("✏️ Completion"):
+                comp_in = gr.Textbox(label="Input", lines=5)
+                comp_out = gr.Textbox(label="Output", lines=10)
+                with gr.Row():
+                    comp_btn = gr.Button("Generate", variant="primary")
+                    comp_stop = gr.Button("⏹ Stop", variant="stop", visible=False)
+            with gr.TabItem("🌐 Translate (prompt)"):
+                tri_in = gr.Textbox(label="Text", lines=5)
+                with gr.Row():
+                    tri_src = gr.Dropdown(label="Source", value="auto",
+                        choices=["auto","English","Spanish","French","German","Chinese"])
+                    tri_tgt = gr.Dropdown(label="Target", value="Spanish",
+                        choices=["English","Spanish","French","German","Chinese"])
+                tri_out = gr.Textbox(label="Translation", lines=5)
+                tri_btn = gr.Button("Translate", variant="primary")
+        with gr.Accordion("⚙️ Parameters", open=False):
+            with gr.Row():
+                tk = gr.Slider(32, 4096, 512, 32, label="Max New Tokens")
+                tm = gr.Slider(0, 2, 0.7, 0.05, label="Temperature")
+            with gr.Row():
+                tp = gr.Slider(0, 1, 0.9, 0.05, label="Top-P")
+                tkk = gr.Slider(0, 200, 50, 1, label="Top-K (0=off)")
+            with gr.Row():
+                rp = gr.Slider(1, 2, 1.1, 0.05, label="Repetition Penalty")
+                ds = gr.Checkbox(True, label="Sampling")
+
+    # --- SUMMARIZATION ---
+    with gr.Column(visible=False) as c_summ:
+        cols["summarization"] = c_summ
+        gr.Markdown("### 📝 Summarization")
+        sm_in = gr.Textbox(label="Document", lines=10)
+        sm_out = gr.Textbox(label="Summary", lines=8)
+        sm_btn = gr.Button("Summarize", variant="primary")
+        with gr.Accordion("⚙️ Parameters", open=False):
+            with gr.Row():
+                sm_tk = gr.Slider(32, 1024, 150, 16, label="Max New Tokens")
+                sm_tm = gr.Slider(0, 2, 0.7, 0.05, label="Temperature")
+            with gr.Row():
+                sm_tp = gr.Slider(0, 1, 0.9, 0.05, label="Top-P")
+                sm_tkk = gr.Slider(0, 200, 50, 1, label="Top-K")
+            with gr.Row():
+                sm_rp = gr.Slider(1, 2, 1, 0.05, label="Repetition")
+                sm_ds = gr.Checkbox(True, label="Sampling")
+
+    # --- TRANSLATION ---
+    with gr.Column(visible=False) as c_trans:
+        cols["translation"] = c_trans
+        gr.Markdown("### 🌐 Translation")
+        with gr.Row():
+            dl_src = gr.Dropdown(label="Source", value="en",
+                choices=["en","es","fr","de","zh","ja","ar"])
+            dl_tgt = gr.Dropdown(label="Target", value="es",
+                choices=["en","es","fr","de","zh","ja","ar"])
+        dl_in = gr.Textbox(label="Text", lines=5)
+        dl_out = gr.Textbox(label="Translation", lines=5)
+        dl_btn = gr.Button("Translate", variant="primary")
+        with gr.Accordion("⚙️ Parameters", open=False):
+            with gr.Row():
+                dl_tk = gr.Slider(32, 1024, 256, 16, label="Max New Tokens")
+                dl_tm = gr.Slider(0, 2, 0.7, 0.05, label="Temperature")
+            with gr.Row():
+                dl_tp = gr.Slider(0, 1, 0.9, 0.05, label="Top-P")
+                dl_tkk = gr.Slider(0, 200, 50, 1, label="Top-K")
+            with gr.Row():
+                dl_rp = gr.Slider(1, 2, 1, 0.05, label="Repetition")
+                dl_ds = gr.Checkbox(True, label="Sampling")
+
+    # --- IMAGE GENERATION ---
+    with gr.Column(visible=False) as c_img:
+        cols["image-generation"] = c_img
+        gr.Markdown("### 🎨 Image Generation")
+        img_pr = gr.Textbox(label="Prompt", lines=3)
+        with gr.Row():
+            img_h = gr.Slider(64, 1024, 256, 32, label="Height")
+            img_w = gr.Slider(64, 1024, 256, 32, label="Width")
+        with gr.Row():
+            img_st = gr.Slider(1, 50, 9, 1, label="Steps")
+            img_rz = gr.Checkbox(True, label="Random Seed")
+            img_sd = gr.Number(42, label="Seed", precision=0, visible=False)
+        img_rz.change(fn=lambda r: gr.update(visible=not r), inputs=[img_rz], outputs=[img_sd])
+        img_out = gr.Image(label="Generated Image", type="pil", height=512)
+        img_sts = gr.Textbox(label="Status", value="Idle", interactive=False)
+        img_used = gr.Number(label="Seed", interactive=False)
+        img_btn = gr.Button("🎨 Generate Image", variant="primary")
+        gr.Examples([["Young Chinese woman in red Hanfu."],
+                     ["Dragon soaring through clouds at sunset."],
+                     ["Astronaut riding a horse on Mars."]],
+                    inputs=[img_pr])
+
+    # --- TTS ---
+    with gr.Column(visible=False) as c_tts:
+        cols["text-to-speech"] = c_tts
+        gr.Markdown("### 🔊 Text-to-Speech")
+        tts_txt = gr.Textbox(label="Text", lines=3)
+        tts_btn = gr.Button("🔊 Generate Speech", variant="primary")
+        tts_aud = gr.Audio(label="Speech", type="numpy")
+
+    # ===========================
+    # VISIBILITY MAPPING
+    # ===========================
+    ui_order = ["text-generation", "text2text-generation", "summarization",
+                "translation", "image-generation", "text-to-speech"]
+    ui_cols = [cols.get(t, c_text) for t in ui_order]
+    # deduplicate by id
+    seen = set()
+    unique_cols = []
+    for c in ui_cols:
+        if id(c) not in seen:
+            seen.add(id(c))
+            unique_cols.append(c)
+
+    def set_visible(task):
+        return [gr.update(visible=c == cols.get(task, c_text)) for c in unique_cols]
+
+    # File browser helpers
+    import os as _os, glob as _glob
+
+    def _list_files():
+        files = sorted(f for f in _glob.glob("**/*", recursive=True) if _os.path.isfile(f))
+        return gr.update(choices=[(f, f) for f in files])
+
+    def _preview_file(path):
+        if not path:
+            return [gr.update(visible=False)] * 4
+        ext = _os.path.splitext(path)[1].lower()
+        img = {".png",".jpg",".jpeg",".gif",".bmp",".webp",".svg"}
+        aud = {".mp3",".wav",".ogg",".flac",".m4a",".aac",".wma"}
+        vid = {".mp4",".avi",".mov",".mkv",".webm",".m4v"}
+        if ext in img:
+            return [gr.update(visible=True, value=path), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)]
+        if ext in aud:
+            return [gr.update(visible=False), gr.update(visible=True, value=path), gr.update(visible=False), gr.update(visible=False)]
+        if ext in vid:
+            return [gr.update(visible=False), gr.update(visible=False), gr.update(visible=True, value=path), gr.update(visible=False)]
         try:
-            parsed = json.loads(raw.decode("utf-8", errors="replace"))
-            # Simplify the JSON before sending it to the model
-            if isinstance(parsed, dict) and "data" in parsed:
-                parsed = parsed["data"]
-            simplified = _simplify_json(parsed)
-            return json.dumps(simplified, indent=2, ensure_ascii=False)
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
         except Exception:
-            return raw.decode("utf-8", errors="replace")
-    if lower.endswith(".pdf"):
-        try:
-            from pypdf import PdfReader
-            reader = PdfReader(io.BytesIO(raw))
-            pages = []
-            for i, page in enumerate(reader.pages, start=1):
-                text = page.extract_text() or ""
-                pages.append(f"--- page {i} ---\n{text}")
-            return "\n".join(pages)
-        except Exception as e:
-            return f"[Could not parse PDF '{filename}': {e}]"
-    # Fallback: treat as plain text
-    return raw.decode("utf-8", errors="replace")
-
-
-def _extract_json(text: str):
-    """Best-effort extraction of a JSON object from model output.
-    Handles the common ```json ... ``` markdown fence and truncated output."""
-    t = text.strip()
-    # Strip a leading ```json / ``` fence
-    if t.startswith("```"):
-        t = t.split("\n", 1)[1] if "\n" in t else t[3:]
-        if t.endswith("```"):
-            t = t[:-3]
-        t = t.strip()
-    start = t.find("{")
-    end = t.rfind("}")
-    if start == -1 or end == -1 or end <= start:
-        raise ValueError(
-            "No JSON object found in model output. RAW>>>"
-            + text[:1000].replace("\n", "\\n")
-        )
-    return json.loads(t[start:end + 1])
-
-
-def _analyze_conflicts(documents, config=None):
-    """Run the LLM conflict analysis on a list of {filename, content} dicts.
-    `config` (dict) may override the model id and any generation parameters
-    (max_new_tokens, temperature, top_p, top_k, do_sample, repetition_penalty)."""
-    config = config or {}
-    model_id = config.get("model") or CONFLICT_MODEL_ID
-    device = "cuda" if (config.get("gpu") and torch.cuda.is_available()) else "cpu"
-    tokenizer, model = _load_conflict_model(model_id, device)
-
-    gen_kwargs = {
-        "max_new_tokens": int(config.get("max_new_tokens", 4096)),
-        "do_sample": bool(config.get("do_sample", False)),
-        "temperature": float(config.get("temperature", 1.0)),
-    }
-    if config.get("top_p") is not None:
-        gen_kwargs["top_p"] = float(config["top_p"])
-    if config.get("top_k") is not None:
-        gen_kwargs["top_k"] = int(config["top_k"])
-    if config.get("repetition_penalty") is not None:
-        gen_kwargs["repetition_penalty"] = float(config["repetition_penalty"])
-
-    docs_block = "\n\n".join(
-        f"===== DOCUMENT: {d['filename']} =====\n{d['content']}" for d in documents
+            content = f"<binary or unreadable: {path}>"
+        return [gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=True, value=content)]
+
+    # ===========================
+    # EVENT WIRING
+    # ===========================
+
+    # Load model
+    def on_load(model_id_val, progress=gr.Progress()):
+        if not model_id_val:
+            return [gr.update()] * (5 + n_vis)
+        task, thinking, info = load_model(model_id_val, progress)
+        vis_updates = set_visible(task)
+        template_name = TASK_TEMPLATE_MAP.get(task, "Custom")
+        template_code = TEMPLATES.get(template_name, TEMPLATES["Custom"])
+        return [task, thinking, info] + vis_updates + [gr.update(value=template_name), gr.update(value=template_code)]
+
+    n_vis = len(unique_cols)
+    load_outputs = [task_state, thinking_state, model_info] + unique_cols + [template_dd, custom_code]
+
+    model_input.change(fn=on_load, inputs=[model_input], outputs=load_outputs)
+    load_btn.click(fn=on_load, inputs=[model_input], outputs=load_outputs)
+
+    # Chat
+    chat_btn.click(
+        fn=chat_respond,
+        inputs=[chat_msg, chatbot, chat_sys, tk, tm, tp, tkk, rp, ds, thinking_state],
+        outputs=[chatbot, chat_msg],
+    )
+    chat_msg.submit(
+        fn=chat_respond,
+        inputs=[chat_msg, chatbot, chat_sys, tk, tm, tp, tkk, rp, ds, thinking_state],
+        outputs=[chatbot, chat_msg],
     )
-    user_content = (
-        "Below are the job description documents to compare.\n\n"
-        f"{docs_block}\n\n"
-        "Analyze them for conflicts using the instructions provided and return ONLY the JSON result."
+    chat_clr.click(fn=lambda: ([], ""), outputs=[chatbot, chat_msg])
+
+    # Completion
+    comp_btn.click(
+        fn=lambda: (gr.update(visible=False), gr.update(visible=True)),
+        outputs=[comp_btn, comp_stop],
+    ).then(
+        fn=completion_fn,
+        inputs=[comp_in, tk, tm, tp, tkk, rp, ds, thinking_state],
+        outputs=[comp_out],
+    ).then(
+        fn=lambda: (gr.update(visible=True), gr.update(visible=False)),
+        outputs=[comp_btn, comp_stop],
+    )
+    comp_stop.click(
+        fn=lambda: (_cancel_flag.__setitem__(0, True),) or (gr.update(visible=True), gr.update(visible=False)),
+        outputs=[comp_btn, comp_stop],
     )
 
-    # Gemma 4 requires the chat template (and thinking disabled) so the model
-    # emits a clean answer instead of reasoning tokens.
-    messages = [
-        {"role": "system", "content": CONFLICT_SYSTEM_PROMPT},
-        {"role": "user", "content": user_content},
-    ]
-    try:
-        text = tokenizer.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True, enable_thinking=False
-        )
-    except TypeError:
-        text = tokenizer.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
-        )
-    inputs = tokenizer(text, return_tensors="pt").to(model.device)
+    # Translate (text gen tab)
+    tri_btn.click(
+        fn=translate_fn,
+        inputs=[tri_in, tri_src, tri_tgt, tk, tm, tp, tkk, rp, ds, thinking_state],
+        outputs=[tri_out],
+    )
 
-    with torch.no_grad():
-        output = model.generate(**inputs, **gen_kwargs)
-    generated = output[0][inputs.input_ids.shape[1]:]
-    response_text = tokenizer.decode(generated, skip_special_tokens=False)
-    try:
-        return _extract_json(response_text)
-    except ValueError:
-        raise ValueError(
-            f"JSON parse failed (gen_len={generated.shape[0]}). "
-            f"tail={response_text[-300:]!r}"
-        )
+    # Summarization
+    sm_btn.click(
+        fn=summarize_fn,
+        inputs=[sm_in, sm_tk, sm_tm, sm_tp, sm_tkk, sm_rp, sm_ds],
+        outputs=[sm_out],
+    )
 
+    # Translation dedicated
+    dl_btn.click(
+        fn=translate_fn,
+        inputs=[dl_in, dl_src, dl_tgt, dl_tk, dl_tm, dl_tp, dl_tkk, dl_rp, dl_ds, thinking_state],
+        outputs=[dl_out],
+    )
 
-@spaces.GPU
-def _analyze_conflicts_gpu(documents, config):
-    """GPU-backed variant: when called, `spaces.GPU` runs this in the Space's
-    GPU worker, where `torch.cuda.is_available()` is True so the model loads to CUDA."""
-    return _analyze_conflicts(documents, config)
+    # Image
+    img_btn.click(
+        fn=generate_image,
+        inputs=[img_pr, img_h, img_w, img_st, img_sd, img_rz],
+        outputs=[img_out, img_used, img_sts],
+    )
 
+    # TTS
+    tts_btn.click(fn=generate_speech, inputs=[tts_txt], outputs=[tts_aud])
 
-def _analyze_conflicts_cpu(documents, config):
-    """CPU variant: runs in the main process (no GPU)."""
-    return _analyze_conflicts(documents, config)
+    # Custom code
+    refresh_btn.click(fn=_list_files, outputs=[file_list])
+    file_list.change(fn=_preview_file, inputs=[file_list], outputs=[preview_img, preview_aud, preview_vid, preview_txt])
+    template_dd.change(
+        fn=lambda name: gr.update(value=TEMPLATES.get(name, TEMPLATES["Custom"])),
+        inputs=[template_dd], outputs=[custom_code],
+    )
+    custom_run.click(fn=run_custom_code, inputs=[custom_code], outputs=[custom_out])
+
+    # Footer
+    gr.Markdown("""
+    ---
+    <div style="text-align:center;opacity:0.7;font-size:0.85em;padding:0.5rem 0;">
+    🤗 HuggingFace Model Playground — Enter any model ID, auto-detect, test instantly.
+    </div>
+    """)
 
 
-# NOTE: the conflict-check handler is `_conflict_check_fn` (defined above), wired to
-# the hidden `conflict_btn.click(...)` handler inside the Blocks block (api_name="conflict_check").
+# ============================================================
+# LAUNCH
+# ============================================================
+
+with gr.Blocks(title="HF Model Playground", fill_height=True) as demo:
+    build_app()
 
 if __name__ == "__main__":
-    demo.queue().launch(
-        theme=custom_theme,
-        css="""
-        .header-text h1 {
-            font-size: 2.5rem !important;
-            font-weight: 700 !important;
-            margin-bottom: 0.5rem !important;
-            background: linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%);
-            -webkit-background-clip: text;
-            -webkit-text-fill-color: transparent;
-            background-clip: text;
-        }
-
-        .header-text p {
-            font-size: 1.1rem !important;
-            color: #64748b !important;
-            margin-top: 0 !important;
-        }
-
-        .footer-text {
-            padding: 1rem 0;
-        }
-
-        .footer-text a {
-            color: #f59e0b !important;
-            text-decoration: none !important;
-            font-weight: 500;
-        }
-
-        .footer-text a:hover {
-            text-decoration: underline !important;
-        }
-
-        /* Mobile optimizations */
-        @media (max-width: 768px) {
-            .header-text h1 {
-                font-size: 1.8rem !important;
-            }
-
-            .header-text p {
-                font-size: 1rem !important;
-            }
-        }
-
-        /* Smooth transitions */
-        button, .gr-button {
-            transition: all 0.2s ease !important;
-        }
-
-        button:hover, .gr-button:hover {
-            transform: translateY(-1px);
-            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15) !important;
-        }
-
-        /* Better spacing */
-        .gradio-container {
-            max-width: 1400px !important;
-            margin: 0 auto !important;
-        }
-
-        /* Hide the conflict-check API components (no visible UI) */
-        .hidden_conflict {
-            display: none !important;
-        }
-        """,
-        footer_links=[
-            "api",
-            "gradio"
-        ],
-        mcp_server=True
-    )
+    demo.queue(default_concurrency_limit=3).launch(
+        server_name="0.0.0.0",
+        theme=theme,
+        css=CSS,
+        footer_links=["api", "gradio"],
+    )

requirements.txt

@@ -4,4 +4,10 @@ diffusers
 transformers
 accelerate
 torch
-pypdf
+huggingface_hub
+sentencepiece
+tiktoken
+datasets
+protobuf
+soundfile
+einops