Update app.py

app.py

@@ -1,18 +1,15 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+from huggingface_hub import AsyncInferenceClient
 from array import array
-import os
-import re
-import time
+from functools import lru_cache
+import os, re, time, asyncio
 
-# 1. API Configuration
+# 1. API Configuration - Switched to 1.5B for 4x faster cloud responses
 HF_TOKEN = os.getenv("HF_TOKEN")
-MODEL_ID = "Qwen/Qwen2.5-7B-Instruct"
+MODEL_ID = "Qwen/Qwen2.5-1.5B-Instruct" # Faster, leaner, demo-optimized
+client = AsyncInferenceClient(MODEL_ID, token=HF_TOKEN)
 
-client_primary = InferenceClient(MODEL_ID, token=HF_TOKEN)
-client_competitor = InferenceClient(MODEL_ID, token=HF_TOKEN)
-
-# 2. THE T3 KERNEL (Local Deterministic Logic)
+# 2. T3 High-Speed Logic Kernel (Local CPU Execution)
 class StateController:
     __slots__ = ("_state", "_rom60", "_symbols", "_rendered")
     def __init__(self):
@@ -21,7 +18,9 @@ class StateController:
         self._symbols    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"
         self._rendered   = "".join(" [NODE_120] " if i == 120 else ("<" if i % 10 == 0 else ".") for i in range(121))
 
+    @lru_cache(maxsize=128) # Optimization from your refactor
     def compute_distribution(self, total, nodes) -> str:
+        if nodes <= 0: return "Error: Node count must be positive."
         base, rem = divmod(total, nodes)
         res = f"T3 Logic Kernel resolved {total} units across {nodes} nodes:\n\n"
         for i in range(nodes):
@@ -31,49 +30,32 @@ class StateController:
     def get_glyphs(self) -> str:
         return f"Rendering 121-point state array:\n\n{self._rendered}\n\nSystem State: RESOLVED"
 
-    def validate_receipt(self, receipt, a, b, c) -> str:
-        idx = (self._rom60[a % 60][b % 60] ^ (c % 60)) % 60
-        expected = f"0{self._symbols[idx]}"
-        if receipt == expected:
-            return f"√ CHECKSUM VALID: Receipt {receipt} verified for allocation ({a}, {b}, {c})."
-        return f"× CHECKSUM INVALID: Expected {expected}, received {receipt}."
-
 controller = StateController()
 
-# 3. Telemetry Formatter (The Visual Upgrade)
 def format_telemetry(seconds: float) -> str:
-    if seconds < 0.001:
-        return f"{seconds * 1_000_000:.2f} \u03BCs" # Microseconds
-    elif seconds < 1:
-        return f"{seconds * 1_000:.2f} ms"        # Milliseconds
-    else:
-        return f"{seconds:.2f} s"                 # Seconds
+    if seconds < 0.001: return f"{seconds * 1_000_000:.2f} \u03BCs"
+    return f"{seconds * 1_000:.2f} ms" if seconds < 1 else f"{seconds:.2f} s"
 
-# 4. Core Response Logic
-def generate_responses(user_message, p_hist, c_hist):
+# 3. Hardened Dual-Response Logic (Async Optimized)
+async def generate_responses(user_message, p_hist, c_hist):
     msg = user_message.strip()
     if not msg: yield p_hist or [], c_hist or [], ""; return
 
-    p_hist = p_hist or []
-    c_hist = c_hist or []
-    p_hist.append({"role": "user", "content": msg})
-    p_hist.append({"role": "assistant", "content": ""})
-    c_hist.append({"role": "user", "content": msg})
-    c_hist.append({"role": "assistant", "content": ""})
+    p_hist, c_hist = p_hist or [], c_hist or []
+    p_hist.append({"role": "user", "content": msg}); p_hist.append({"role": "assistant", "content": ""})
+    c_hist.append({"role": "user", "content": msg}); c_hist.append({"role": "assistant", "content": ""})
     yield p_hist, c_hist, ""
     
     start_time = time.perf_counter()
 
-    # --- THE T3 INTERCEPTORS (Microsecond Local Path) ---
-    dist_match = re.search(r"(\d+)\s+units\s+across\s+(\d+)\s+nodes", msg, re.IGNORECASE)
-    diag_match = "diagnostic" in msg.lower() or "grid" in msg.lower()
-    rcpt_match = re.search(r"verify receipt\s+([a-zA-Z0-9]{2})\s+for\s+(\d+),\s*(\d+),\s*(\d+)", msg, re.IGNORECASE)
+    # --- HARDENED LOCAL INTERCEPTORS ---
+    # Using the refined regex from your refactor
+    dist_match = re.search(r"(?P<units>\d{1,9})\s+units\s+across\s+(?P<nodes>\d{1,4})\s+nodes", msg, re.I)
+    diag_match = any(kw in msg.lower() for kw in ["diagnostic", "grid"])
 
-    if dist_match or diag_match or rcpt_match:
+    if dist_match or diag_match:
         if dist_match:
-            res = controller.compute_distribution(int(dist_match.group(1)), int(dist_match.group(2)))
-        elif rcpt_match:
-            res = controller.validate_receipt(rcpt_match.group(1), int(rcpt_match.group(2)), int(rcpt_match.group(3)), int(rcpt_match.group(4)))
+            res = controller.compute_distribution(int(dist_match.group("units")), int(dist_match.group("nodes")))
         else:
             res = controller.get_glyphs()
         
@@ -81,50 +63,44 @@ def generate_responses(user_message, p_hist, c_hist):
         p_hist[-1]["content"] = f"{res}\n\n---\n*Telemetry: {format_telemetry(elapsed)} | Source: LOCAL T3 KERNEL*"
         yield p_hist, c_hist, ""
     else:
-        # Cloud API Fallback
+        # ASYNC PRIMARY STREAM
         try:
-            stream = client_primary.chat_completion(messages=[{"role":"system","content":"T3 Augmented Logic Engine"}] + p_hist[:-1], max_tokens=512, stream=True, temperature=0.1)
             res_text = ""
-            for chunk in stream:
+            async for chunk in client.chat_completion(messages=[{"role":"system","content":"Logic Engine"}] + p_hist[:-1], max_tokens=512, stream=True, temperature=0.1):
                 res_text += (chunk.choices[0].delta.content or "")
                 p_hist[-1]["content"] = res_text
                 yield p_hist, c_hist, ""
-            elapsed = time.perf_counter() - start_time
-            p_hist[-1]["content"] += f"\n\n---\n*Telemetry: {format_telemetry(elapsed)} | Source: AUGMENTED CLOUD*"
-            yield p_hist, c_hist, ""
+            p_hist[-1]["content"] += f"\n\n---\n*Telemetry: {format_telemetry(time.perf_counter()-start_time)} | Source: AUGMENTED CLOUD*"
         except Exception as e:
             p_hist[-1]["content"] = f"Primary Error: {str(e)}"
-            yield p_hist, c_hist, ""
+        yield p_hist, c_hist, ""
 
-    # --- COMPETITOR ENGINE (VANILLA CLOUD) ---
+    # ASYNC VANILLA STREAM
     comp_start = time.perf_counter()
-    c_hist[-1]["content"] = "*Routing through standard infrastructure...*"
+    c_hist[-1]["content"] = "*Routing...*"
     yield p_hist, c_hist, ""
     
     try:
-        stream = client_competitor.chat_completion(messages=[{"role":"system","content":"Vanilla AI"}] + c_hist[:-1], max_tokens=512, stream=True, temperature=0.7)
         res_text = ""
-        for chunk in stream:
+        async for chunk in client.chat_completion(messages=[{"role":"system","content":"Standard AI"}] + c_hist[:-1], max_tokens=512, stream=True, temperature=0.7):
             res_text += (chunk.choices[0].delta.content or "")
             c_hist[-1]["content"] = res_text
             yield p_hist, c_hist, ""
-        elapsed = time.perf_counter() - comp_start
-        c_hist[-1]["content"] += f"\n\n---\n*Telemetry: {format_telemetry(elapsed)} | Source: VANILLA CLOUD*"
-        yield p_hist, c_hist, ""
+        c_hist[-1]["content"] += f"\n\n---\n*Telemetry: {format_telemetry(time.perf_counter()-comp_start)} | Source: VANILLA CLOUD*"
     except Exception as e:
         c_hist[-1]["content"] = f"Competitor Error: {str(e)}"
-        yield p_hist, c_hist, ""
+    yield p_hist, c_hist, ""
 
-# 5. Interface Styling
+# 4. Interface Styling
 custom_css = "body, .gradio-container { background-color: #110c08 !important; color: #fb923c !important; } footer { display: none !important; }"
 
 with gr.Blocks() as demo:
     gr.Markdown("# [ GLYPH.IO ]\n### Dual-Engine Hardware Benchmark")
     p_chat = gr.Chatbot(label="Augmented Logic Kernel (T3 Architecture)", height=350)
     with gr.Row():
-        msg_in = gr.Textbox(label="Message", placeholder="Test math/logic tasks...", scale=8)
+        msg_in = gr.Textbox(label="Message", placeholder="Test P vs NP or Logistics Distribution...", scale=8)
         btn = gr.Button("Execute", scale=1, variant="primary")
-    gr.Examples(examples=["Run grid diagnostic", "Calculate distribution for 120 units across 3 nodes.", "Verify receipt 0e for 60, 30, 30"], inputs=msg_in)
+    gr.Examples(examples=["Define P vs. NP. Then validate a 120-unit distribution across 3 nodes.", "Run grid diagnostic"], inputs=msg_in)
     c_chat = gr.Chatbot(label="Vanilla Qwen 2.5 (Standard Infrastructure)", height=350)
 
     msg_in.submit(generate_responses, [msg_in, p_chat, c_chat], [p_chat, c_chat, msg_in])