Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,404 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from datetime import datetime, timedelta
+from dateutil.parser import parse
+
+# ---------------------------
+# App Config and Theming
+# ---------------------------
+st.set_page_config(
+    page_title="Procurement Agent – S/4HANA Embedded Analytics (Demo)",
+    page_icon="🧭",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Subtle CSS polish for a premium feel
+st.markdown(
+    """
+    <style>
+    .kpi-card {
+        padding: 14px 16px; border-radius: 12px; background: #0a0a0a0d;
+        border: 1px solid #e6e6e6; box-shadow: 0 1px 2px rgba(0,0,0,0.04);
+    }
+    .metric-label { font-size: 12px; color: #666; margin-bottom: 6px; }
+    .metric-value { font-size: 26px; font-weight: 700; }
+    .metric-sub { font-size: 12px; color: #999; }
+    .stChatFloatingInputContainer { border-top: 1px solid #eee; }
+    .st-emotion-cache-1avcm0n { padding-top: 0 !important; }
+    .rounded-img { border-radius: 50%; }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+# ---------------------------
+# Data Loading (Synthetic “CDS-like”)
+# ---------------------------
+@st.cache_data
+def load_data():
+    df = pd.read_csv("data/synthetic_procurement.csv", parse_dates=["PO_Date","DeliveryDate","GR_Date","IR_Date"])
+    # Derived fields similar to embedded analytics
+    df["DaysToDeliver"] = (df["DeliveryDate"] - df["PO_Date"]).dt.days
+    df["IsOpen"] = df["Status"].eq("Open")
+    return df
+
+df = load_data()
+
+# ---------------------------
+# Sidebar Filters
+# ---------------------------
+with st.sidebar:
+    st.image("https://huggingface.co/front/assets/huggingface_logo-noborder.svg", width=120)
+    st.title("Procurement Agent")
+    st.caption("S/4HANA Embedded Analytics – Learning Demo (Synthetic data)")
+
+    # Time filter
+    max_date = df["PO_Date"].max()
+    default_start = max_date - timedelta(days=45)
+    date_range = st.date_input("PO Date Range", (default_start, max_date))
+
+    # Codelists
+    company = st.multiselect("Company Code", sorted(df["CompanyCode"].unique().tolist()))
+    plants = st.multiselect("Plant", sorted(df["Plant"].unique().tolist()))
+    mat_groups = st.multiselect("Material Group", sorted(df["MaterialGroup"].unique().tolist()))
+    suppliers = st.multiselect("Supplier", sorted(df["Supplier"].unique().tolist()))
+    buyers = st.multiselect("Buyer", sorted(df["Buyer"].unique().tolist()))
+    status_sel = st.multiselect("Status", sorted(df["Status"].unique().tolist()))
+
+    st.markdown("---")
+    st.subheader("Demo actions")
+    if st.button("Reset Filters"):
+        st.session_state.clear()
+        st.rerun()
+
+# Apply filters
+def apply_filters(df):
+    dff = df.copy()
+    if isinstance(date_range, tuple) and len(date_range) == 2:
+        start_date, end_date = pd.to_datetime(date_range[0]), pd.to_datetime(date_range[1])
+        dff = dff[(dff["PO_Date"] >= start_date) & (dff["PO_Date"] <= end_date)]
+    if company:
+        dff = dff[dff["CompanyCode"].isin(company)]
+    if plants:
+        dff = dff[dff["Plant"].isin(plants)]
+    if mat_groups:
+        dff = dff[dff["MaterialGroup"].isin(mat_groups)]
+    if suppliers:
+        dff = dff[dff["Supplier"].isin(suppliers)]
+    if buyers:
+        dff = dff[dff["Buyer"].isin(buyers)]
+    if status_sel:
+        dff = dff[dff["Status"].isin(status_sel)]
+    return dff
+
+fdf = apply_filters(df)
+
+# ---------------------------
+# KPI Header
+# ---------------------------
+def kpi_card(label, value, sub=""):
+    st.markdown(
+        f"""
+        <div class="kpi-card">
+            <div class="metric-label">{label}</div>
+            <div class="metric-value">{value}</div>
+            <div class="metric-sub">{sub}</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    total_po = fdf["PO_ID"].nunique()
+    kpi_card("Purchase Orders", f"{total_po:,}", "Unique POs in selection")
+with col2:
+    spend = fdf["NetValue"].sum()
+    kpi_card("Net Spend", f"${spend:,.0f}", "Sum of PO item values")
+with col3:
+    avg_lt = fdf["LeadTimeDays"].mean() if len(fdf) else 0
+    kpi_card("Avg Lead Time", f"{avg_lt:.1f}d", "Supplier cycle time")
+with col4:
+    otif = fdf["OTIF"].mean() * 100 if len(fdf) else 0
+    kpi_card("OTIF", f"{otif:.0f}%", "On-time in-full rate")
+
+st.markdown("")
+
+# ---------------------------
+# Tabs: Overview | Supplier Insights | Explorer | Simulations
+# ---------------------------
+tab1, tab2, tab3, tab4 = st.tabs(["Overview", "Supplier Insights", "Explorer", "Simulations"])
+
+with tab1:
+    c1, c2 = st.columns([1.3, 1])
+    with c1:
+        st.subheader("Spend by Supplier")
+        if len(fdf):
+            fig = px.bar(
+                fdf.groupby("Supplier", as_index=False)["NetValue"].sum().sort_values("NetValue", ascending=False),
+                x="Supplier", y="NetValue", color="Supplier", height=380, template="plotly_white",
+                hover_data={"NetValue":":,.0f"}
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.info("No data for selected filters.")
+
+        st.subheader("Material Group Mix")
+        if len(fdf):
+            fig2 = px.pie(
+                fdf, names="MaterialGroup", values="NetValue", hole=0.45, template="plotly_white",
+                height=380
+            )
+            st.plotly_chart(fig2, use_container_width=True)
+
+    with c2:
+        st.subheader("Lead Time by Supplier")
+        if len(fdf):
+            g = fdf.groupby("Supplier", as_index=False)["LeadTimeDays"].mean().sort_values("LeadTimeDays")
+            fig3 = px.bar(g, x="LeadTimeDays", y="Supplier", orientation="h", height=380, template="plotly_white")
+            st.plotly_chart(fig3, use_container_width=True)
+
+        st.subheader("OTIF by Supplier")
+        if len(fdf):
+            g2 = fdf.groupby("Supplier", as_index=False)["OTIF"].mean()
+            g2["OTIF%"] = (g2["OTIF"] * 100).round(1)
+            fig4 = px.scatter(g2, x="Supplier", y="OTIF%", size="OTIF%", color="Supplier", height=340, template="plotly_white")
+            st.plotly_chart(fig4, use_container_width=True)
+
+with tab2:
+    st.subheader("Supplier Scorecard")
+    sup = st.selectbox("Choose supplier", sorted(df["Supplier"].unique().tolist()))
+    sdf = fdf[fdf["Supplier"] == sup]
+    if len(sdf):
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            kpi_card("Spend", f"${sdf['NetValue'].sum():,.0f}")
+        with c2:
+            kpi_card("Avg Price", f"${sdf['NetPrice'].mean():.2f}/unit")
+        with c3:
+            kpi_card("OTIF", f"{(sdf['OTIF'].mean()*100):.0f}%")
+
+        st.markdown("")
+
+        c4, c5 = st.columns(2)
+        with c4:
+            st.caption("Lead time trend (by PO date)")
+            trend = sdf.sort_values("PO_Date").groupby("PO_Date", as_index=False)["LeadTimeDays"].mean()
+            fig5 = px.line(trend, x="PO_Date", y="LeadTimeDays", markers=True, template="plotly_white", height=340)
+            st.plotly_chart(fig5, use_container_width=True)
+        with c5:
+            st.caption("Price distribution")
+            fig6 = px.histogram(sdf, x="NetPrice", nbins=10, template="plotly_white", height=340)
+            st.plotly_chart(fig6, use_container_width=True)
+
+        st.subheader("Recent PO Lines")
+        st.dataframe(
+            sdf.sort_values("PO_Date", ascending=False)[
+                ["PO_ID","PO_Item","PO_Date","Material","Quantity","OrderUnit","NetPrice","NetValue","DeliveryDate","Status","LeadTimeDays","OTIF"]
+            ].head(10),
+            use_container_width=True, height=300
+        )
+    else:
+        st.info("No lines for selected supplier within current filters.")
+
+with tab3:
+    st.subheader("Interactive Explorer")
+    dims = ["CompanyCode","Plant","MaterialGroup","Supplier","Buyer","Status"]
+    sel_dim = st.selectbox("Dimension", dims, index=3)
+    sel_mea = st.selectbox("Measure", ["NetValue","Quantity","NetPrice","LeadTimeDays","OTIF"], index=0)
+
+    if len(fdf):
+        g = fdf.groupby(sel_dim, as_index=False)[sel_mea].mean() if sel_mea in ["NetPrice","LeadTimeDays","OTIF"] else \
+            fdf.groupby(sel_dim, as_index=False)[sel_mea].sum()
+        fig7 = px.bar(g.sort_values(sel_mea, ascending=False).head(15), x=sel_dim, y=sel_mea, color=sel_dim, template="plotly_white", height=420)
+        st.plotly_chart(fig7, use_container_width=True)
+        st.dataframe(g.sort_values(sel_mea, ascending=False), use_container_width=True, height=260)
+    else:
+        st.info("Adjust filters to see data.")
+
+with tab4:
+    st.subheader("What-if: Payment Terms and Delivery Delays")
+
+    # Simple simulation: change payment terms and hypothetical delay impact on OTIF
+    term_delta = st.slider("Payment term change (days)", -30, 30, 0, step=5)
+    delay_rate = st.slider("Simulate delivery delay rate (%)", 0, 50, 10, step=5)
+
+    def run_sim(df_in, term_delta, delay_rate):
+        sim = df_in.copy()
+        # Adjust payment days
+        sim["PaymentDaysSim"] = sim["PaymentDays"] + term_delta
+        # Apply simple OTIF penalty based on delay rate
+        penalty = delay_rate / 100.0
+        sim["OTIF_Sim"] = np.clip(sim["OTIF"] * (1 - penalty) + (1 - sim["OTIF"]) * (1 - penalty/2), 0, 1)
+        # Assume carrying cost impact: +0.02% per extra payment day on spend
+        delta_days = np.maximum(sim["PaymentDaysSim"] - sim["PaymentDays"], 0)
+        sim["CarryingCostAdj"] = sim["NetValue"] * (0.0002 * delta_days)
+        return sim
+
+    if len(fdf):
+        simdf = run_sim(fdf, term_delta, delay_rate)
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            kpi_card("OTIF (Simulated)", f"{(simdf['OTIF_Sim'].mean()*100):.0f}%")
+        with c2:
+            kpi_card("PaymentDays Δ", f"{term_delta:+d}d")
+        with c3:
+            kpi_card("Carrying Cost Adj", f"${simdf['CarryingCostAdj'].sum():,.0f}")
+
+        st.caption("Supplier-level OTIF change")
+        g = simdf.groupby("Supplier", as_index=False)[["OTIF","OTIF_Sim"]].mean()
+        g["OTIF"] = (g["OTIF"]*100).round(1)
+        g["OTIF_Sim"] = (g["OTIF_Sim"]*100).round(1)
+        fig8 = px.bar(g.melt(id_vars="Supplier", value_vars=["OTIF","OTIF_Sim"], var_name="Metric", value_name="OTIF%"), x="Supplier", y="OTIF%", color="Metric", barmode="group", template="plotly_white", height=400)
+        st.plotly_chart(fig8, use_container_width=True)
+        st.dataframe(g.sort_values("OTIF_Sim", ascending=False), use_container_width=True, height=260)
+    else:
+        st.info("No data to simulate. Adjust filters.")
+
+# ---------------------------
+# Agentic Chat (Demo)
+# ---------------------------
+st.markdown("---")
+st.subheader("Agent Assistant")
+st.caption("Ask procurement questions, e.g., “Top suppliers by OTIF this month,” “Compare ACME vs GLOBAL_MFG on price and lead time,” “Show spend by RM group last 30 days.”")
+
+if "messages" not in st.session_state:
+    st.session_state.messages = [
+        {"role": "assistant", "content": "Hello! I can analyze procurement data, compute KPIs, and run what‑if simulations. What would you like to see?"}
+    ]
+
+# Simple tool functions (CDS-like queries)
+def tool_top_suppliers_by(metric="OTIF", topn=5):
+    if not len(fdf): return "No data in current selection."
+    g = fdf.groupby("Supplier", as_index=False)[metric].mean()
+    if metric != "OTIF":
+        # For value metrics that make sense as sum (e.g., NetValue)
+        if metric in ["NetValue","Quantity"]:
+            g = fdf.groupby("Supplier", as_index=False)[metric].sum()
+    g = g.sort_values(metric, ascending=False).head(topn)
+    return g
+
+def tool_compare_suppliers(sup_a, sup_b):
+    sub = fdf[fdf["Supplier"].isin([sup_a, sup_b])]
+    if not len(sub): return "No data for those suppliers in current selection."
+    stats = sub.groupby("Supplier").agg(
+        Spend=("NetValue","sum"),
+        AvgPrice=("NetPrice","mean"),
+        AvgLead=("LeadTimeDays","mean"),
+        OTIF=("OTIF","mean")
+    ).reset_index()
+    stats["OTIF%"] = (stats["OTIF"]*100).round(1)
+    return stats
+
+def tool_spend_by_dim(dim="MaterialGroup"):
+    if not len(fdf): return None
+    g = fdf.groupby(dim, as_index=False)["NetValue"].sum().sort_values("NetValue", ascending=False)
+    return g
+
+def tool_show_recent_po_lines(n=10):
+    if not len(fdf): return None
+    cols = ["PO_ID","PO_Item","PO_Date","Supplier","Material","Quantity","OrderUnit","NetPrice","NetValue","DeliveryDate","Status","LeadTimeDays","OTIF"]
+    return fdf.sort_values("PO_Date", ascending=False)[cols].head(n)
+
+# Heuristic “planner” to route user intents to tools
+def agent_router(prompt: str):
+    p = prompt.lower().strip()
+    # pattern routes
+    if "top" in p and "supplier" in p and "otif" in p:
+        n = 5
+        for tok in p.split():
+            if tok.isdigit():
+                n = int(tok)
+                break
+        return ("top_suppliers_otif", {"topn": n})
+    if "compare" in p and "supplier" in p:
+        # naive extract A vs B
+        tokens = p.replace("compare","").replace("supplier","").replace("suppliers","").replace(" vs "," ").split()
+        # heuristic: choose two known supplier names intersected
+        known = set(df["Supplier"].unique().tolist())
+        picks = [t for t in tokens if t.upper() in known]
+        if len(picks) >= 2:
+            return ("compare_suppliers", {"a": picks[0].upper(), "b": picks[1].upper()})
+        return ("compare_suppliers", {"a": "ACME_SUPPLY", "b": "GLOBAL_MFG"})
+    if "spend" in p and ("material group" in p or "group" in p):
+        return ("spend_by_dim", {"dim": "MaterialGroup"})
+    if "recent" in p or ("last" in p and "po" in p):
+        return ("recent_pos", {"n": 10})
+    if "lead time" in p and "supplier" in p:
+        return ("lead_by_supplier", {})
+    if "price" in p and "supplier" in p:
+        return ("price_by_supplier", {})
+    # default: summary
+    return ("summary", {})
+
+def agent_execute(route, args):
+    if route == "top_suppliers_otif":
+        g = tool_top_suppliers_by("OTIF", topn=args.get("topn",5))
+        if isinstance(g, str):
+            return g, None
+        g2 = g.copy()
+        g2["OTIF%"] = (g2["OTIF"]*100).round(1)
+        fig = px.bar(g2, x="Supplier", y="OTIF%", color="Supplier", template="plotly_white", height=360)
+        return "Top suppliers by OTIF:", fig
+
+    if route == "compare_suppliers":
+        stats = tool_compare_suppliers(args.get("a"), args.get("b"))
+        if isinstance(stats, str):
+            return stats, None
+        fig = px.bar(stats, x="Supplier", y=["Spend","AvgPrice","AvgLead","OTIF"], barmode="group", template="plotly_white", height=420)
+        return "Comparison across Spend, AvgPrice, AvgLead, and OTIF:", fig
+
+    if route == "spend_by_dim":
+        g = tool_spend_by_dim(args.get("dim","MaterialGroup"))
+        if g is None:
+            return "No data for spend by dimension.", None
+        fig = px.treemap(g, path=[args.get("dim","MaterialGroup")], values="NetValue", height=420)
+        return f"Spend by {args.get('dim','MaterialGroup')}:", fig
+
+    if route == "recent_pos":
+        lines = tool_show_recent_po_lines(args.get("n",10))
+        if lines is None:
+            return "No recent PO lines found.", None
+        st.dataframe(lines, use_container_width=True, height=260)
+        return f"Showing {len(lines)} most recent PO lines.", None
+
+    if route == "lead_by_supplier":
+        if not len(fdf): return "No data.", None
+        g = fdf.groupby("Supplier", as_index=False)["LeadTimeDays"].mean()
+        fig = px.bar(g.sort_values("LeadTimeDays"), x="LeadTimeDays", y="Supplier", orientation="h", template="plotly_white", height=420)
+        return "Average lead time by supplier:", fig
+
+    if route == "price_by_supplier":
+        if not len(fdf): return "No data.", None
+        g = fdf.groupby("Supplier", as_index=False)["NetPrice"].mean()
+        fig = px.bar(g.sort_values("NetPrice", ascending=False), x="Supplier", y="NetPrice", template="plotly_white", height=420)
+        return "Average price by supplier:", fig
+
+    # summary
+    msg = f"In current selection: {fdf['PO_ID'].nunique()} POs, spend ${fdf['NetValue'].sum():,.0f}, avg lead time {fdf['LeadTimeDays'].mean():.1f}d, OTIF {(fdf['OTIF'].mean()*100):.0f}%."
+    return msg, None
+
+# Render chat history
+for m in st.session_state.messages:
+    with st.chat_message(m["role"], avatar="🧭" if m["role"]=="assistant" else "🧑🏻"):
+        st.write(m["content"])
+
+prompt = st.chat_input("Ask about procurement performance, suppliers, KPIs, or simulations…")
+if prompt:
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user", avatar="🧑🏻"):
+        st.write(prompt)
+
+    with st.chat_message("assistant", avatar="🧭"):
+        with st.status("Thinking…", expanded=False):
+            route, args = agent_router(prompt)
+            text, fig = agent_execute(route, args)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+        if text:
+            st.write(text)
+        if fig is not None:
+            st.plotly_chart(fig, use_container_width=True)
+        st.session_state.messages.append({"role": "assistant", "content": text or "(shown as chart/table)"})