Update app.py

app.py

@@ -3,232 +3,252 @@ from datetime import datetime
 from typing import Dict, List
 import os
 import json
+import uuid
 
-# =========================
+# ======================================================
 # CONFIGURATION
-# =========================
+# ======================================================
 
 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"
 
-# =========================
-# UTILITIES
-# =========================
+# ======================================================
+# PERSISTENCE & GOVERNANCE
+# ======================================================
 
-def load_history():
-    if os.path.exists(HISTORY_FILE):
-        with open(HISTORY_FILE, "r") as f:
+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):
-    history = load_history()
-    history.append(entry)
-    with open(HISTORY_FILE, "w") as f:
-        json.dump(history[-500:], f, indent=2)
+    hist = _load_file(HISTORY_FILE)
+    hist.append(entry)
+    _save_file(HISTORY_FILE, hist)
 
-def validate_api_key(key: str):
-    if key != API_KEY:
-        raise ValueError("Invalid API key")
+# ======================================================
+# SECURITY / LICENSING
+# ======================================================
 
-def watermark(confidence: float) -> str:
-    if confidence >= 0.9:
-        return "HIGH CONFIDENCE ✔"
-    if confidence >= 0.75:
-        return "MEDIUM CONFIDENCE ◼"
-    return "LOW CONFIDENCE ⚠"
+def validate_api_key(key: str) -> str:
+    if key not in LICENSE_TIERS:
+        raise ValueError("Invalid API key")
+    return LICENSE_TIERS[key]
+
+# ======================================================
+# LIVE MARKET FEED (SAFE STUB)
+# ======================================================
+
+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)
 
-# =========================
-# CORE ENGINE
-# =========================
+# ======================================================
+# CORE ECONOMIC ENGINE
+# ======================================================
 
-def harmonize_price(
-    synthetic_price: float,
-    physical_anchor: float,
-    lag_factor: float
-) -> Dict[str, float]:
-    correction = (synthetic_price - physical_anchor) * min(1.0, lag_factor)
-    harmonized = synthetic_price - correction
-    confidence = 1.0 - abs(correction) / max(synthetic_price, 1.0)
+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_index": round(synthetic_price, 2),
+        "synthetic_price": round(synthetic, 2),
+        "harmonized_price": round(harmonized, 2),
         "correction": round(-correction, 2),
-        "harmonized_price_index": round(harmonized, 2),
         "confidence": round(max(0.0, min(confidence, 1.0)), 2)
     }
 
-def accelerate_cashflow(
-    amount: float,
-    days_delay: int,
-    confidence: float
-) -> float:
+def accelerate_cashflow(amount: float, delay_days: int, confidence: float) -> float:
     base_rate = 0.03
-    risk_penalty = (1.0 - confidence) * 0.05
-    discount_rate = base_rate + risk_penalty
-    return round(amount / ((1 + discount_rate) ** (days_delay / 365)), 2)
-
-# =========================
-# SINGLE & BATCH RUNTIME
-# =========================
+    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"
+
+# ======================================================
+# CODEX MESH INTEGRATION
+# ======================================================
+
+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()
+    return payload
+
+# ======================================================
+# MAIN RUNTIME
+# ======================================================
 
 def codexflow_execute(
     commodity: str,
     synthetic_price: float,
     physical_price: float,
-    reporting_lag_days: int,
+    lag_days: int,
     api_key: str
 ) -> Dict:
-    validate_api_key(api_key)
 
-    lag_factor = min(reporting_lag_days / 10, 1.0)
-    harmonized = harmonize_price(
-        synthetic_price,
-        physical_price,
-        lag_factor
-    )
+    tier = validate_api_key(api_key)
+
+    lag_factor = min(lag_days / 10, 1.0)
+    harmonized = harmonize_price(synthetic_price, physical_price, lag_factor)
 
     accelerated = accelerate_cashflow(
-        harmonized["harmonized_price_index"],
-        reporting_lag_days,
+        harmonized["harmonized_price"],
+        lag_days,
         harmonized["confidence"]
     )
 
     result = {
-        "timestamp": datetime.utcnow().isoformat(),
         "engine": "CodexFlow ΩΞ",
+        "tier": tier,
         "commodity": commodity,
+        "timestamp": datetime.utcnow().isoformat(),
         "harmonized_state": harmonized,
-        "accelerated_cashflow_estimate": accelerated,
-        "confidence_watermark": watermark(harmonized["confidence"])
+        "accelerated_cashflow": accelerated,
+        "confidence_watermark": confidence_watermark(harmonized["confidence"])
     }
 
+    # Governance
     save_history(result)
-    return result
+    log_audit({
+        "event": "execution",
+        "tier": tier,
+        "commodity": commodity,
+        "time": result["timestamp"]
+    })
+
+    # Mesh propagation
+    return codex_mesh_broadcast(result)
+
+# ======================================================
+# BATCH EXECUTION
+# ======================================================
 
 def codexflow_batch(
     commodities: List[str],
-    synthetic_prices: List[float],
-    physical_prices: List[float],
     lag_days: int,
     api_key: str
 ) -> List[Dict]:
+
     validate_api_key(api_key)
     outputs = []
 
-    for c, s, p in zip(commodities, synthetic_prices, physical_prices):
+    for c in commodities:
+        synthetic = fetch_live_market_price(c)
+        physical = synthetic * 0.95  # conservative anchor
         outputs.append(
-            codexflow_execute(c, s, p, lag_days, api_key)
+            codexflow_execute(c, synthetic, physical, lag_days, api_key)
         )
-    return outputs
 
-# =========================
-# REST-LIKE API ENDPOINT
-# =========================
-
-def api_endpoint(payload: Dict) -> Dict:
-    return codexflow_execute(
-        payload["commodity"],
-        payload["synthetic_price"],
-        payload["physical_price"],
-        payload["reporting_lag_days"],
-        payload["api_key"]
-    )
+    return outputs
 
-# =========================
-# DASHBOARD HELPERS
-# =========================
+# ======================================================
+# INVESTOR DECK GENERATOR
+# ======================================================
 
-def get_history():
-    return load_history()
+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"
+            ]
+        }
+    }
 
-# =========================
-# GRADIO UI
-# =========================
+# ======================================================
+# UI
+# ======================================================
 
 with gr.Blocks() as demo:
-    gr.Markdown(
-        """
-        # CodexFlow ΩΞ Runtime  
-        **Autonomous Reality-Anchored Cashflow Acceleration Engine**
-
-        Features:
-        • API-key gated execution  
-        • Batch commodity processing  
-        • Confidence watermarking  
-        • Historical trend memory  
-        • REST-style JSON interface  
-        """
-    )
+    gr.Markdown("""
+    # CodexFlow ΩΞ  
+    **Autonomous Reality-Anchored Cashflow Operating System**
+    """)
 
     api_key = gr.Textbox(label="API Key", type="password")
 
-    with gr.Tab("Single Execution"):
-        commodity = gr.Dropdown(
-            ["Gold", "Iron Ore", "Crude Oil"],
-            label="Commodity"
-        )
-        synthetic_price = gr.Number(label="Synthetic Price Index", value=1000)
-        physical_price = gr.Number(label="Physical Price Anchor", value=950)
-        reporting_lag = gr.Slider(0, 30, value=7, step=1, label="Reporting Lag (Days)")
-        run_btn = gr.Button("Run CodexFlow")
-        output = gr.JSON()
+    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()
 
-        run_btn.click(
+        btn.click(
             codexflow_execute,
-            inputs=[
-                commodity,
-                synthetic_price,
-                physical_price,
-                reporting_lag,
-                api_key
-            ],
-            outputs=output
+            inputs=[commodity, synthetic_price, physical_price, lag, api_key],
+            outputs=out
         )
 
-    with gr.Tab("Batch Mode"):
-        commodities = gr.Textbox(
-            label="Commodities (comma-separated)",
-            value="Gold,Iron Ore,Crude Oil"
-        )
-        synthetic_prices = gr.Textbox(
-            label="Synthetic Prices (comma-separated)",
-            value="1000,1200,800"
-        )
-        physical_prices = gr.Textbox(
-            label="Physical Prices (comma-separated)",
-            value="950,1150,770"
-        )
-        lag_days = gr.Slider(0, 30, value=7, step=1, label="Reporting Lag (Days)")
+    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()
 
         batch_btn.click(
-            lambda c, s, p, l, k: codexflow_batch(
-                c.split(","),
-                list(map(float, s.split(","))),
-                list(map(float, p.split(","))),
-                l,
-                k
-            ),
-            inputs=[
-                commodities,
-                synthetic_prices,
-                physical_prices,
-                lag_days,
-                api_key
-            ],
+            codexflow_batch,
+            inputs=[commodities, lag_b, api_key],
             outputs=batch_out
         )
 
-    with gr.Tab("Historical Trends"):
-        hist_btn = gr.Button("Load History")
-        hist_out = gr.JSON()
-        hist_btn.click(get_history, outputs=hist_out)
+    with gr.Tab("Investor Deck"):
+        deck_btn = gr.Button("Generate Deck")
+        deck_out = gr.JSON()
+        deck_btn.click(generate_investor_deck, outputs=deck_out)
+
+    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)
 
-# =========================
+# ======================================================
 # HUGGING FACE DEPLOY PATCH
-# =========================
+# ======================================================
 
 if __name__ == "__main__":
     demo.launch(