Upload 7 files

app.py

@@ -0,0 +1,25 @@
+import gradio as gr
+from model_wrapper import CodeDebuggerWrapper
+
+# instantiate once (will download model)
+debugger = CodeDebuggerWrapper()
+
+def debug_code(code: str):
+    if not code or not code.strip():
+        return "❌ Please paste some code to debug."
+    try:
+        return debugger.debug(code)
+    except Exception as e:
+        # friendly error message
+        return f"Error during model inference:\n{e}"
+
+with gr.Blocks() as demo:
+    gr.Markdown("## 🐞 AI Code Debugger (Fine-tuned)")
+    gr.Markdown("Paste Python code below and click **Debug Code**. Uses your fine-tuned HF model.")
+    code_input = gr.Textbox(lines=14, placeholder="Paste Python code here...", label="Input Code")
+    output = gr.Textbox(lines=14, label="Debugged Code / Output")
+    btn = gr.Button("Debug Code")
+    btn.click(fn=debug_code, inputs=code_input, outputs=output)
+
+if __name__ == "__main__":
+    demo.launch(share=True)

config.yml

@@ -0,0 +1,7 @@
+jtype: CodeDebugger
+py_modules:
+  - executor.py
+metas:
+  name: code-debugger
+  description: "Executor that debugs AI/ML code using a fine-tuned model."
+  version: 0.1.0

executor.py

@@ -0,0 +1,67 @@
+import threading
+import os
+from jina import Executor, requests
+from docarray import BaseDoc, DocList
+
+# transformers imports are done lazily in _ensure_model to prevent heavy import on module load
+class CodeInput(BaseDoc):
+    code: str
+
+class CodeOutput(BaseDoc):
+    result: str
+
+class CodeDebugger(Executor):
+    """
+    Jina Executor that lazy-loads a Hugging Face seq2seq model on first request.
+    Use environment variable JINA_SKIP_MODEL_LOAD=1 to skip model loading (useful in CI/builds).
+    """
+    def __init__(self, model_name: str = "Girinath11/aiml_code_debug_model", **kwargs):
+        super().__init__(**kwargs)
+        self.model_name = model_name
+        self._lock = threading.Lock()
+        self.tokenizer = None
+        self.model = None
+        # optional: allow overriding max_new_tokens via env var
+        self.max_new_tokens = int(os.environ.get("MAX_NEW_TOKENS", "256"))
+
+    def _ensure_model(self):
+        """
+        Load tokenizer & model once in a thread-safe manner.
+        If JINA_SKIP_MODEL_LOAD is set to "1", skip loading (helpful for hub builds).
+        """
+        skip = os.environ.get("JINA_SKIP_MODEL_LOAD", "0") == "1"
+        if skip:
+            self.logger.warning("JINA_SKIP_MODEL_LOAD=1 set — skipping HF model load.")
+            return
+
+        if self.model is None or self.tokenizer is None:
+            from transformers import AutoTokenizer, AutoModelForSeq2SeqLM  # lazy import
+            with self._lock:
+                if self.model is None or self.tokenizer is None:
+                    self.logger.info(f"Loading model {self.model_name} ...")
+                    # If HF_TOKEN is set, transformers will use it automatically via huggingface-cli login
+                    self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+                    self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
+                    self.logger.info("Model loaded successfully.")
+
+    @requests
+    def debug(self, docs: DocList[CodeInput], **kwargs) -> DocList[CodeOutput]:
+        # Lazy load model at request time
+        self._ensure_model()
+
+        results = []
+        if self.model is None or self.tokenizer is None:
+            # If model was skipped, return a helpful message
+            for _ in docs:
+                results.append(CodeOutput(result="Model not loaded (JINA_SKIP_MODEL_LOAD=1)."))
+            return DocList[CodeOutput](results)
+
+        for doc in docs:
+            # make sure input is string
+            code_text = doc.code if isinstance(doc.code, str) else str(doc.code)
+            inputs = self.tokenizer(code_text, return_tensors="pt", padding=True, truncation=True)
+            outputs = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+            result = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            results.append(CodeOutput(result=result))
+
+        return DocList[CodeOutput](results)

mainfest.yml

@@ -0,0 +1,8 @@
+name: girinath11/code-debugger
+description: Debug Python code using a fine-tuned Hugging Face model.
+keywords: [code, debug, huggingface, aiml, transformer, T5, LLM, bug-fix, python]
+tags: [bug-fix, python, transformer, code-debugger]
+version: 0.1.0
+license: apache-2.0
+url: https://github.com/Giri530/jina-code-debugger
+author: Girinath V <girinathv48@gmail.com>

model_wrapper.py

@@ -0,0 +1,38 @@
+import os
+import threading
+
+class CodeDebuggerWrapper:
+    """
+    Simple wrapper that loads the same HF model and exposes debug(code: str) -> str
+    This is used by app.py (Gradio).
+    """
+    def __init__(self, model_name: str = "Girinath11/aiml_code_debug_model"):
+        self.model_name = model_name
+        self._lock = threading.Lock()
+        self.tokenizer = None
+        self.model = None
+        self.max_new_tokens = int(os.environ.get("MAX_NEW_TOKENS", "256"))
+        self._ensure_model()
+
+    def _ensure_model(self):
+        # allow skipping in environments where you don't want to download weights
+        skip = os.environ.get("SKIP_MODEL_LOAD", "0") == "1"
+        if skip:
+            print("SKIP_MODEL_LOAD=1 -> not loading model.")
+            return
+
+        if self.model is None or self.tokenizer is None:
+            from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+            with self._lock:
+                if self.model is None or self.tokenizer is None:
+                    print(f"Loading model {self.model_name} ...")
+                    self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+                    self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
+                    print("Model loaded.")
+
+    def debug(self, code: str) -> str:
+        if self.model is None or self.tokenizer is None:
+            return "Model not loaded. Set SKIP_MODEL_LOAD=0 and ensure HF token is available if model is private."
+        inputs = self.tokenizer(code, return_tensors="pt", padding=True, truncation=True)
+        outputs = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

readme.md

@@ -0,0 +1,20 @@
+# 🐞 AI Code Debugger — Executor + Gradio App
+
+This repository contains:
+- `executor.py` — a **Jina Executor** (lazy-loads your HF model).
+- `model_wrapper.py` — simple wrapper used by the Gradio app.
+- `app.py` — a Gradio UI (suitable for Hugging Face Spaces or local run).
+- `manifest.yml` & `config.yml` — metadata for Jina Hub.
+- `requirements.txt` — dependencies.
+
+## Model
+This uses your fine-tuned model:
+`Girinath11/aiml_code_debug_model` on Hugging Face.
+**If the model is private**, set `HF_TOKEN` or run `huggingface-cli login` on the host to allow downloads.
+
+---
+
+## Run locally (quick)
+1. Install deps:
+```bash
+pip install -r requirements.txt

requirements.txt

@@ -0,0 +1,14 @@
+# Core
+transformers>=4.41.1
+torch
+
+# Jina executor / testing
+jina>=3.21.1
+docarray>=0.38.0
+
+# Web UI (Gradio) & HF CLI
+gradio
+huggingface_hub
+
+# Optional: for nicer logs in some environments
+tqdm