Create app.py

app.py

@@ -0,0 +1,319 @@
+import os
+import re
+import random
+from datetime import datetime, timedelta
+
+import pandas as pd
+import streamlit as st
+
+st.set_page_config(page_title="AI Lighting Quotation Agent", layout="wide")
+st.title("💡 AI Lighting Quotation Agent (Prototype)")
+st.caption("Paste inquiry → extract specs → rank suppliers → recommend pricing → generate quote draft")
+
+# ✅ Docker-safe writable location
+DATA_PATH = os.environ.get("SUPPLIER_DB_PATH", "/tmp/supplier_db.csv")
+random.seed(42)
+
+PRODUCT_CATALOG = [
+    ("LED Panel", ["panel", "led panel", "ceiling panel"], (14, 28)),
+    ("Downlight", ["downlight", "spot", "spotlight"], (6, 18)),
+    ("Flood Light", ["flood", "floodlight"], (18, 55)),
+    ("High Bay", ["high bay", "warehouse bay"], (35, 120)),
+    ("Tube Light", ["tube", "t8", "batten"], (4, 12)),
+    ("Track Light", ["track", "rail light"], (10, 30)),
+    ("Street Light", ["street", "road light"], (40, 160)),
+    ("LED Strip", ["strip", "led strip", "tape"], (3, 15)),
+]
+
+BRANDS = ["Philips", "Osram", "Panasonic", "Schneider", "Opple", "NVC", "Crompton", "Wipro", "Havells", "Generic"]
+REGIONS = ["SG Central", "SG East", "SG West", "SG North", "Johor", "KL", "Batam"]
+
+def make_supplier_name(i: int) -> str:
+    prefixes = ["Bright", "Nova", "Apex", "Luma", "Spark", "Prime", "Zen", "Vertex", "Delta", "Orion"]
+    suffixes = ["Lighting", "Electrics", "Solutions", "Supply", "Traders", "Distributors", "Imports", "Wholesale", "Mart", "Hub"]
+    return f"{random.choice(prefixes)} {random.choice(suffixes)} Pte Ltd #{i:02d}"
+
+def generate_supplier_db(n_suppliers: int = 50) -> pd.DataFrame:
+    rows = []
+    for i in range(1, n_suppliers + 1):
+        supplier = make_supplier_name(i)
+        region = random.choice(REGIONS)
+        supported_categories = random.sample([c[0] for c in PRODUCT_CATALOG], k=random.randint(2, 4))
+        reliability = round(random.uniform(0.60, 0.98), 2)
+        lead_days = random.randint(2, 21)
+        moq = random.choice([1, 5, 10, 20, 30, 50])
+        competitiveness = round(random.uniform(0.85, 1.20), 2)
+        brands_supported = random.sample(BRANDS, k=random.randint(2, 5))
+        rows.append({
+            "supplier_id": f"SUP-{1000+i}",
+            "supplier_name": supplier,
+            "region": region,
+            "supported_categories": "|".join(supported_categories),
+            "brands_supported": "|".join(brands_supported),
+            "reliability_score": reliability,
+            "lead_time_days": lead_days,
+            "moq": moq,
+            "price_competitiveness_factor": competitiveness,
+            "contact_email": f"sales{i:02d}@example-supplier.com",
+            "last_updated": (datetime.today() - timedelta(days=random.randint(0, 60))).strftime("%Y-%m-%d"),
+        })
+    return pd.DataFrame(rows)
+
+def load_or_create_db() -> pd.DataFrame:
+    if os.path.exists(DATA_PATH):
+        return pd.read_csv(DATA_PATH)
+    df = generate_supplier_db(50)
+    df.to_csv(DATA_PATH, index=False)
+    return df
+
+df_suppliers = load_or_create_db()
+
+def normalize_text(t: str) -> str:
+    return re.sub(r"\s+", " ", (t or "").strip().lower())
+
+def detect_quantity(text: str):
+    patterns = [
+        r"\bqty[:\s]*([0-9]{1,5})\b",
+        r"\bquantity[:\s]*([0-9]{1,5})\b",
+        r"\b([0-9]{1,5})\s*(pcs|pc|pieces|nos|units)\b",
+    ]
+    for p in patterns:
+        m = re.search(p, text, flags=re.IGNORECASE)
+        if m:
+            return int(m.group(1))
+    return None
+
+def detect_wattage(text: str):
+    m = re.search(r"\b([0-9]{1,4})\s*(w|watt|watts)\b", text, flags=re.IGNORECASE)
+    return int(m.group(1)) if m else None
+
+def detect_brand(text: str):
+    t = (text or "").lower()
+    for b in BRANDS:
+        if b.lower() in t:
+            return b
+    return None
+
+def detect_category(text: str):
+    t = normalize_text(text)
+    for category, keywords, _rng in PRODUCT_CATALOG:
+        for kw in keywords:
+            if kw in t:
+                return category
+    return None
+
+def detect_location(text: str):
+    t = normalize_text(text)
+    loc_map = {
+        "singapore": "SG",
+        "sg": "SG",
+        "jurong": "SG West",
+        "tampines": "SG East",
+        "woodlands": "SG North",
+        "batam": "Batam",
+        "johor": "Johor",
+        "kuala lumpur": "KL",
+        "kl": "KL",
+    }
+    for k, v in loc_map.items():
+        if k in t:
+            return v
+    return None
+
+def parse_inquiry(text: str) -> dict:
+    return {
+        "raw_text": (text or "").strip(),
+        "quantity": detect_quantity(text) or 10,
+        "wattage": detect_wattage(text),
+        "brand": detect_brand(text),
+        "category": detect_category(text),
+        "location": detect_location(text),
+    }
+
+def estimate_market_range(category: str | None, wattage: int | None):
+    if not category:
+        return (10.0, 40.0)
+    base = None
+    for c, _kw, rng in PRODUCT_CATALOG:
+        if c == category:
+            base = rng
+            break
+    if not base:
+        return (10.0, 40.0)
+
+    lo, hi = base
+    if wattage:
+        scale = min(2.0, max(0.7, wattage / 18.0))
+        lo = lo * (0.85 + 0.15 * scale)
+        hi = hi * (0.85 + 0.20 * scale)
+    return (round(lo, 2), round(hi, 2))
+
+def pick_margin(pricing_mode: str, base_margin: float):
+    if pricing_mode == "Competitive":
+        return max(5, base_margin - 6)
+    if pricing_mode == "High Margin":
+        return min(40, base_margin + 8)
+    return base_margin
+
+def compute_offers(req: dict, suppliers: pd.DataFrame, margin_pct: float):
+    category = req.get("category")
+    brand = req.get("brand")
+    qty = int(req.get("quantity") or 10)
+
+    candidates = suppliers.copy()
+
+    if category:
+        candidates = candidates[candidates["supported_categories"].astype(str).str.contains(category, na=False)]
+
+    if brand:
+        bm = candidates["brands_supported"].astype(str).str.contains(brand, na=False)
+        if bm.sum() > 0:
+            candidates = candidates[bm]
+
+    candidates = candidates[candidates["moq"].fillna(1).astype(int) <= qty]
+    if candidates.empty:
+        return pd.DataFrame()
+
+    market_lo, market_hi = estimate_market_range(category, req.get("wattage"))
+    market_mid = (market_lo + market_hi) / 2
+
+    rows = []
+    for _, s in candidates.iterrows():
+        factor = float(s["price_competitiveness_factor"])
+        supplier_cost = market_mid * factor * random.uniform(0.92, 1.06)
+
+        region = str(s["region"])
+        if region in ["Johor", "KL", "Batam"]:
+            supplier_cost *= 1.05
+
+        supplier_cost = round(supplier_cost, 2)
+        sell_price = round(supplier_cost / (1 - margin_pct / 100.0), 2)
+
+        reliability = float(s["reliability_score"])
+        lead = int(s["lead_time_days"])
+        score = (1 / max(sell_price, 0.01)) * 100 + reliability * 10 + (1 / max(lead, 1)) * 5
+
+        rows.append({
+            "supplier_id": s["supplier_id"],
+            "supplier_name": s["supplier_name"],
+            "region": s["region"],
+            "reliability_score": reliability,
+            "lead_time_days": lead,
+            "moq": int(s["moq"]),
+            "est_supplier_cost_sgd": supplier_cost,
+            "recommended_sell_price_sgd": sell_price,
+            "score": round(score, 4),
+            "contact_email": s["contact_email"],
+        })
+
+    return pd.DataFrame(rows).sort_values("score", ascending=False).head(10).reset_index(drop=True)
+
+# Sidebar
+st.sidebar.header("⚙️ Controls")
+base_margin = st.sidebar.slider("Base Margin (%)", 5, 40, 20, 1)
+pricing_mode = st.sidebar.radio("Pricing Mode", ["Balanced", "Competitive", "High Margin"], index=0)
+top_n = st.sidebar.slider("Top offers to show", 3, 10, 5, 1)
+
+with st.sidebar.expander("📦 Supplier DB", expanded=False):
+    st.write(f"Loaded suppliers: **{len(df_suppliers)}**")
+    st.download_button(
+        "Download supplier_db.csv",
+        data=df_suppliers.to_csv(index=False).encode("utf-8"),
+        file_name="supplier_db.csv",
+        mime="text/csv",
+        use_container_width=True,
+    )
+    if st.button("Regenerate DB (50 suppliers)"):
+        df_suppliers = generate_supplier_db(50)
+        df_suppliers.to_csv(DATA_PATH, index=False)
+        st.success("Regenerated supplier database")
+        st.rerun()
+
+# Main
+left, right = st.columns([1.2, 1.0], gap="large")
+
+with left:
+    st.subheader("1) Paste Customer Inquiry")
+    sample = "Hi, please quote best price for 50 pcs Philips 18W LED panel light. Delivery to Singapore in 2 weeks."
+    inquiry = st.text_area("Inquiry", value=sample, height=150)
+
+    req = parse_inquiry(inquiry)
+    st.subheader("2) Agent Step: Requirement Extraction")
+    st.json(req)
+
+with right:
+    st.subheader("3) Agent Step: Market Intelligence (Demo)")
+    market_lo, market_hi = estimate_market_range(req.get("category"), req.get("wattage"))
+    st.metric("Estimated market low (SGD/unit)", f"{market_lo:.2f}")
+    st.metric("Estimated market high (SGD/unit)", f"{market_hi:.2f}")
+
+st.divider()
+
+margin_to_use = pick_margin(pricing_mode, base_margin)
+st.subheader("4) Agent Step: Supplier Shortlist + Pricing Recommendation")
+st.caption(f"Mode: **{pricing_mode}** → Margin applied: **{margin_to_use:.0f}%**")
+
+offers_df = compute_offers(req, df_suppliers, margin_to_use)
+
+if offers_df.empty:
+    st.error("No matching suppliers found (internal DB).")
+    st.markdown("### 🆕 New Product / No-Match Mode (Prototype)")
+    st.write("**Agent next actions:**")
+    st.write("1) Search online for market range and equivalent SKUs.")
+    st.write("2) Identify relevant supplier categories and shortlist outreach list.")
+    st.write("3) Auto-send RFQs (email/WhatsApp) and wait for quotes.")
+    st.write("4) Add new SKU to internal catalog once confirmed.")
+else:
+    st.dataframe(offers_df.head(top_n), use_container_width=True)
+    best = offers_df.iloc[0].to_dict()
+    st.success(
+        f"Recommended: **{best['supplier_name']}** | "
+        f"Cost **SGD {best['est_supplier_cost_sgd']:.2f}** ��� Sell **SGD {best['recommended_sell_price_sgd']:.2f}** | "
+        f"Lead **{best['lead_time_days']}d** | Reliability **{best['reliability_score']:.2f}**"
+    )
+
+st.divider()
+
+st.subheader("5) Quote Draft (Copy/Paste Demo)")
+company_name = st.text_input("Your company name", value="Delight Lighting (Demo)")
+customer_name = st.text_input("Customer name", value="Customer")
+quote_valid_days = st.number_input("Quote validity (days)", min_value=1, max_value=30, value=7)
+
+if offers_df.empty:
+    st.info("Once suppliers match, the quote draft will be generated here.")
+else:
+    qty = int(req.get("quantity") or 10)
+    category = req.get("category") or "Lighting Product"
+    brand = req.get("brand") or "Brand-agnostic"
+    wattage = f"{req.get('wattage')}W" if req.get("wattage") else ""
+    unit_price = float(offers_df.iloc[0]["recommended_sell_price_sgd"])
+    total = round(unit_price * qty, 2)
+    valid_until = (datetime.today() + timedelta(days=int(quote_valid_days))).strftime("%Y-%m-%d")
+
+    quote_text = f"""Subject: Quotation - {brand} {wattage} {category} (Qty: {qty})
+
+Hi {customer_name},
+
+Thanks for your inquiry. Please find our quotation below:
+
+Item: {brand} {wattage} {category}
+Quantity: {qty}
+Unit Price: SGD {unit_price:.2f}
+Total: SGD {total:.2f}
+
+Estimated Lead Time: {int(offers_df.iloc[0]["lead_time_days"])} days
+Validity: Until {valid_until}
+Terms: 50% advance, balance before delivery (demo terms)
+
+Regards,
+Sales Team
+{company_name}
+"""
+    st.text_area("Generated Quote Draft", value=quote_text, height=240)
+    st.download_button(
+        "Download quote draft (.txt)",
+        data=quote_text.encode("utf-8"),
+        file_name="quote_draft.txt",
+        mime="text/plain",
+        use_container_width=True,
+    )