Update app.py

app.py

@@ -1,289 +1,298 @@
-# codegen_gradio.py
-import os
-import io
-import json
-import time
-import tempfile
-import requests
-import gradio as gr
-from typing import Tuple, Optional
-
-# ---------------------- 配置 ----------------------
-HF_INFERENCE_URL = "https://api-inference.huggingface.co/models"
-# 默认模型（面向代码的强模型建议 user 输入或使用 bigcode/starcoder）
-DEFAULT_HF_MODEL = "bigcode/starcoder"  # or "bigcode/starcoder-base" / user can change in UI
-
-# 支持的语言与默认扩展（可扩展）
-LANG_EXT = {
-    "Python": ".py",
-    "JavaScript": ".js",
-    "TypeScript": ".ts",
-    "Go": ".go",
-    "Java": ".java",
-    "C": ".c",
-    "C++": ".cpp",
-    "C#": ".cs",
-    "Rust": ".rs",
-    "Kotlin": ".kt",
-    "Swift": ".swift",
-    "Ruby": ".rb",
-    "PHP": ".php",
-    "Shell": ".sh",
-    "PowerShell": ".ps1",
-    "HTML": ".html",
-    "CSS": ".css",
-    "SQL": ".sql",
-    "R": ".r",
-    "MATLAB": ".m",
-    "Scala": ".scala",
-    "Haskell": ".hs",
-    "Lua": ".lua",
-    "Perl": ".pl",
-    "Dart": ".dart",
-    "Elixir": ".ex",
-    "Julia": ".jl",
-    "Objective-C": ".m",
-    "Assembly": ".s",
-    "Dockerfile": "Dockerfile",
-    "YAML": ".yml",
-    "JSON": ".json",
-    "XML": ".xml",
-    "Protobuf": ".proto",
-    # add more if needed
-}
-
-# 多语言选项（显示顺序）
-LANG_CHOICES = list(LANG_EXT.keys())
-
-# 简单的安全黑名单（用于拒绝明显恶意请求）
-DANGEROUS_KEYWORDS = [
-    "rm -rf", "format(", "mkfs", "dd if=", "fork bomb", "shutdown", "reboot", "poweroff",
-    "create user", "adduser", "useradd", "passwd", "ssh -i", "cryptominer", "virus", "malware",
-    "ransomware", "keylogger", "inject", "exploit", "sqlmap", "metasploit", "reverse shell",
-    "nc -e", "wget http", "curl http", "chmod 777 /", "sudo rm -rf /", ">: /dev/sda"
-]
-
-# Prompt templates per task
-TASK_TEMPLATES = {
-    "Generate code from description": "Implement the following functionality in {lang}:\n\n{content}\n\nPlease provide only the code, no extra commentary.",
-    "Translate code to another language": "Translate the following code from {src_lang} to {lang}. Keep behavior identical and include necessary imports/dependencies.\n\n```{src_lang}\n{content}\n```",
-    "Explain code": "Explain the following {lang} code. Provide a concise explanation of what it does, complexity if applicable, and potential pitfalls or edge cases.\n\n```{lang}\n{content}\n```",
-    "Refactor code (improve readability/performance)": "Refactor the following {lang} code for readability and performance. Keep behavior identical, explain briefly what you changed, then provide the refactored code only.\n\n```{lang}\n{content}\n```",
-    "Add unit tests": "Write unit tests for the following {lang} code. Use common testing framework for {lang} (e.g., pytest for Python, jest for JS). Provide test code only.\n\n```{lang}\n{content}\n```",
-    "Document & comment code": "Add clear inline comments and a top-level docstring explaining the purpose, inputs, outputs, and side effects for this {lang} code. Then provide the commented code only.\n\n```{lang}\n{content}\n```",
-    "Optimize for performance": "Optimize the following {lang} code for performance. Keep same external behavior. Explain the optimizations in 2-3 lines, then provide the optimized code only.\n\n```{lang}\n{content}\n```",
-    "Add type hints / static types": "Add type annotations or static types to the following {lang} code where appropriate. Make sure the code remains valid.\n\n```{lang}\n{content}\n```",
-    "Create CLI tool": "Create a command-line interface (CLI) tool in {lang} that wraps the following functionality: {content}. Provide a complete script with argument parsing and usage example.",
-}
-
-# ---------------------- HF Inference helper ----------------------
-def call_hf_inference(model: str, hf_token: str, prompt: str, max_new_tokens: int = 512, temperature: float = 0.2, top_k: Optional[int] = None) -> str:
-    """
-    Call Hugging Face Inference API for text generation.
-    Returns the generated text (string) or an error message.
-    """
-    if not hf_token or hf_token.strip() == "":
-        return "[Error] No Hugging Face token provided. Please paste your HF token in the UI."
-
-    url = f"{HF_INFERENCE_URL}/{model}"
-    headers = {"Authorization": f"Bearer {hf_token}", "Content-Type": "application/json"}
-    payload = {"inputs": prompt, "parameters": {"max_new_tokens": max_new_tokens, "temperature": temperature}}
-    if top_k is not None:
-        payload["parameters"]["top_k"] = top_k
-
-    try:
-        resp = requests.post(url, headers=headers, json=payload, timeout=120)
-        resp.raise_for_status()
-        data = resp.json()
-        # handle different response shapes
-        if isinstance(data, list) and len(data) > 0:
-            first = data[0]
-            if isinstance(first, dict) and "generated_text" in first:
-                return first["generated_text"]
-            # sometimes it's raw text
-            return str(first)
-        if isinstance(data, dict):
-            if "generated_text" in data:
-                return data["generated_text"]
-            if "error" in data:
-                return "[HF Error] " + str(data["error"])
-            return json.dumps(data)
-        return str(data)
-    except requests.exceptions.HTTPError as e:
-        return f"[HF HTTP Error] {e} - {resp.text if 'resp' in locals() else ''}"
-    except Exception as e:
-        return f"[HF Error] {e}"
-
-
-# ---------------------- helpers ----------------------
-def detect_dangerous(text: str) -> Optional[str]:
-    lower = text.lower()
-    for k in DANGEROUS_KEYWORDS:
-        if k in lower:
-            return k
-    return None
-
-def build_prompt(task: str, lang: str, content: str, src_lang: Optional[str] = None) -> str:
-    tmpl = TASK_TEMPLATES.get(task, "{content}")
-    return tmpl.format(lang=lang, content=content, src_lang=src_lang or "")
-
-def ext_for_language(lang: str) -> str:
-    return LANG_EXT.get(lang, ".txt")
-
-def save_code_to_tempfile(code: str, filename_hint: str = "generated", ext: str = ".txt") -> str:
-    fd, path = tempfile.mkstemp(prefix=filename_hint + "_", suffix=ext)
-    with os.fdopen(fd, "w", encoding="utf-8") as f:
-        f.write(code)
-    return path
-
-# ---------------------- Gradio backends ----------------------
-def generate_code_task(task: str, hf_token: str, hf_model: str, language: str, src_language: str, description: str,
-                       temperature: float, max_new_tokens: int, top_k: int) -> Tuple[str, Optional[str]]:
-    """
-    Main generation entry: builds prompt, calls HF Inference, returns (code_str, download_path_or_None)
-    """
-    # security check
-    danger = detect_dangerous(description)
-    if danger:
-        return f"[Refused] Request contains potentially dangerous keyword: '{danger}'. Code generation aborted.", None
-
-    prompt = build_prompt(task, language, description, src_lang=src_language)
-    # Some code models do better if prompt includes an instruction header
-    instruction = f"# Instruction: {task} for language {language}\n# Begin\n{prompt}\n# End\n"
-    gen = call_hf_inference(hf_model, hf_token, instruction, max_new_tokens=max_new_tokens, temperature=temperature, top_k=(None if top_k==0 else top_k))
-
-    # If HF returns an error-like string, just return it
-    if isinstance(gen, str) and gen.startswith("[HF"):
-        return gen, None
-
-    # Trim any leading instruction repeats
-    code = gen.strip()
-    # If the model echoed the prompt, try to cut off the prompt portion
-    if instruction.strip() and code.startswith(instruction.strip()):
-        code = code[len(instruction.strip()):].strip()
-
-    # post-process: if model included explanation but we requested code-only, try to extract code block
-    if "```" in code:
-        # extract first fenced code block
-        parts = code.split("```")
-        if len(parts) >= 3:
-            # parts: [before, langinfo, code, ...] or [before, code, ...]
-            # find the longest code-like chunk
-            candidate = None
-            for i in range(1, len(parts), 2):
-                chunk = parts[i+0]
-                if len(chunk.strip()) > 0:
-                    candidate = chunk
-                    break
-            if candidate:
-                code = candidate.strip()
-
-    # Prepare downloadable file
-    ext = ext_for_language(language)
-    fname = f"code_{language.lower().replace(' ', '_')}{ext}"
-    path = save_code_to_tempfile(code, filename_hint="generated_code", ext=ext)
-    return code, path
-
-# ---------------------- UI components & logic ----------------------
-def do_generate(task, hf_token, hf_model, language, src_language, description, temperature, max_new_tokens, top_k):
-    # basic input validation
-    if not hf_token or hf_token.strip() == "":
-        return "[Error] Please paste your Hugging Face API token in the HF token field.", None
-    if not hf_model or hf_model.strip() == "":
-        return "[Error] Please enter a Hugging Face model name (e.g. bigcode/starcoder).", None
-    if not description or description.strip() == "":
-        return "[Error] Please provide a description or code to operate on.", None
-
-    code, path = generate_code_task(task, hf_token, hf_model, language, src_language, description, temperature, max_new_tokens, top_k)
-    return code, path
-
-# Helper: simple examples
-EXAMPLES = [
-    ("Generate code from description", "bigcode/starcoder", "Python", "", "A function that computes the nth Fibonacci number using dynamic programming and returns results as integers.", 0.2, 256, 0),
-    ("Translate code to another language", "bigcode/starcoder", "JavaScript", "Python", "def greet(name):\n    return f\"Hello, {name}!\"", 0.2, 256, 0),
-    ("Add unit tests", "bigcode/starcoder", "Python", "", "def add(a, b):\n    return a + b", 0.2, 256, 0),
-    ("Explain code", "bigcode/starcoder", "Go", "", 'package main\n\nimport "fmt"\n\nfunc main() {\n    fmt.Println("Hello world")\n}', 0.2, 256, 0),
-]
-
-def build_ui():
-    with gr.Blocks(title="Polyglot Code Generator (HF Inference)") as demo:
-        gr.Markdown("# 🚀 Polyglot Code Generator\nGenerate, translate, explain, refactor, test and document code in many languages using Hugging Face models.\n\n**Important:** paste your Hugging Face Inference API token below (Settings → Access Tokens on Hugging Face).")
-
-        with gr.Row():
-            with gr.Column(scale=3):
-                hf_token = gr.Textbox(label="Hugging Face API Token (paste here)", type="password", placeholder="hf_xxx...")
-                hf_model = gr.Textbox(label="HF model name", value=DEFAULT_HF_MODEL, placeholder="bigcode/starcoder or bigcode/starcoder-base")
-                task = gr.Dropdown(label="Task", choices=list(TASK_TEMPLATES.keys()), value="Generate code from description")
-                language = gr.Dropdown(label="Target language", choices=LANG_CHOICES, value="Python")
-                src_language = gr.Textbox(label="Source language (for translation)", placeholder="e.g. Python", value="")
-                description = gr.Textbox(label="Description / Input code", lines=8, placeholder="Describe the feature or paste the code to transform...")
-                temp = gr.Slider(label="temperature", minimum=0.0, maximum=1.0, value=0.2, step=0.05)
-                max_tokens = gr.Slider(label="max_new_tokens", minimum=16, maximum=2048, value=512, step=16)
-                top_k = gr.Slider(label="top_k (0 = default)", minimum=0, maximum=100, value=0, step=1)
-                gen_btn = gr.Button("Generate Code")
-
-                with gr.Accordion("Prompt templates & examples", open=False):
-                    gr.Markdown("Choose a task and the app will apply an appropriate prompt template. Examples below can be loaded into the inputs.")
-                    example_btns = []
-                    for ex in EXAMPLES:
-                        b = gr.Button(f"Load example: {ex[0]} → {ex[2]}")
-                        example_btns.append((b, ex))
-
-            with gr.Column(scale=2):
-                gr.Markdown("### Output")
-                code_out = gr.Code(value="", language="python", label="Generated Code / Explanation")
-                download_file = gr.File(label="Download generated file (click to download)")
-
-                with gr.Row():
-                    copy_btn = gr.Button("Copy to clipboard (browser)")  # gradio supports copy via JS, left as UI hint
-                    save_btn = gr.Button("Save as file (prepare download)")
-
-                gr.Markdown("### Quick actions")
-                explain_btn = gr.Button("Explain this code")  # convenience to re-run with Explain task
-
-        # Wiring
-        def load_example(example):
-            task_v, hf_mod, lang, src_lang, desc, temperature, max_new_tokens, top_k = example
-            return hf_mod, task_v, lang, src_lang, desc, temperature, max_new_tokens, top_k
-
-        # register example buttons
-        for btn, ex in example_btns:
-            btn.click(fn=load_example, inputs=None, outputs=[hf_model, task, language, src_language, description, temp, max_tokens, top_k], _js=None).then(lambda: None)
-
-        def prepare_and_generate(hf_token_val, hf_model_val, task_val, language_val, src_language_val, description_val, temp_val, max_tokens_val, top_k_val):
-            code, path = do_generate(task_val, hf_token_val, hf_model_val, language_val, src_language_val, description_val, temp_val, int(max_tokens_val), int(top_k_val))
-            # Set language for highlighter
-            lang_for_highlight = language_val.lower() if language_val else "text"
-            return code, path, lang_for_highlight
-
-        gen_btn.click(fn=prepare_and_generate,
-                      inputs=[hf_token, hf_model, task, language, src_language, description, temp, max_tokens, top_k],
-                      outputs=[code_out, download_file, code_out])  # last output used to set language attr
-
-        # Save file (prepare download) button: write latest code to temp file and return path
-        def save_generated_as_file(code_text, language_val):
-            if not code_text or code_text.strip() == "":
-                return None
-            ext = ext_for_language(language_val)
-            path = save_code_to_tempfile(code_text, filename_hint="generated_code", ext=ext)
-            return path
-
-        save_btn.click(fn=save_generated_as_file, inputs=[code_out, language], outputs=[download_file])
-
-        # Explain selected code quickly
-        def quick_explain(hf_token_val, hf_model_val, code_text, language_val, temp_val, max_tokens_val):
-            if not code_text or code_text.strip() == "":
-                return "[Error] No code to explain."
-            # reuse TASK_TEMPLATES explanation
-            prompt = build_prompt("Explain code", language_val, code_text)
-            return call_hf_inference(hf_model_val, hf_token_val, f"# Instruction: Explain code\n{prompt}\n", max_new_tokens=int(max_tokens_val), temperature=float(temp_val))
-
-        explain_btn.click(fn=quick_explain, inputs=[hf_token, hf_model, code_out, language, temp, max_tokens], outputs=[code_out])
-
-        gr.Markdown("---\n**Notes & safety**: This app calls the Hugging Face Inference API; keep your token private. The app refuses obviously destructive requests by simple keyword checks. Do not use generated code in production without review.")
-
-    return demo
-
-if __name__ == "__main__":
-    demo_app = build_ui()
-    demo_app.launch(server_name="0.0.0.0", share=False)
+# codegen_gradio_fixed.py
+import os
+import io
+import json
+import time
+import tempfile
+import requests
+import gradio as gr
+from typing import Tuple, Optional
+
+# ------------------ Configuration ------------------
+HF_INFERENCE_URL = "https://api-inference.huggingface.co/models"
+DEFAULT_HF_MODEL = "bigcode/starcoder"
+LANG_EXT = {
+    "Python": ".py", "JavaScript": ".js", "TypeScript": ".ts", "Go": ".go",
+    "Java": ".java", "C": ".c", "C++": ".cpp", "C#": ".cs", "Rust": ".rs",
+    "Kotlin": ".kt", "Swift": ".swift", "Ruby": ".rb", "PHP": ".php",
+    "Shell": ".sh", "PowerShell": ".ps1", "HTML": ".html", "CSS": ".css",
+    "SQL": ".sql", "R": ".r", "MATLAB": ".m", "Scala": ".scala",
+    "Haskell": ".hs", "Lua": ".lua", "Perl": ".pl", "Dart": ".dart",
+    "Elixir": ".ex", "Julia": ".jl", "Objective-C": ".m", "Assembly": ".s",
+    "Dockerfile": "Dockerfile", "JSON": ".json", "YAML": ".yml", "XML": ".xml"
+}
+
+# Dangerous keywords simple blacklist
+DANGEROUS_KEYWORDS = [
+    "rm -rf", "mkfs", "dd if=", "fork bomb", "shutdown", "reboot", "poweroff",
+    "create user", "adduser", "useradd", "passwd", "ssh -i", "cryptominer", "virus",
+    "malware", "ransomware", "keylogger", "inject", "exploit", "reverse shell",
+    "nc -e", "wget http", "curl http", "chmod 777 /", "sudo rm -rf /", ">: /dev/sda"
+]
+
+# Task templates
+TASK_TEMPLATES = {
+    "Generate code from description":
+        "Implement the following functionality in {lang}:\n\n{content}\n\n"
+        "Please provide only the code (no surrounding explanation).",
+    "Translate code to another language":
+        "Translate the following code from {src_lang} to {lang}. Keep behavior identical and include necessary imports.\n\n```{src_lang}\n{content}\n```",
+    "Explain code":
+        "Explain the following {lang} code. Provide a concise explanation, complexity notes, and potential pitfalls.\n\n```{lang}\n{content}\n```",
+    "Refactor code (readability/performance)":
+        "Refactor the following {lang} code for readability and performance. Keep behavior identical. Provide a 1-2 line summary of changes, then the refactored code only.\n\n```{lang}\n{content}\n```",
+    "Add unit tests":
+        "Write unit tests for the following {lang} code using a common testing framework (e.g., pytest for Python, jest for JS). Provide only the test code.\n\n```{lang}\n{content}\n```",
+    "Document & comment code":
+        "Add clear inline comments and a top-level docstring describing purpose, inputs, outputs, and side effects for this {lang} code. Provide the commented code only.\n\n```{lang}\n{content}\n```",
+    "Optimize for performance":
+        "Optimize the following {lang} code for performance while preserving behavior. Explain the optimization in 2-3 lines, then provide the optimized code only.\n\n```{lang}\n{content}\n```",
+    "Add type hints / static types":
+        "Add type annotations or static types to the following {lang} code where appropriate. Ensure the code remains valid.\n\n```{lang}\n{content}\n```",
+    "Create CLI tool":
+        "Create a command-line interface tool in {lang} that implements: {content}. Provide a complete script with argument parsing and a usage example."
+}
+
+# Model recommendations (HF model_name: (short description, compatibility notes))
+MODEL_RECOMMENDATIONS = {
+    "bigcode/starcoder": (
+        "StarCoder: Open-source model specialized for code generation and multi-language support.",
+        "Good for Python, JS, TypeScript and general-purpose code generation. May return large outputs."
+    ),
+    "bigcode/starcoder-base": (
+        "StarCoder-base: Lighter StarCoder variant with faster response but slightly lower fidelity.",
+        "Better for quick prototyping or smaller deployments."
+    ),
+    "bigcode/codegen-2B-multi": (
+        "CodeGen 2B (multi): Code generation model trained on multi-language corpora.",
+        "Good for many languages; 2B size balances performance and resource usage."
+    ),
+    "facebook/incoder-1B": (
+        "InCoder 1B: Autoregressive code model that supports code infilling and generation.",
+        "Smaller model appropriate for lower-resource environments; may require prompt engineering for best results."
+    ),
+    "codellama/CodeLlama-7b-Instruct": (
+        "CodeLlama 7B Instruct: Instruction-tuned CodeLlama model for code generation and explanation.",
+        "High-quality outputs but large (7B); requires sufficient memory or HF Inference API."
+    ),
+    "Salesforce/codegen-6B-mono": (
+        "CodeGen 6B Mono: Strong code generation model focused on mono-language generation.",
+        "Powerful but large; use HF Inference or a GPU-equipped local environment."
+    ),
+    "bigcode/starcoder-large": (
+        "StarCoder-large: Larger StarCoder variant for higher fidelity.",
+        "Best-quality among StarCoder variants but resource heavy."
+    )
+}
+
+# ------------------ Helpers ------------------
+def ext_for_language(lang: str) -> str:
+    return LANG_EXT.get(lang, ".txt")
+
+def detect_dangerous(text: str) -> Optional[str]:
+    if not text:
+        return None
+    lower = text.lower()
+    for k in DANGEROUS_KEYWORDS:
+        if k in lower:
+            return k
+    return None
+
+def build_prompt(task: str, lang: str, content: str, src_lang: Optional[str] = None) -> str:
+    tmpl = TASK_TEMPLATES.get(task, "{content}")
+    return tmpl.format(lang=lang, content=content, src_lang=src_lang or "")
+
+def save_code_to_tempfile(code: str, filename_hint: str = "generated_code", ext: str = ".txt") -> str:
+    fd, path = tempfile.mkstemp(prefix=filename_hint + "_", suffix=ext)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(code)
+    return path
+
+# ------------------ HF Inference call ------------------
+def call_hf_inference(model: str, hf_token: str, prompt: str, max_new_tokens: int = 512, temperature: float = 0.2, top_k: Optional[int] = None) -> str:
+    if not hf_token or not hf_token.strip():
+        return "[Error] No Hugging Face token provided."
+
+    url = f"{HF_INFERENCE_URL}/{model}"
+    headers = {"Authorization": f"Bearer {hf_token}", "Content-Type": "application/json"}
+    payload = {"inputs": prompt, "parameters": {"max_new_tokens": max_new_tokens, "temperature": temperature}}
+    if top_k and top_k > 0:
+        payload["parameters"]["top_k"] = top_k
+    try:
+        r = requests.post(url, headers=headers, json=payload, timeout=120)
+        r.raise_for_status()
+        data = r.json()
+        # common shapes: list with dicts or dict with generated_text
+        if isinstance(data, list) and len(data) > 0:
+            first = data[0]
+            if isinstance(first, dict) and "generated_text" in first:
+                return first["generated_text"]
+            return str(first)
+        if isinstance(data, dict):
+            if "generated_text" in data:
+                return data["generated_text"]
+            if "error" in data:
+                return "[HF Error] " + str(data["error"])
+            return json.dumps(data)
+        return str(data)
+    except requests.exceptions.HTTPError as e:
+        return f"[HF HTTP Error] {e} - {r.text if 'r' in locals() else ''}"
+    except Exception as e:
+        return f"[HF Error] {e}"
+
+# ------------------ Generation pipeline ------------------
+def generate_code_task(task: str, hf_token: str, hf_model: str, language: str, src_language: str, description: str,
+                       temperature: float, max_new_tokens: int, top_k: int) -> Tuple[str, Optional[str]]:
+    # security
+    danger = detect_dangerous(description)
+    if danger:
+        return f"[Refused] Request contains potentially dangerous keyword: '{danger}'.", None
+
+    prompt = build_prompt(task, language, description, src_lang=src_language)
+    instruction = f"# Instruction: {task} for language {language}\n# Begin\n{prompt}\n# End\n"
+    gen = call_hf_inference(hf_model, hf_token, instruction, max_new_tokens=max_new_tokens, temperature=temperature, top_k=(None if top_k == 0 else top_k))
+
+    if isinstance(gen, str) and gen.startswith("[HF"):
+        # error from HF
+        return gen, None
+
+    code = gen.strip()
+    # extract code fence content if present
+    if "```" in code:
+        parts = code.split("```")
+        # parts may be: before, ```lang\ncode\n```, ...
+        # find the first non-empty code-like chunk
+        candidate = None
+        for i in range(1, len(parts), 2):
+            chunk = parts[i].strip()
+            if len(chunk) > 0:
+                # if chunk starts with language id like "python\n", remove the first line
+                lines = chunk.splitlines()
+                if len(lines) > 1 and len(lines[0]) <= 20 and not lines[0].strip().startswith(("#", "//")) and not "(" in lines[0]:
+                    # treat as lang tag
+                    candidate = "\n".join(lines[1:]).strip()
+                else:
+                    candidate = chunk
+                break
+        if candidate:
+            code = candidate
+
+    # try to strip instruction echoes
+    if instruction.strip() and code.startswith(instruction.strip()):
+        code = code[len(instruction.strip()):].strip()
+
+    # fallback: ensure code not empty
+    if not code:
+        code = gen
+
+    ext = ext_for_language(language)
+    fname = f"code_{language.lower().replace(' ', '_')}{ext}"
+    path = save_code_to_tempfile(code, filename_hint="generated_code", ext=ext)
+    return code, path
+
+# ------------------ UI wiring ------------------
+EXAMPLES = [
+    ("Generate code from description", "bigcode/starcoder", "Python", "", "A function that returns the nth Fibonacci number using dynamic programming (iterative).", 0.2, 256, 0),
+    ("Translate code to another language", "bigcode/starcoder", "JavaScript", "Python", "def greet(name):\n    return f\"Hello, {name}!\"", 0.2, 256, 0),
+    ("Add unit tests", "bigcode/starcoder", "Python", "", "def add(a, b):\n    return a + b", 0.2, 256, 0),
+    ("Explain code", "bigcode/starcoder", "Go", "", 'package main\n\nimport "fmt"\n\nfunc main() {\n    fmt.Println("Hello world")\n}', 0.2, 256, 0),
+]
+
+def load_example_to_inputs(example):
+    # returns values matching the UI inputs order we will set
+    (task_v, hf_mod, lang, src_lang, desc, temperature, max_new_tokens, top_k) = example
+    return hf_mod, task_v, lang, src_lang, desc, temperature, max_new_tokens, top_k
+
+def do_generate(task, hf_token, hf_model, language, src_language, description, temperature, max_new_tokens, top_k):
+    if not hf_token or not hf_token.strip():
+        return "[Error] Please paste your Hugging Face API token.", None
+    if not hf_model or not hf_model.strip():
+        return "[Error] Please enter a Hugging Face model name.", None
+    if not description or not description.strip():
+        return "[Error] Please provide a description or code to operate on.", None
+    code, path = generate_code_task(task, hf_token, hf_model, language, src_language, description, temperature, int(max_new_tokens), int(top_k))
+    return code, path
+
+def save_generated_as_file(code_text, language_val):
+    if not code_text or code_text.strip() == "":
+        return None
+    ext = ext_for_language(language_val)
+    return save_code_to_tempfile(code_text, filename_hint="generated_code", ext=ext)
+
+# ------------------ Build Gradio UI ------------------
+def build_ui():
+    with gr.Blocks(title="Polyglot Code Generator (Hugging Face Inference)") as demo:
+        gr.Markdown("# 🚀 Polyglot Code Generator\nGenerate, translate, explain, refactor and test code in many languages using Hugging Face models.\n\nPaste your Hugging Face Inference API token below (Settings → Access Tokens on Hugging Face).")
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                hf_token = gr.Textbox(label="Hugging Face API Token (paste here)", type="password", placeholder="hf_xxx...")
+                # Model recommendation dropdown
+                model_choices = list(MODEL_RECOMMENDATIONS.keys())
+                hf_model = gr.Dropdown(label="Model (recommended)", choices=model_choices, value=DEFAULT_HF_MODEL)
+                model_info = gr.Markdown(value=f"**Model info:** {MODEL_RECOMMENDATIONS.get(DEFAULT_HF_MODEL)[0]}  \n_{MODEL_RECOMMENDATIONS.get(DEFAULT_HF_MODEL)[1]}_")
+
+                task = gr.Dropdown(label="Task", choices=list(TASK_TEMPLATES.keys()), value="Generate code from description")
+                language = gr.Dropdown(label="Target language", choices=list(LANG_EXT.keys()), value="Python")
+                src_language = gr.Textbox(label="Source language (for translation)", placeholder="e.g. Python", value="")
+                description = gr.Textbox(label="Description / Input code", lines=8, placeholder="Describe the feature or paste the code to transform...")
+                temp = gr.Slider(label="temperature", minimum=0.0, maximum=1.0, value=0.2, step=0.05)
+                max_tokens = gr.Slider(label="max_new_tokens", minimum=16, maximum=2048, value=512, step=16)
+                top_k = gr.Slider(label="top_k (0 = default)", minimum=0, maximum=100, value=0, step=1)
+
+                gen_btn = gr.Button("Generate Code")
+                with gr.Accordion("Examples", open=False):
+                    example_buttons = []
+                    for i, ex in enumerate(EXAMPLES):
+                        b = gr.Button(f"Load example: {ex[0]} → {ex[2]}")
+                        example_buttons.append((b, ex))
+
+            with gr.Column(scale=2):
+                gr.Markdown("### Output")
+                code_out = gr.Code(value="", language="python", label="Generated Code / Explanation")
+                download_file = gr.File(label="Download generated file")
+
+                with gr.Row():
+                    save_btn = gr.Button("Save as file (prepare download)")
+                    explain_btn = gr.Button("Explain selected code (quick action)")
+
+                gr.Markdown("### Quick tips")
+                gr.Markdown("- If the model echoes the prompt or includes explanation, the app will try to extract the first code block.\n- For best results use a code-capable HF model like `bigcode/starcoder` or `codellama/CodeLlama-7b-Instruct` via the Inference API.")
+
+        # Events
+        # Update model info when hf_model changes
+        def update_model_info(model_name):
+            info = MODEL_RECOMMENDATIONS.get(model_name)
+            if info:
+                return f"**Model info:** {info[0]}  \n_{info[1]}_"
+            else:
+                return "**Model info:** Unknown model. Compatibility depends on the model. Use a code-capable model."
+
+        hf_model.change(fn=update_model_info, inputs=[hf_model], outputs=[model_info])
+
+        # Example buttons wiring
+        for btn, ex in example_buttons:
+            btn.click(fn=load_example_to_inputs, inputs=None, outputs=[hf_model, task, language, src_language, description, temp, max_tokens, top_k], _js=None, _preprocess=False, _postprocess=False, args=[ex])
+
+        # Generate
+        gen_btn.click(fn=do_generate, inputs=[task, hf_token, hf_model, language, src_language, description, temp, max_tokens, top_k], outputs=[code_out, download_file])
+
+        # Save button
+        save_btn.click(fn=save_generated_as_file, inputs=[code_out, language], outputs=[download_file])
+
+        # Quick explain
+        def quick_explain(hf_token_val, hf_model_val, code_text, language_val, temp_val, max_tokens_val):
+            if not code_text or code_text.strip() == "":
+                return "[Error] No code to explain."
+            prompt = build_prompt("Explain code", language_val, code_text)
+            return call_hf_inference(hf_model_val, hf_token_val, f"# Instruction: Explain code\n{prompt}\n", max_new_tokens=int(max_tokens_val), temperature=float(temp_val))
+
+        explain_btn.click(fn=quick_explain, inputs=[hf_token, hf_model, code_out, language, temp, max_tokens], outputs=[code_out])
+
+        gr.Markdown("---\n**Safety note**: This app performs basic keyword checks to refuse obviously destructive requests. Always review generated code before running it in production.")
+
+    return demo
+
+if __name__ == "__main__":
+    demo = build_ui()
+    demo.launch(server_name="0.0.0.0", share=False)