Update app.py

app.py

@@ -1,10 +1,11 @@
 import os
-import psutil
+import subprocess
 import time
-import numpy as np
-import multiprocessing
+import requests
+import json
 import gradio as gr
-import spaces  # <-- Keep the import
+import spaces
+from huggingface_hub import hf_hub_download
 
 # 1. DUMMY GPU FUNCTION: satisfies the Hugging Face startup checker 
 # without wasting runtime resources or intercepting user execution.
@@ -16,114 +17,115 @@ def dummy_gpu():
 # Automatically execute it once right away during script interpretation
 dummy_gpu()
 
-def get_cpu_model():
-    try:
-        with open("/proc/cpuinfo", "r") as f:
-            for line in f:
-                if "model name" in line:
-                    return line.split(":")[1].strip()
-    except Exception as e:
-        return f"Could not read CPU model: {str(e)}"
-    return "Unknown CPU Model"
+# 2. DOWNLOAD MODEL & COMPILE LLAMA.CPP SERVER
+def setup_environment():
+    print("Downloading model...")
+    repo = "Abiray/MiniCPM5-1B-GGUF"
+    filename = "minicpm5-1b-Q6_K.gguf"
+    model_path = hf_hub_download(repo_id=repo, filename=filename)
+    print(f"Model downloaded to: {model_path}")
 
-def get_container_cpu_cores():
-    try:
-        with open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us", "r") as f:
-            quota = int(f.read().strip())
-        with open("/sys/fs/cgroup/cpu/cpu.cfs_period_us", "r") as f:
-            period = int(f.read().strip())
-        if quota > 0 and period > 0:
-            return quota / period
-    except Exception:
-        pass
-    try:
-        with open("/sys/fs/cgroup/cpu.max", "r") as f:
-            parts = f.read().strip().split()
-            if len(parts) == 2 and parts[0] != "max":
-                return int(parts[0]) / int(parts[1])
-    except Exception:
-        pass
-    return os.cpu_count() or 1
+    if not os.path.exists("llama.cpp/llama-server"):
+        print("llama-server binary not found. Cloning and compiling llama.cpp...")
+        subprocess.run("git clone https://github.com/ggerganov/llama.cpp.git", shell=True)
+        # Compile only the server binary to save time
+        subprocess.run("cd llama.cpp && make -j4 llama-server", shell=True)
+        print("Compilation finished!")
+    else:
+        print("llama.cpp already compiled.")
+        
+    return model_path
 
-def get_container_ram_limit():
-    for path in ["/sys/fs/cgroup/memory/memory.limit_in_bytes", "/sys/fs/cgroup/memory.max"]:
+# 3. START BACKGROUND SERVER
+def start_server(model_path):
+    # Using the exact parameters from your Dockerfile but pointing to local 8080 port
+    # so Gradio can occupy the main 7860 port safely.
+    cmd = [
+        "./llama.cpp/llama-server",
+        "-m", model_path,
+        "--host", "127.0.0.1",
+        "--port", "8080",
+        "-t", "2",
+        "--cache-type-k", "q8_0",
+        "--cache-type-v", "iq4_nl",
+        "-c", "131072",
+        "-n", "32000"
+    ]
+    
+    print("Booting local llama-server with command:")
+    print(" ".join(cmd))
+    
+    # Spawn server process in the background
+    server_process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+    
+    # Wait for the server to be healthy
+    print("Waiting for llama-server to initialize (this may take a moment due to the 131k context KV cache allocation)...")
+    for _ in range(120):
         try:
-            with open(path, "r") as f:
-                limit = int(f.read().strip())
-                if limit < 9223372036854771712:
-                    return limit / (1024 ** 2)
-        except Exception:
-            continue
-    return psutil.virtual_memory().total / (1024 ** 2)
+            response = requests.get("http://127.0.0.1:8080/health")
+            if response.status_code == 200:
+                print("llama-server is up and running!")
+                return server_process
+        except requests.exceptions.ConnectionError:
+            time.sleep(2)
+            
+    raise RuntimeError("Server failed to start within the timeout period. You may be hitting an OOM error due to the 131072 context size.")
 
-def stress_cpu_core(duration):
-    timeout = time.time() + duration
-    while time.time() < timeout:
-        _ = 123456789.0 * 987654321.0
+model_filepath = setup_environment()
+start_server(model_filepath)
 
-# NO @spaces.GPU DECORATOR HERE -> This runs purely on the space's base CPU container
-def run_heavy_benchmark():
-    log = []
+# 4. GRADIO UI TO INTERACT WITH LOCAL SERVER
+def chat_with_llama(message, history):
+    # Format history for OpenAI-compatible API
+    messages = [{"role": "system", "content": "You are a helpful AI assistant."}]
+    for user_msg, assistant_msg in history:
+        messages.append({"role": "user", "content": user_msg})
+        messages.append({"role": "assistant", "content": assistant_msg})
     
-    cpu_model = get_cpu_model()
-    reported_cores = os.cpu_count() or 1
-    cgroup_cores = get_container_cpu_cores()
-    allocated_ram = get_container_ram_limit()
+    messages.append({"role": "user", "content": message})
     
-    log.append("=== HOST & CONTAINER INITIAL SPECS ===")
-    log.append(f"CPU Model: {cpu_model}")
-    log.append(f"Total Cores Visible: {reported_cores}")
-    log.append(f"Cgroup Core Limit: {cgroup_cores:.2f}")
-    log.append(f"Total Allowed RAM Space: {allocated_ram:.1f} MB\n")
+    payload = {
+        "messages": messages,
+        "stream": True,
+        "temperature": 0.7
+    }
     
-    log.append("=== RAM STRESS TEST (Targeting 20 GB) ===")
     try:
-        log.append("Allocating continuous NumPy array...")
-        elements = 2500000000 
-        ram_hog = np.empty(elements, dtype=np.float64)
-        ram_hog.fill(7.0)
+        response = requests.post(
+            "http://127.0.0.1:8080/v1/chat/completions",
+            json=payload,
+            stream=True
+        )
         
-        process = psutil.Process(os.getpid())
-        current_ram = process.memory_info().rss / (1024 ** 2)
-        log.append(f"✅ Success! Managed to hold RAM without crash.")
-        log.append(f"Active App RAM State: {current_ram:.1f} MB")
-        
-        del ram_hog
-        log.append("Array successfully garbage collected.\n")
-    except MemoryError:
-        log.append("❌ Failed: Hit container hard Memory OOM ceiling.\n")
+        partial_response = ""
+        for line in response.iter_lines():
+            if line:
+                decoded_line = line.decode('utf-8')
+                if decoded_line.startswith("data: "):
+                    data_str = decoded_line[6:]
+                    if data_str == "[DONE]":
+                        break
+                    try:
+                        data = json.loads(data_str)
+                        if "choices" in data and len(data["choices"]) > 0:
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                partial_response += delta["content"]
+                                yield partial_response
+                    except json.JSONDecodeError:
+                        continue
     except Exception as e:
-        log.append(f"❌ Failed with unexpected exception: {str(e)}\n")
-
-    log.append("=== CPU MAX OUT TEST ===")
-    log.append(f"Spawning {reported_cores} distinct processes to bypass GIL...")
-    
-    processes = []
-    stress_duration = 6
-    
-    for _ in range(reported_cores):
-        p = multiprocessing.Process(target=stress_cpu_core, args=(stress_duration,))
-        processes.append(p)
-        p.start()
-        
-    time.sleep(2.0)
-    system_cpu = psutil.cpu_percent(interval=0.5)
-    log.append(f"Live measured core utilization: {system_cpu}%")
-    
-    for p in processes:
-        p.join()
-        
-    log.append("All stress tasks safely completed.")
-    return "\n".join(log)
+        yield f"Error communicating with local server: {str(e)}"
 
+# 5. LAUNCH GRADIO APP
 with gr.Blocks() as demo:
-    gr.Markdown("## Hugging Face Native CPU & Core Resource Profile Tester")
-    
-    run_btn = gr.Button("Execute Deep Diagnostics", variant="primary")
-    output_log = gr.Textbox(label="System Standard Output Log", lines=16)
+    gr.Markdown("# Native CPU `llama.cpp` Execution on ZeroGPU Space")
+    gr.Markdown(f"Running **MiniCPM5-1B-GGUF** natively using `llama-server` behind the scenes! Bypassing GPU logic entirely.")
     
-    run_btn.click(fn=run_heavy_benchmark, outputs=output_log)
+    gr.ChatInterface(
+        fn=chat_with_llama,
+        examples=["Who are you?", "Write a python script to reverse a string.", "Explain quantum computing."],
+    )
 
 if __name__ == "__main__":
-    multiprocessing.freeze_support()
-    demo.launch(server_name="0.0.0.0")
+    demo.launch(server_name="0.0.0.0", server_port=7860)