Update app.py

app.py

@@ -1,145 +1,97 @@
-import asyncio
-import websockets
-import json
-import time
-import numpy as np
-from collections import deque
-from scipy.stats import entropy
-from statistics import mean, stdev
-
-# --- Config ---
-PAIR = 'BTCUSDT'
-VWAP_WINDOW = 20
-CVC_WINDOW = 30
-ENTRY_THRESHOLD = 0.85
-MAX_LATENCY_MS = 30
-
-# Internal buffers
-price_buffer_a, price_buffer_b = deque(maxlen=CVC_WINDOW), deque(maxlen=CVC_WINDOW)
-volume_buffer_a, volume_buffer_b = deque(maxlen=VWAP_WINDOW), deque(maxlen=VWAP_WINDOW)
-vwap_buffer_a, vwap_buffer_b = deque(maxlen=VWAP_WINDOW), deque(maxlen=VWAP_WINDOW)
-tick_times_a, tick_times_b = deque(maxlen=2), deque(maxlen=2)
-
-# --- Utility Functions ---
-def compute_vwap(prices, volumes):
-    return sum(p * v for p, v in zip(prices, volumes)) / sum(volumes) if volumes else 0
-
-def compute_entropy(distribution):
-    probs = np.array(distribution) / sum(distribution)
-    return entropy(probs) if all(probs) else 0
-
-def sigmoid(x): return 1 / (1 + np.exp(-x))
-
-# --- KPI Computation ---
-def compute_kpis(msg_a, msg_b):
-    t_a, t_b = msg_a['T'], msg_b['T']
-    latency = abs(t_a - t_b) / 1000
-
-    ask_a, bid_a = msg_a['a'], msg_a['b']
-    ask_b, bid_b = msg_b['a'], msg_b['b']
-
-    spread_eff = (ask_a - bid_a) / ((ask_a + bid_a) / 2)
-    micro_skew = (msg_a['bv'] - msg_a['av']) / max(msg_a['bv'] + msg_a['av'], 1e-9)
-
-    vwap_a = compute_vwap(price_buffer_a, volume_buffer_a)
-    vwap_b = compute_vwap(price_buffer_b, volume_buffer_b)
-    vwap_div = (vwap_a - vwap_b) / vwap_b if vwap_b else 0
-
-    ob_entropy = compute_entropy([msg_a['bv'], msg_a['av']])
-
-    if len(price_buffer_a) >= 2:
-        tick_velocity = (price_buffer_a[-1] - price_buffer_a[-2]) / (tick_times_a[-1] - tick_times_a[-2] + 1e-6)
-    else:
-        tick_velocity = 0
-
-    if len(volume_buffer_a) >= 2:
-        vdm = (volume_buffer_a[-1] - volume_buffer_a[-2]) / (tick_times_a[-1] - tick_times_a[-2] + 1e-6)
-    else:
-        vdm = 0
-
-    cvc = np.corrcoef(price_buffer_a, price_buffer_b)[0][1] if len(price_buffer_a) >= 2 else 0
-
-    # Combine into vector
-    return np.array([
-        spread_eff, latency, micro_skew,
-        vwap_div, ob_entropy, tick_velocity,
-        vdm, 0,  # placeholder for funding skew
-        cvc
-    ])
-
-def evaluate_entry(kpi_vector):
-    weights = np.array([1.0, -0.5, 1.0, 0.8, -0.6, 0.9, 0.8, 0.5, 1.0])
-    score = sigmoid(np.dot(weights, kpi_vector))
-    return score
-
-# --- WebSocket Handlers ---
-async def stream_gate():
-    uri = f"wss://api.gateio.ws/ws/v4/"
-    async with websockets.connect(uri) as ws:
-        payload = {
-            "time": int(time.time()),
-            "channel": "spot.trades",
-            "event": "subscribe",
-            "payload": [f"{PAIR.lower()}"]
-        }
-        await ws.send(json.dumps(payload))
-
-        async for msg in ws:
-            data = json.loads(msg)
-            if 'result' not in data or not isinstance(data['result'], list):
-                continue
-            trade = data['result'][0]
-            p = float(trade['price'])
-            v = float(trade['amount'])
-            t = int(trade['create_time_ms'])
-            tick_times_b.append(t / 1000)
-            price_buffer_b.append(p)
-            volume_buffer_b.append(v)
-
-async def stream_binance(handler_queue):
-    uri = f"wss://stream.binance.com:9443/ws/{PAIR.lower()}@bookTicker"
-    async with websockets.connect(uri) as ws:
-        async for msg in ws:
-            data = json.loads(msg)
-            tick = {
-                'T': data['u'],
-                'a': float(data['a']),
-                'b': float(data['b']),
-                'bv': random.uniform(100, 200),  # mock depth
-                'av': random.uniform(100, 200)   # mock depth
-            }
-            price = (tick['a'] + tick['b']) / 2
-            volume = random.uniform(1, 10)
-            tick_times_a.append(time.time())
-            price_buffer_a.append(price)
-            volume_buffer_a.append(volume)
-            await handler_queue.put(tick)
-
-# --- Coordination Loop ---
-async def monitor(handler_queue):
-    while True:
-        msg_a = await handler_queue.get()
-        msg_b = {
-            'T': int(tick_times_b[-1] * 1000),
-            'a': price_buffer_b[-1] + 0.5,
-            'b': price_buffer_b[-1] - 0.5,
-            'bv': random.uniform(50, 150),
-            'av': random.uniform(50, 150)
-        }
-        kpi_vector = compute_kpis(msg_a, msg_b)
-        score = evaluate_entry(kpi_vector)
-        print(f"E_t = {score:.3f} | KPIs = {np.round(kpi_vector, 4)}")
-        if score > ENTRY_THRESHOLD:
-            print(">>> Entry Signal Triggered")
-
-# --- Main Entrypoint ---
-async def main():
-    handler_queue = asyncio.Queue()
-    await asyncio.gather(
-        stream_binance(handler_queue),
-        stream_gate(),
-        monitor(handler_queue)
+import os, json, requests, torch
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+import gradio as gr
+
+def fetch_file(space_id, filename):
+    url = f"https://huggingface.co/spaces/{space_id}/raw/main/{filename}"
+    try:
+        r = requests.get(url, timeout=10)
+        return r.text if r.status_code == 200 else ""
+    except:
+        return ""
+
+def build_prompt(readme, code, reqs):
+    return f"""<s>[INST] You are a protocol intelligence model. Determine if this Hugging Face Space is monetized on-chain.
+
+Return strictly in this JSON format:
+{{
+  "is_revenue_ready": true|false,
+  "confidence": float,
+  "blockers": [ "reason 1", "reason 2" ],
+  "summary": "short summary"
+}}
+
+README:
+{readme}
+
+Code:
+{code}
+
+Dependencies:
+{reqs}
+[/INST]
+"""
+
+def run_audit(space_id, model_id):
+    readme = fetch_file(space_id, "README.md")
+    code = fetch_file(space_id, "app.py")
+    reqs = fetch_file(space_id, "requirements.txt")
+    prompt = build_prompt(readme, code, reqs)
+
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float32)
+        pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, max_new_tokens=512)
+        result = pipe(prompt)[0]["generated_text"]
+    except Exception as e:
+        return {"error": f"Model load failed: {str(e)}"}
+
+    try:
+        blob = result.split("{", 1)[1].rsplit("}", 1)[0]
+        js = json.loads("{" + blob + "}")
+        js["space_id"] = space_id
+        return js
+    except Exception as e:
+        return {"error": f"Output parse failed: {str(e)}", "raw": result}
+
+def batch_audit():
+    spaces = open("space_list.txt").read().splitlines()
+    os.makedirs("out/unified_audit", exist_ok=True)
+    model_id = "mistralai/Mistral-7B-Instruct-v0.1"
+    for sid in spaces:
+        result = run_audit(sid, model_id)
+        with open(f"out/unified_audit/{sid.replace('/', '__')}.json", "w") as f:
+            json.dump(result, f, indent=2)
+        print(f"✅ {sid}: {result.get('summary', result)}")
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# 🔍 HF Space Revenue Readiness Auditor (33x LLMs, No API Keys)")
+    sid = gr.Textbox(label="Space ID (e.g. username/space-name)")
+    model = gr.Dropdown(
+        label="Select LLM Model",
+        choices=[
+            "mistralai/Mistral-7B-Instruct-v0.1",
+            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "google/gemma-2b-it",
+            "microsoft/phi-2",
+            "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+            "NousResearch/Nous-Capybara-7B-V1",
+            "HuggingFaceH4/zephyr-7b-alpha",
+            "intel/neural-chat-7b-v3",
+            "tiiuae/falcon-rw-1b",
+            "EleutherAI/pythia-1.4b",
+            "EleutherAI/pythia-2.8b",
+            "Open-Orca/Mistral-7B-OpenOrca"
+            # Extend to full 33 here
+        ],
+        value="mistralai/Mistral-7B-Instruct-v0.1"
     )
+    run = gr.Button("Run Audit")
+    output = gr.JSON(label="Audit Result")
+    run.click(fn=run_audit, inputs=[sid, model], outputs=output)
+
+# Uncomment to run CLI batch:
+# batch_audit()
 
-if __name__ == "__main__":
-    asyncio.run(main())
+demo.launch()