Update app.py

app.py

@@ -6,34 +6,35 @@ import matplotlib.pyplot as plt
 import numpy as np
 from datetime import datetime
 
-# ═══════════════════════════════════════════════════════════
-# GLOBAL STATE (REAL-TIME MEMORY)
-# ═══════════════════════════════════════════════════════════
-history = {
-    "load": [],
-    "latency": [],
-    "cost": [],
-    "servers": []
-}
-
-MAX_POINTS = 120
-
-# ═══════════════════════════════════════════════════════════
-# COLORS
-# ═══════════════════════════════════════════════════════════
-C = {
-    "bg": "#0b0f1a",
-    "cyan": "#00e5ff",
-    "green": "#00ff9d",
-    "red": "#ff3d5a",
-    "amber": "#ffb300",
-    "purple": "#c084fc"
+# ═══════════════════════════════════════════════════
+# GLOBAL STATE
+# ═══════════════════════════════════════════════════
+history = {"load": [], "latency": [], "cost": [], "servers": []}
+MAX_POINTS = 100
+
+# ═══════════════════════════════════════════════════
+# CUSTOM CSS (PRO UI)
+# ═══════════════════════════════════════════════════
+custom_css = """
+body { background: #0b0f1a; color: white; }
+.card {
+    background: rgba(255,255,255,0.05);
+    border-radius: 16px;
+    padding: 15px;
+    box-shadow: 0 0 15px rgba(0,0,0,0.3);
+    text-align: center;
 }
+.metric { font-size: 28px; font-weight: bold; }
+.green { color: #00ff9d; }
+.red { color: #ff3d5a; }
+.yellow { color: #ffb300; }
+.cyan { color: #00e5ff; }
+"""
 
-# ═══════════════════════════════════════════════════════════
-# REAL SYSTEM METRICS (LIVE ENGINE)
-# ═══════════════════════════════════════════════════════════
-def get_real_metrics():
+# ═══════════════════════════════════════════════════
+# METRICS ENGINE
+# ═══════════════════════════════════════════════════
+def get_metrics():
     cpu = psutil.cpu_percent()
     mem = psutil.virtual_memory().percent
 
@@ -44,78 +45,67 @@ def get_real_metrics():
 
     return load, latency, servers, cost
 
-# ═══════════════════════════════════════════════════════════
-# AI DECISION ENGINE (SMART)
-# ═══════════════════════════════════════════════════════════
-def ai_decision(load, latency, cost, auto_scaling):
-
-    anomaly = False
-
-    if len(history["load"]) > 10:
-        avg = np.mean(history["load"][-10:])
-        if load > avg * 1.4:
-            anomaly = True
-
-    if anomaly:
-        return "🚨 ANOMALY DETECTED → Emergency Scale Up", "HIGH"
-
-    if load > 750 and latency > 90:
-        return "🔥 Scale Up +2", "HIGH"
-
-    if load < 300:
-        return "🟢 Scale Down -1", "LOW"
-
-    if cost > 0.7:
-        return "💰 Optimize Cost / Use Spot", "MEDIUM"
-
-    return "⚖️ Stable System", "LOW"
-
-# ═══════════════════════════════════════════════════════════
-# PREDICTION ENGINE (SIMPLE FORECAST)
-# ═══════════════════════════════════════════════════════════
-def predict_next():
-    if len(history["load"]) < 5:
-        return 0, 0
-
-    load_trend = np.mean(history["load"][-5:])
-    lat_trend = np.mean(history["latency"][-5:])
-
-    return int(load_trend * 1.05), int(lat_trend * 1.05)
-
-# ═══════════════════════════════════════════════════════════
-# GRAPH (MULTI-LINE REAL-TIME)
-# ══════════════════════���════════════════════════════════════
+# ═══════════════════════════════════════════════════
+# AI DECISION
+# ═══════════════════════════════════════════════════
+def ai_decision(load, latency, cost):
+    if load > 800 or latency > 100:
+        return "🔥 Scale Up Immediately", "HIGH"
+    elif load < 300:
+        return "🟢 Scale Down Resources", "LOW"
+    elif cost > 0.7:
+        return "💰 Optimize Cost", "MEDIUM"
+    return "⚖️ System Stable", "LOW"
+
+# ═══════════════════════════════════════════════════
+# CARD FORMATTER
+# ═══════════════════════════════════════════════════
+def card(title, value, color):
+    return f"""
+    <div class="card">
+        <div>{title}</div>
+        <div class="metric {color}">{value}</div>
+    </div>
+    """
+
+# ═══════════════════════════════════════════════════
+# GRAPH
+# ═══════════════════════════════════════════════════
 def make_graph():
-
     fig, ax = plt.subplots(figsize=(7,3))
     fig.patch.set_facecolor("#0b0f1a")
     ax.set_facecolor("#0b0f1a")
 
     t = np.arange(len(history["load"]))
 
-    ax.plot(t, history["load"], color=C["cyan"], label="Load")
-    ax.plot(t, history["latency"], color=C["amber"], label="Latency")
-    ax.plot(t, np.array(history["cost"])*1000, color=C["green"], label="Cost x1000")
+    ax.plot(t, history["load"], linewidth=2, label="Load")
+    ax.plot(t, history["latency"], linewidth=2, label="Latency")
+    ax.plot(t, np.array(history["cost"])*1000, linewidth=2, label="Cost x1000")
 
     ax.legend()
     ax.grid(alpha=0.2)
 
+    ax.spines[:].set_visible(False)
+    ax.tick_params(colors="white")
+    ax.set_title("Live Metrics", color="white")
+
     return fig
 
-# ═══════════════════════════════════════════════════════════
-# MAIN ENGINE LOOP
-# ═══════════════════════════════════════════════════════════
-def run_engine(user_control, auto_scaling):
+# ═══════════════════════════════════════════════════
+# MAIN ENGINE
+# ═══════════════════════════════════════════════════
+def run_engine(load_slider, chaos):
 
-    now = datetime.now().strftime("%H:%M:%S")
+    load, latency, servers, cost = get_metrics()
 
-    # REAL METRICS
-    load, latency, servers, cost = get_real_metrics()
+    # simulate user load
+    load = int(load * (load_slider / 50))
 
-    # APPLY USER CONTROL (simulate external pressure)
-    load = int(load * (user_control / 50))
+    # chaos mode
+    if chaos:
+        load *= random.randint(1, 3)
 
-    # STORE HISTORY
+    # store history
     history["load"].append(load)
     history["latency"].append(latency)
     history["cost"].append(cost)
@@ -124,71 +114,56 @@ def run_engine(user_control, auto_scaling):
     for k in history:
         history[k] = history[k][-MAX_POINTS:]
 
-    # AI DECISION
-    decision, risk = ai_decision(load, latency, cost, auto_scaling)
-
-    # PREDICTION
-    p_load, p_lat = predict_next()
+    decision, risk = ai_decision(load, latency, cost)
 
-    # LOG
-    log = f"""
-[{now}] Load={load} | Lat={latency} | Cost={cost}
-→ {decision}
-→ Predicted Next: Load={p_load}, Lat={p_lat}
-"""
+    log = f"[{datetime.now().strftime('%H:%M:%S')}] Load={load}, Lat={latency}, Cost={cost}"
 
-    # GRAPH
     fig = make_graph()
 
     return (
-        load,
-        latency,
-        servers,
-        cost,
-        decision,
-        risk,
-        p_load,
-        p_lat,
+        card("🚀 Load", load, "cyan"),
+        card("⚡ Latency", latency, "yellow"),
+        card("🖥 Servers", servers, "green"),
+        card("💰 Cost/hr", f"${cost}", "green"),
+        f"🤖 {decision}",
+        f"Risk: {risk}",
         log,
         fig
     )
 
-# ═══════════════════════════════════════════════════════════
-# UI (PRO DASHBOARD)
-# ═══════════════════════════════════════════════════════════
-with gr.Blocks(title="PRO AI Cloud Engine") as demo:
+# ═══════════════════════════════════════════════════
+# UI
+# ═══════════════════════════════════════════════════
+with gr.Blocks(css=custom_css) as demo:
 
-    gr.Markdown("# 🚀 PRO AI Cloud Engine (Live System)")
+    gr.Markdown("""
+    # 🚀 Cloud-Cost Guardian AI  
+    ### Autonomous AI for Real-Time Scaling & Cost Optimization
+    """)
 
     with gr.Row():
-        user_control = gr.Slider(10,100,value=50,label="External Load Pressure")
-        auto_scaling = gr.Checkbox(value=True,label="AI Auto Scaling")
+        load_slider = gr.Slider(10, 100, value=50, label="External Load")
+        chaos = gr.Checkbox(label="🔥 Chaos Mode")
 
     with gr.Row():
-        load_out = gr.Number(label="Load (req/s)")
-        lat_out = gr.Number(label="Latency (ms)")
-        srv_out = gr.Number(label="Servers")
-        cost_out = gr.Number(label="Cost ($/hr)")
+        load_out = gr.HTML()
+        lat_out = gr.HTML()
+        srv_out = gr.HTML()
+        cost_out = gr.HTML()
 
     with gr.Row():
         decision_out = gr.Textbox(label="AI Decision")
         risk_out = gr.Textbox(label="Risk Level")
 
-    with gr.Row():
-        pred_load = gr.Number(label="Predicted Load")
-        pred_lat = gr.Number(label="Predicted Latency")
-
-    log_out = gr.Textbox(label="System Log", lines=6)
+    log_out = gr.Textbox(label="System Log")
     graph = gr.Plot()
 
-    # 🔥 LIVE ENGINE
     demo.load(
         run_engine,
-        inputs=[user_control, auto_scaling],
+        inputs=[load_slider, chaos],
         outputs=[
             load_out, lat_out, srv_out, cost_out,
             decision_out, risk_out,
-            pred_load, pred_lat,
             log_out, graph
         ],
         every=1