Update app.py

app.py

@@ -1,259 +1,222 @@
 import gradio as gr
+import os, json, time, uuid, hashlib, math, random
 from datetime import datetime
 from typing import Dict, List
-import os
-import json
-import uuid
 
 # ======================================================
-# CONFIGURATION
+# WHITE-LABEL / GLOBAL CONFIG
 # ======================================================
+BRAND = os.getenv("CODEX_BRAND", "CodexFlow ΩΞ")
+ORG   = os.getenv("CODEX_ORG",   "Codex Sovereign")
+CCY   = os.getenv("CODEX_CCY",   "USD")
+STATE_DIR = os.getenv("CODEX_STATE_DIR", "state")
+os.makedirs(STATE_DIR, exist_ok=True)
 
-API_KEY = os.environ.get("CODEXFLOW_API_KEY", "DEMO_KEY")
-LICENSE_TIERS = {
-    "DEMO_KEY": "demo",
-    "PRO_KEY": "pro",
-    "INSTITUTIONAL_KEY": "institutional"
-}
-HISTORY_FILE = "history.json"
-AUDIT_FILE = "audit_log.json"
+# Files
+HIST_F = f"{STATE_DIR}/history.json"
+AUD_F  = f"{STATE_DIR}/audit.json"
+USE_F  = f"{STATE_DIR}/usage.json"
+GRF_F  = f"{STATE_DIR}/causal_graph.json"
+PROV_F = f"{STATE_DIR}/provenance.json"
+STAT_F = f"{STATE_DIR}/system_state.json"
 
 # ======================================================
-# PERSISTENCE & GOVERNANCE
+# RBAC / QUOTAS
 # ======================================================
-
-def _load_file(path):
-    if os.path.exists(path):
-        with open(path, "r") as f:
-            return json.load(f)
-    return []
-
-def _save_file(path, data, limit=1000):
-    with open(path, "w") as f:
-        json.dump(data[-limit:], f, indent=2)
-
-def log_audit(entry: Dict):
-    audit = _load_file(AUDIT_FILE)
-    audit.append(entry)
-    _save_file(AUDIT_FILE, audit)
-
-def save_history(entry: Dict):
-    hist = _load_file(HISTORY_FILE)
-    hist.append(entry)
-    _save_file(HISTORY_FILE, hist)
+API_KEYS = {
+    "DEMO_KEY": {"tier":"demo","quota":50},
+    "PRO_KEY": {"tier":"pro","quota":500},
+    "INSTITUTIONAL_KEY": {"tier":"institutional","quota":50000},
+    "SOVEREIGN_KEY": {"tier":"sovereign","quota":10**9},
+}
 
 # ======================================================
-# SECURITY / LICENSING
+# STORAGE UTILS
 # ======================================================
+def _load(p, d=None):
+    if os.path.exists(p):
+        with open(p,"r") as f: return json.load(f)
+    return [] if d is None else d
 
-def validate_api_key(key: str) -> str:
-    if key not in LICENSE_TIERS:
-        raise ValueError("Invalid API key")
-    return LICENSE_TIERS[key]
+def _save(p, data, lim=5000):
+    with open(p,"w") as f: json.dump(data[-lim:], f, indent=2)
 
 # ======================================================
-# LIVE MARKET FEED (SAFE STUB)
+# SECURITY / RBAC
 # ======================================================
-
-def fetch_live_market_price(commodity: str) -> float:
-    """
-    Stub for live feeds.
-    Replace with exchange / data-provider API.
-    """
-    base_prices = {
-        "Gold": 1000,
-        "Iron Ore": 1200,
-        "Crude Oil": 800
-    }
-    return base_prices.get(commodity, 1000)
+def _use_key(k):
+    if k not in API_KEYS: raise ValueError("Invalid API key")
+    usage=_load(USE_F,[])
+    if sum(1 for u in usage if u["k"]==k)>=API_KEYS[k]["quota"]:
+        raise ValueError("Quota exceeded")
+    usage.append({"k":k,"t":time.time()}); _save(USE_F,usage)
+    return API_KEYS[k]["tier"]
 
 # ======================================================
-# CORE ECONOMIC ENGINE
+# CRYPTO PROVENANCE (HASH-CHAIN)
 # ======================================================
-
-def harmonize_price(synthetic: float, physical: float, lag: float) -> Dict:
-    correction = (synthetic - physical) * min(1.0, lag)
-    harmonized = synthetic - correction
-    confidence = 1.0 - abs(correction) / max(synthetic, 1.0)
-
-    return {
-        "synthetic_price": round(synthetic, 2),
-        "harmonized_price": round(harmonized, 2),
-        "correction": round(-correction, 2),
-        "confidence": round(max(0.0, min(confidence, 1.0)), 2)
-    }
-
-def accelerate_cashflow(amount: float, delay_days: int, confidence: float) -> float:
-    base_rate = 0.03
-    risk_adj = (1 - confidence) * 0.05
-    rate = base_rate + risk_adj
-    return round(amount / ((1 + rate) ** (delay_days / 365)), 2)
-
-def confidence_watermark(c: float) -> str:
-    if c >= 0.9: return "AAA – High Confidence"
-    if c >= 0.75: return "AA – Medium Confidence"
-    return "A – Caution"
+def _h(obj): return hashlib.sha256(json.dumps(obj,sort_keys=True).encode()).hexdigest()
+def attest(payload):
+    prov=_load(PROV_F,[])
+    prev=prov[-1]["hash"] if prov else "GENESIS"
+    att={"id":str(uuid.uuid4()),"time":datetime.utcnow().isoformat(),
+         "prev":prev,"hash":_h({**payload,"prev":prev})}
+    prov.append(att); _save(PROV_F,prov)
+    payload["provenance"]=att; return payload
 
 # ======================================================
-# CODEX MESH INTEGRATION
+# MESH / FEDERATION (HOOKS)
 # ======================================================
-
-def codex_mesh_broadcast(payload: Dict):
-    """
-    Mesh-ready broadcast stub.
-    Replace with real message bus / federation layer.
-    """
-    payload["mesh_id"] = f"mesh-{uuid.uuid4()}"
-    payload["mesh_timestamp"] = datetime.utcnow().isoformat()
+def mesh_node(): return hashlib.sha256(os.getenv("HOSTNAME","codex-node").encode()).hexdigest()[:16]
+def mesh_broadcast(payload):
+    payload["mesh"]={"node":mesh_node(),"msg":str(uuid.uuid4()),
+                     "time":datetime.utcnow().isoformat()}
+    # hook: Kafka/Pulsar/Webhook
     return payload
 
 # ======================================================
-# MAIN RUNTIME
+# DATA ADAPTERS
 # ======================================================
+def exchange_price(commodity):
+    base={"Gold":1000,"Iron Ore":1200,"Crude Oil":800}
+    return round(base.get(commodity,1000)+random.uniform(-6,6),2)
 
-def codexflow_execute(
-    commodity: str,
-    synthetic_price: float,
-    physical_price: float,
-    lag_days: int,
-    api_key: str
-) -> Dict:
+def producer_state(commodity):
+    return {"commodity":commodity,
+            "output_tpd":random.randint(8000,15000),
+            "inventory_t":random.randint(20000,60000),
+            "logistics":random.choice(["normal","tight"]),
+            "energy":random.choice(["stable","volatile"])}
 
-    tier = validate_api_key(api_key)
+# ======================================================
+# CAUSAL GRAPH + ANOMALY
+# ======================================================
+def update_graph(commodity, distortion, lag):
+    g=_load(GRF_F,[])
+    g.append({"c":commodity,"d":distortion,"lag":lag,
+              "t":datetime.utcnow().isoformat()})
+    _save(GRF_F,g)
 
-    lag_factor = min(lag_days / 10, 1.0)
-    harmonized = harmonize_price(synthetic_price, physical_price, lag_factor)
+def is_anomaly(dist): return abs(dist)>0.15
 
-    accelerated = accelerate_cashflow(
-        harmonized["harmonized_price"],
-        lag_days,
-        harmonized["confidence"]
-    )
+# ======================================================
+# AUTONOMOUS MATHEMATICAL LOGIC
+# ======================================================
+# State evolves via a stabilizing gradient flow:
+#   x_{t+1} = x_t - η ∇E(x_t)
+# Energy E penalizes distortion, lag, and low confidence.
+def _state():
+    return _load(STAT_F, {"eta":0.2,"bias":0.0})
 
-    result = {
-        "engine": "CodexFlow ΩΞ",
-        "tier": tier,
-        "commodity": commodity,
-        "timestamp": datetime.utcnow().isoformat(),
-        "harmonized_state": harmonized,
-        "accelerated_cashflow": accelerated,
-        "confidence_watermark": confidence_watermark(harmonized["confidence"])
-    }
+def _save_state(s): _save(STAT_F,[s],lim=1)
 
-    # Governance
-    save_history(result)
-    log_audit({
-        "event": "execution",
-        "tier": tier,
-        "commodity": commodity,
-        "time": result["timestamp"]
-    })
+def energy(dist, lag, conf):
+    return (dist**2) + 0.01*(lag**2) + (1-conf)**2
 
-    # Mesh propagation
-    return codex_mesh_broadcast(result)
+def update_state(dist, lag, conf):
+    s=_state()
+    grad = 2*dist + 0.02*lag - 2*(1-conf)
+    s["bias"] = max(-0.2, min(0.2, s["bias"] - s["eta"]*grad))
+    _save_state(s); return s
 
 # ======================================================
-# BATCH EXECUTION
+# ECONOMIC CORE
 # ======================================================
+def harmonize(synth, phys, lag):
+    lagf=min(lag/10,1.0)
+    corr=(synth-phys)*lagf
+    harm=synth-corr
+    conf=max(0.0,1-abs(corr)/max(synth,1.0))
+    return round(harm,2), round(-corr,2), round(conf,2)
 
-def codexflow_batch(
-    commodities: List[str],
-    lag_days: int,
-    api_key: str
-) -> List[Dict]:
+def accelerate(val, lag, conf):
+    r=0.03+(1-conf)*0.05
+    return round(val/((1+r)**(lag/365)),2)
 
-    validate_api_key(api_key)
-    outputs = []
+def grade(conf): return "AAA" if conf>=0.9 else "AA" if conf>=0.75 else "A"
 
-    for c in commodities:
-        synthetic = fetch_live_market_price(c)
-        physical = synthetic * 0.95  # conservative anchor
-        outputs.append(
-            codexflow_execute(c, synthetic, physical, lag_days, api_key)
-        )
+def scenarios(base):
+    return {"optimistic":round(base*1.05,2),
+            "baseline":round(base,2),
+            "stress":round(base*0.9,2)}
 
-    return outputs
+def treasury_controls(tier, conf):
+    if tier=="sovereign":
+        return {"gate":"open","policy_cap":"sovereign","floor":0.7}
+    return {"gate":"market","policy_cap":tier,"floor":0.75 if tier!="demo" else 0.8}
 
-# ======================================================
-# INVESTOR DECK GENERATOR
-# ======================================================
-
-def generate_investor_deck() -> Dict:
-    return {
-        "CodexFlow": {
-            "Problem": "Synthetic price distortion & cashflow delay",
-            "Solution": "Reality-anchored harmonization + time compression",
-            "Moat": "Trust, auditability, physical anchoring",
-            "Revenue": [
-                "Licensing tiers",
-                "Transaction fees",
-                "Institutional APIs"
-            ],
-            "Target Clients": [
-                "Producers",
-                "Banks",
-                "Treasuries",
-                "Exchanges"
-            ]
-        }
-    }
+def regulatory(entry):
+    return {"engine":BRAND,"org":ORG,"time":entry["timestamp"],
+            "commodity":entry["commodity"],
+            "harmonized_price":entry["harmonized_price"],
+            "confidence":entry["confidence"],
+            "mesh_node":entry["mesh"]["node"],
+            "prov_hash":entry["provenance"]["hash"]}
 
 # ======================================================
-# UI
+# MAIN RUNTIME (AUTONOMOUS)
 # ======================================================
+def run(commodity, physical_anchor, lag_days, api_key, use_live):
+    tier=_use_key(api_key)
+    synth=exchange_price(commodity) if use_live else round(physical_anchor*1.05,2)
+    prod=producer_state(commodity)
 
-with gr.Blocks() as demo:
-    gr.Markdown("""
-    # CodexFlow ΩΞ  
-    **Autonomous Reality-Anchored Cashflow Operating System**
-    """)
-
-    api_key = gr.Textbox(label="API Key", type="password")
-
-    with gr.Tab("Single Run"):
-        commodity = gr.Dropdown(["Gold", "Iron Ore", "Crude Oil"])
-        synthetic_price = gr.Number(label="Synthetic Price")
-        physical_price = gr.Number(label="Physical Anchor")
-        lag = gr.Slider(0, 30, value=7, step=1)
-        btn = gr.Button("Execute")
-        out = gr.JSON()
-
-        btn.click(
-            codexflow_execute,
-            inputs=[commodity, synthetic_price, physical_price, lag, api_key],
-            outputs=out
-        )
+    harm, dist, conf = harmonize(synth, physical_anchor, lag_days)
+    # autonomous bias correction
+    st=update_state(abs(dist), lag_days, conf)
+    harm=round(harm*(1+st["bias"]),2)
 
-    with gr.Tab("Batch / Live Mode"):
-        commodities = gr.CheckboxGroup(["Gold", "Iron Ore", "Crude Oil"])
-        lag_b = gr.Slider(0, 30, value=7)
-        batch_btn = gr.Button("Run Batch")
-        batch_out = gr.JSON()
+    accel=accelerate(harm, lag_days, conf)
+    update_graph(commodity, dist, lag_days)
 
-        batch_btn.click(
-            codexflow_batch,
-            inputs=[commodities, lag_b, api_key],
-            outputs=batch_out
-        )
+    res={
+        "engine":BRAND,"org":ORG,"tier":tier,"ccy":CCY,
+        "timestamp":datetime.utcnow().isoformat(),
+        "commodity":commodity,
+        "synthetic_price":synth,
+        "physical_anchor":physical_anchor,
+        "harmonized_price":harm,
+        "distortion":dist,
+        "confidence":conf,
+        "grade":grade(conf),
+        "accelerated_cashflow":accel,
+        "anomaly":is_anomaly(dist),
+        "producer":prod,
+        "scenarios":scenarios(harm),
+        "treasury":treasury_controls(tier,conf),
+        "state":st
+    }
 
-    with gr.Tab("Investor Deck"):
-        deck_btn = gr.Button("Generate Deck")
-        deck_out = gr.JSON()
-        deck_btn.click(generate_investor_deck, outputs=deck_out)
+    hist=_load(HIST_F,[]); hist.append(res); _save(HIST_F,hist)
+    aud=_load(AUD_F,[]); aud.append(res); _save(AUD_F,aud)
 
-    with gr.Tab("Audit Log"):
-        audit_btn = gr.Button("View Audit")
-        audit_out = gr.JSON()
-        audit_btn.click(lambda: _load_file(AUDIT_FILE), outputs=audit_out)
+    res=mesh_broadcast(res)
+    res=attest(res)
+    res["regulatory_export"]=regulatory(res)
+    return res
 
 # ======================================================
-# HUGGING FACE DEPLOY PATCH
+# UI (HF SPACES)
 # ======================================================
-
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        ssr_mode=False
-    )
+with gr.Blocks() as demo:
+    gr.Markdown(f"# {BRAND}\n**Autonomous Economic Reflex OS**")
+    api=gr.Textbox(label="API Key", type="password")
+    com=gr.Dropdown(["Gold","Iron Ore","Crude Oil"], label="Commodity")
+    phys=gr.Number(950, label="Physical Anchor")
+    lag=gr.Slider(0,30,7,1,label="Reporting Lag (Days)")
+    live=gr.Checkbox(True,label="Use Live Exchange Feed")
+    btn=gr.Button("Execute"); out=gr.JSON()
+    btn.click(run, inputs=[com,phys,lag,api,live], outputs=out)
+
+    with gr.Tab("Audit"):
+        gr.Button("Load").click(lambda:_load(AUD_F,[]), outputs=gr.JSON())
+    with gr.Tab("Causal Graph"):
+        gr.Button("Load").click(lambda:_load(GRF_F,[]), outputs=gr.JSON())
+    with gr.Tab("Provenance"):
+        gr.Button("Load").click(lambda:_load(PROV_F,[]), outputs=gr.JSON())
+
+# ======================================================
+# HF DEPLOY PATCH
+# ======================================================
+if __name__=="__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True, ssr_mode=False)