Upload coderX.py

coderX.py

@@ -0,0 +1,289 @@
+# 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)