Upload 5 files

app.py

@@ -1,52 +1,34 @@
-import spaces
 import gradio as gr
-from huggingface_hub import hf_hub_download
+from model_runner import ModelRunner
+from parser import parse_to_files
+from zip_util import make_zip_from_files
+import os
 
-# Download the GGUF model
-hf_hub_download(
-    repo_id="tHottie/NeuralDaredevil-8B-abliterated-Q4_K_M-GGUF",
-    filename="neuraldaredevil-8b-abliterated-q4_k_m-imat.gguf",
-    local_dir="./models"
-)
+# Path or model identifier for your GGUF model
+MODEL_PATH = os.environ.get("GGUF_MODEL_PATH", "path/to/your/model.gguf")
 
-@spaces.GPU(duration=120)
-def process_code_response(code_response):
-    # Process the code response to extract the relevant files
-    # For example, you could use a regular expression to find the file paths in the text
-    import re
-    file_paths = re.findall(r'file: (.+)', code_response)
-    
-    # Create a zip file with the extracted files
-    import zipfile
-    with zipfile.ZipFile('output.zip', 'w') as zip_file:
-        for file_path in file_paths:
-            zip_file.write(file_path)
+# Instantiate once
+runner = ModelRunner(MODEL_PATH)
 
-@spaces.GPU(duration=120)
-def respond(message):
-    # Call the GGUF model to generate a response
-    llm = Llama(
-        model_path=f"models/neuraldaredevil-8b-abliterated-q4_k_m-imat.gguf",
-        flash_attn=True,
-        n_gpu_layers=81,
-        n_batch=1024,
-        n_ctx=8192,
-    )
-    
-    # Process the response to extract code files
-    processed_response = process_code_response(message)
-    
-    return processed_response
+def process_and_zip(ai_response: str) -> str:
+    """
+    Given the pasted AI response, do model interpretation → parse → zip → return zip path
+    """
+    model_output = runner.interpret_code_description(ai_response)
+    file_list = parse_to_files(model_output)
+    zip_path = make_zip_from_files(file_list)
+    return zip_path
 
-def main():
-    interface = gr.Interface(
-        fn=respond,
-        inputs="text",
-        outputs="file",
-        title="GGUF Code Generator"
+with gr.Blocks() as demo:
+    gr.Markdown("### Paste your AI model response (with code descriptions) below")
+    input_box = gr.Textbox(lines=15, placeholder="Paste AI response here")
+    output_zip = gr.DownloadButton(
+        "Download code zip",
+        value=lambda resp: resp,  # will be provided after processing
     )
+    submit = gr.Button("Generate Code Bundle")
 
-    interface.launch()
+    # When clicked, run process_and_zip
+    submit.click(fn=process_and_zip, inputs=input_box, outputs=output_zip)
 
-if __name__ == "__main__":
-    main()
+demo.launch()

model_runner.py

@@ -0,0 +1,22 @@
+import os
+from llama_cpp import Llama  # assuming llama-cpp-python is used to run GGUF
+
+class ModelRunner:
+    def __init__(self, model_path: str):
+        # Initialize the model once
+        self.llm = Llama(model_path=model_path)
+
+    def interpret_code_description(self, prompt: str) -> str:
+        """
+        Given the pasted AI response (prompt), return the model’s parsing output
+        (e.g. JSON or a DSL).
+        """
+        # You may want to wrap the prompt with instructions
+        wrapped = (
+            "You are a code parser. The following is a description of multiple files with code. "
+            "Produce as output a JSON object mapping filenames to file contents. "
+            "If something is ambiguous, try your best.\n\n"
+            + prompt
+        )
+        resp = self.llm(prompt=wrapped, max_tokens=2048)
+        return resp["choices"][0]["text"]

parser.py

@@ -0,0 +1,30 @@
+import json
+import re
+from typing import List, Tuple, Dict
+
+def parse_to_files(model_output: str) -> List[Tuple[str, str]]:
+    """
+    Parses the model’s output (ideally JSON) to a list of (filename, content).
+    Fallback heuristics if output is not strictly JSON.
+    """
+    # First try JSON parsing
+    try:
+        obj = json.loads(model_output)
+        files = []
+        for fname, content in obj.items():
+            files.append((fname, content))
+        return files
+    except json.JSONDecodeError:
+        # fallback: look for patterns like:
+        # Filename: xyz.py \n```python\n ... \n```
+        pattern = r"Filename:\s*(?P<fname>[\w\.\-/]+)\s*```(?:[a-zA-Z0-9]*)\n(?P<code>[\s\S]*?)```"
+        matches = re.finditer(pattern, model_output)
+        files = []
+        for m in matches:
+            fname = m.group("fname").strip()
+            code = m.group("code")
+            files.append((fname, code))
+        if files:
+            return files
+        # ultimate fallback: write everything into a single file
+        return [("all_code.txt", model_output)]

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=3.0
+llama-cpp-python

zip_util.py

@@ -0,0 +1,38 @@
+import os
+import zipfile
+import uuid
+from typing import List, Tuple
+
+def make_zip_from_files(
+    files: List[Tuple[str, str]], 
+    zip_name: str = None, 
+    out_dir: str = "/tmp"
+) -> str:
+    """
+    Take a list of (filename, content) tuples, write them into a temp folder,
+    zip them, and return the path to the zip file.
+    """
+    if zip_name is None:
+        zip_name = f"code_bundle_{uuid.uuid4().hex}.zip"
+    zip_path = os.path.join(out_dir, zip_name)
+    # Make a temp working directory
+    temp_dir = os.path.join(out_dir, f"code_dir_{uuid.uuid4().hex}")
+    os.makedirs(temp_dir, exist_ok=True)
+
+    for fname, content in files:
+        # ensure subdirectories exist
+        full_path = os.path.join(temp_dir, fname)
+        os.makedirs(os.path.dirname(full_path), exist_ok=True)
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    # create zip
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for root, _, fnames in os.walk(temp_dir):
+            for f in fnames:
+                full = os.path.join(root, f)
+                # store relative path inside zip
+                rel = os.path.relpath(full, start=temp_dir)
+                zf.write(full, arcname=rel)
+
+    return zip_path