Update app.py

app.py

@@ -1,10 +1,45 @@
 import gradio as gr
 from datetime import datetime
-from typing import Dict
+from typing import Dict, List
+import os
+import json
 
+# =========================
+# CONFIGURATION
+# =========================
+
+API_KEY = os.environ.get("CODEXFLOW_API_KEY", "DEMO_KEY")
+HISTORY_FILE = "history.json"
+
+# =========================
+# UTILITIES
+# =========================
+
+def load_history():
+    if os.path.exists(HISTORY_FILE):
+        with open(HISTORY_FILE, "r") as f:
+            return json.load(f)
+    return []
+
+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)
+
+def validate_api_key(key: str):
+    if key != API_KEY:
+        raise ValueError("Invalid API key")
+
+def watermark(confidence: float) -> str:
+    if confidence >= 0.9:
+        return "HIGH CONFIDENCE ✔"
+    if confidence >= 0.75:
+        return "MEDIUM CONFIDENCE ◼"
+    return "LOW CONFIDENCE ⚠"
 
 # =========================
-# CORE CODEX ENGINE
+# CORE ENGINE
 # =========================
 
 def harmonize_price(
@@ -12,9 +47,6 @@ def harmonize_price(
     physical_anchor: float,
     lag_factor: float
 ) -> Dict[str, float]:
-    """
-    Harmonize synthetic price signals with physical reality.
-    """
     correction = (synthetic_price - physical_anchor) * min(1.0, lag_factor)
     harmonized = synthetic_price - correction
     confidence = 1.0 - abs(correction) / max(synthetic_price, 1.0)
@@ -26,59 +58,89 @@ def harmonize_price(
         "confidence": round(max(0.0, min(confidence, 1.0)), 2)
     }
 
-
 def accelerate_cashflow(
     amount: float,
     days_delay: int,
     confidence: float
 ) -> float:
-    """
-    Time-value cashflow acceleration (non-speculative).
-    """
     base_rate = 0.03
     risk_penalty = (1.0 - confidence) * 0.05
     discount_rate = base_rate + risk_penalty
-
-    accelerated_value = amount / ((1 + discount_rate) ** (days_delay / 365))
-    return round(accelerated_value, 2)
-
+    return round(amount / ((1 + discount_rate) ** (days_delay / 365)), 2)
 
 # =========================
-# SYSTEM ENTRYPOINT
+# SINGLE & BATCH RUNTIME
 # =========================
 
-def codexflow_runtime(
+def codexflow_execute(
     commodity: str,
     synthetic_price: float,
     physical_price: float,
-    reporting_lag_days: int
+    reporting_lag_days: int,
+    api_key: str
 ) -> Dict:
-    """
-    Full CodexFlow runtime execution.
-    """
-    lag_factor = min(reporting_lag_days / 10, 1.0)
+    validate_api_key(api_key)
 
+    lag_factor = min(reporting_lag_days / 10, 1.0)
     harmonized = harmonize_price(
-        synthetic_price=synthetic_price,
-        physical_anchor=physical_price,
-        lag_factor=lag_factor
+        synthetic_price,
+        physical_price,
+        lag_factor
     )
 
-    accelerated_cashflow = accelerate_cashflow(
-        amount=harmonized["harmonized_price_index"],
-        days_delay=reporting_lag_days,
-        confidence=harmonized["confidence"]
+    accelerated = accelerate_cashflow(
+        harmonized["harmonized_price_index"],
+        reporting_lag_days,
+        harmonized["confidence"]
     )
 
-    return {
-        "status": "ok",
-        "engine": "CodexFlow ΩΞ",
+    result = {
         "timestamp": datetime.utcnow().isoformat(),
+        "engine": "CodexFlow ΩΞ",
         "commodity": commodity,
         "harmonized_state": harmonized,
-        "accelerated_cashflow_estimate": accelerated_cashflow
+        "accelerated_cashflow_estimate": accelerated,
+        "confidence_watermark": watermark(harmonized["confidence"])
     }
 
+    save_history(result)
+    return result
+
+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):
+        outputs.append(
+            codexflow_execute(c, s, p, 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"]
+    )
+
+# =========================
+# DASHBOARD HELPERS
+# =========================
+
+def get_history():
+    return load_history()
 
 # =========================
 # GRADIO UI
@@ -88,53 +150,84 @@ with gr.Blocks() as demo:
     gr.Markdown(
         """
         # CodexFlow ΩΞ Runtime  
-        **Reality-Anchored Cashflow Acceleration Engine**
-
-        Harmonizes synthetic market signals with physical reality and
-        accelerates cashflow without speculation or leverage.
+        **Autonomous Reality-Anchored Cashflow Acceleration Engine**
+
+        Features:
+        • API-key gated execution  
+        • Batch commodity processing  
+        • Confidence watermarking  
+        • Historical trend memory  
+        • REST-style JSON interface  
         """
     )
 
-    with gr.Row():
+    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
+        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()
+
+        run_btn.click(
+            codexflow_execute,
+            inputs=[
+                commodity,
+                synthetic_price,
+                physical_price,
+                reporting_lag,
+                api_key
+            ],
+            outputs=output
         )
 
-    with gr.Row():
-        physical_price = gr.Number(
-            label="Physical / Production Price Anchor",
-            value=950
+    with gr.Tab("Batch Mode"):
+        commodities = gr.Textbox(
+            label="Commodities (comma-separated)",
+            value="Gold,Iron Ore,Crude Oil"
         )
-        reporting_lag = gr.Slider(
-            minimum=0,
-            maximum=30,
-            step=1,
-            label="Reporting Lag (Days)",
-            value=7
+        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)")
+        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
+            ],
+            outputs=batch_out
         )
 
-    run_btn = gr.Button("Run CodexFlow Harmonization")
-    output = gr.JSON(label="CodexFlow Output")
-
-    run_btn.click(
-        codexflow_runtime,
-        inputs=[
-            commodity,
-            synthetic_price,
-            physical_price,
-            reporting_lag
-        ],
-        outputs=output
-    )
-
+    with gr.Tab("Historical Trends"):
+        hist_btn = gr.Button("Load History")
+        hist_out = gr.JSON()
+        hist_btn.click(get_history, outputs=hist_out)
 
 # =========================
-# HUGGING FACE PATCH
+# HUGGING FACE DEPLOY PATCH
 # =========================
 
 if __name__ == "__main__":