Update app.py

app.py

@@ -1,173 +1,143 @@
 import gradio as gr
 import pandas as pd
+import numpy as np
 import matplotlib.pyplot as plt
-import io
-import base64
-
-# ---------------------------------------------------
-# Helper: Generate Heatmap Image (Aisle × Rack)
-# ---------------------------------------------------
-def generate_slotting_heatmap(df):
-    plt.figure(figsize=(8, 6))
-    plt.scatter(df["Suggested Aisle"], df["Suggested Rack"],
-                c='orange', s=120, edgecolor='black')
-
-    plt.title("SKU Slotting Heatmap (Aisle × Rack)")
-    plt.xlabel("Aisle Number")
-    plt.ylabel("Rack Number")
-    plt.grid(True, alpha=0.3)
-
-    # Add SKU labels near points
-    for i, sku in enumerate(df["SKU"]):
-        plt.text(df["Suggested Aisle"][i] + 0.3,
-                 df["Suggested Rack"][i] + 0.3,
-                 sku, fontsize=9)
-
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png", bbox_inches='tight')
-    plt.close()
-    buf.seek(0)
-
-    encoded = base64.b64encode(buf.read()).decode()
-    return "data:image/png;base64," + encoded
-
+from io import BytesIO
+
+PRIMARY_COLOR = "#0f2c59"
+
+
+# -------------------------
+# BUSINESS LOGIC
+# -------------------------
+def compute_slotting(df):
+    """
+    Determines aisle & rack suggestions based on SKU velocity.
+    """
+
+    results = []
+    for _, row in df.iterrows():
+        sku = row["SKU"]
+        vel = row["Velocity"]
+        freq = int(row["Frequency"])
+
+        if vel.lower() == "fast":
+            aisle = 3
+            rack = 14
+            reason = "Fast-moving SKU — Placed close to dispatch for quicker picking."
+        elif vel.lower() == "medium":
+            aisle = 6
+            rack = 20
+            reason = "Medium-moving SKU — Positioned in central aisles to balance travel distance."
+        else:
+            aisle = 20
+            rack = 6
+            reason = "Slow-moving SKU — Moved to back aisles to avoid congestion."
 
-# ---------------------------------------------------
-# Helper: Generate Before vs After Distance Chart
-# ---------------------------------------------------
-def generate_distance_chart(before_dist, after_dist):
-    plt.figure(figsize=(7, 5))
+        results.append([sku, vel, freq, aisle, rack, reason])
 
-    plt.bar(["Before", "After"], [before_dist, after_dist],
-            color=["red", "green"])
+    return pd.DataFrame(
+        results,
+        columns=["SKU", "Velocity", "Frequency", "Suggested Aisle", "Suggested Rack", "Reason"]
+    )
 
-    plt.title("Walking Distance Comparison")
-    plt.ylabel("Distance (meters)")
 
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png", bbox_inches='tight')
-    plt.close()
-    buf.seek(0)
+def generate_heatmap(slotting_df):
+    """
+    Generates a heatmap representing item placement (Aisle vs. Rack).
+    """
 
-    encoded = base64.b64encode(buf.read()).decode()
-    return "data:image/png;base64," + encoded
+    aisles = slotting_df["Suggested Aisle"].astype(int)
+    racks = slotting_df["Suggested Rack"].astype(int)
 
+    grid = np.zeros((25, 25))
+    for a, r in zip(aisles, racks):
+        if a < 25 and r < 25:
+            grid[a, r] = 1
 
-# ---------------------------------------------------
-# Core Slotting Engine
-# ---------------------------------------------------
-def optimize_slotting(sku_df):
-    if sku_df is None or len(sku_df) == 0:
-        return None, "No data provided.", None, None
+    fig, ax = plt.subplots(figsize=(6, 6))
+    ax.imshow(grid, cmap="Oranges", origin="lower")
+    ax.set_title("Warehouse Slotting Heatmap")
+    ax.set_xlabel("Rack Number")
+    ax.set_ylabel("Aisle Number")
 
-    df = sku_df.copy()
+    buf = BytesIO()
+    plt.savefig(buf, format="png", dpi=120, bbox_inches="tight")
+    plt.close(fig)
+    buf.seek(0)
+    return buf
 
-    # Mapping velocities to warehouse zone logic
-    velocity_zone_map = {
-        "Fast": (3, 14),      # near dispatch
-        "Medium": (6, 20),    # middle aisles
-        "Slow": (20, 6)       # far aisles
-    }
 
-    suggested_aisles = []
-    suggested_racks = []
-    reasons = []
+def business_summary(df):
+    fast = sum(df["Velocity"].str.lower() == "fast")
+    med = sum(df["Velocity"].str.lower() == "medium")
+    slow = sum(df["Velocity"].str.lower() == "slow")
 
-    for i in range(len(df)):
-        velocity = df.loc[i, "Velocity"]
-        freq = df.loc[i, "Frequency"]
-        sku = df.loc[i, "SKU"]
+    summary = f"""
+### 📊 Business Insight Summary
 
-        if velocity not in velocity_zone_map:
-            aisle, rack = (10, 10)  # fallback
-            reason = "Default placement due to unknown velocity."
-        else:
-            aisle, rack = velocity_zone_map[velocity]
-            reason = f"{velocity}-moving SKU — placed strategically to reduce picker travel."
-
-        suggested_aisles.append(aisle)
-        suggested_racks.append(rack)
-        reasons.append(reason)
-
-    df["Suggested Aisle"] = suggested_aisles
-    df["Suggested Rack"] = suggested_racks
-    df["Reason"] = reasons
-
-    # Business insight summary
-    insight = (
-        "📌 **Business Insight Summary**\n"
-        "- Fast movers placed closest to dispatch to minimize walking distance.\n"
-        "- Medium movers placed in central aisles to balance traffic.\n"
-        "- Slow movers placed in deep aisles to avoid congestion.\n\n"
-        "**Operational Impact:**\n"
-        "✔ Walking distance reduction\n"
-        "✔ Faster order fulfillment\n"
-        "✔ Better warehouse throughput\n"
-        "✔ Lower aisle congestion\n"
-    )
+- **Fast Movers**: {fast} SKUs placed near dispatch → reduces pick time.
+- **Medium Movers**: {med} SKUs placed in central aisles → balances travel.
+- **Slow Movers**: {slow} SKUs placed in far aisles → lowers congestion.
 
-    # Generate visuals
-    heatmap_img = generate_slotting_heatmap(df)
+#### This Improves:
+- 🚶‍♂️ Reduction in walking distance  
+- 🚚 Faster order fulfillment  
+- 🏭 Better warehouse space utilization  
+- 🔄 Reduced aisle congestion  
+"""
+    return summary
 
-    before_distance = 300  # static demo number
-    after_distance = 180   # static demo number
-    distance_img = generate_distance_chart(before_distance, after_distance)
 
-    return df, insight, heatmap_img, distance_img
+# -------------------------
+# GRADIO UI
+# -------------------------
+def process_slotting(input_df):
+    try:
+        slotting = compute_slotting(input_df)
+        heatmap = generate_heatmap(slotting)
+        insights = business_summary(slotting)
+        return slotting, heatmap, insights
+    except Exception as e:
+        return None, None, f"❌ Error: {e}"
 
 
-# ---------------------------------------------------
-# UI Layout
-# ---------------------------------------------------
 def build_ui():
     with gr.Blocks() as demo:
-        gr.Markdown(
-            "<h1>Procelevate Inventory Slotting Optimizer</h1>"
-            "<p>AI-powered SKU placement engine to reduce picking time, congestion & improve throughput.</p>"
-        )
 
-        gr.Markdown("📦 **Upload SKU File or Enter Data**")
-
-        # Input table
-        input_table = gr.Dataframe(
-            headers=["SKU", "Velocity", "Frequency"],
-            datatype=["str", "str", "number"],
-            row_count=3,
-            value=[
-                ["A123", "Fast", 120],
-                ["B555", "Medium", 60],
-                ["C888", "Slow", 5]
-            ],
-            label="SKU Velocity Table"
+        gr.Markdown(
+            "<h1 style='color:#FF6A00'>Procelevate Inventory Slotting Optimizer</h1>"
+            "AI-powered SKU placement engine to reduce picking time & congestion."
         )
 
-        submit_btn = gr.Button("Optimize Slotting", variant="primary")
-
-        # Tabs for results
-        with gr.Tabs():
-            with gr.Tab("Optimized Slotting"):
-                output_table = gr.Dataframe(
-                    headers=["SKU", "Velocity", "Frequency", "Suggested Aisle", "Suggested Rack", "Reason"],
-                    label="Optimized Slotting Table"
-                )
-
-            with gr.Tab("Heatmap Visualization"):
-                heatmap_view = gr.Image(label="SKU Slotting Heatmap")
-
-            with gr.Tab("Walking Distance Savings"):
-                distance_view = gr.Image(label="Walking Distance Chart")
-
-            with gr.Tab("Business Insights"):
-                insight_box = gr.Markdown()
-
-        submit_btn.click(
-            optimize_slotting,
-            inputs=[input_table],
-            outputs=[output_table, insight_box, heatmap_view, distance_view]
-        )
+        with gr.Tab("Optimized Slotting"):
+            df_input = gr.DataFrame(
+                headers=["SKU", "Velocity", "Frequency"],
+                value=[
+                    ["A123", "Fast", 120],
+                    ["B555", "Medium", 60],
+                    ["C888", "Slow", 5],
+                ],
+                label="SKU Velocity Table",
+                interactive=True
+            )
+
+            run_btn = gr.Button("Optimize Slotting", variant="primary")
+
+            slotting_table = gr.DataFrame(label="Optimized Slotting", interactive=False)
+            heatmap_output = gr.Image(type="numpy", label="Heatmap")
+            insights_output = gr.Markdown()
+
+            run_btn.click(
+                process_slotting,
+                inputs=df_input,
+                outputs=[slotting_table, heatmap_output, insights_output]
+            )
 
     return demo
 
 
 demo = build_ui()
-demo.launch()
+
+if __name__ == "__main__":
+    demo.launch()