This section follows the current sidebar filters. Region, store, and category stay aligned with the left panel.
', unsafe_allow_html=True)
st.markdown('Store-level comparison now follows the current sidebar filter. If the filter includes one store, you get a pure same-store comparison. If it includes multiple stores, you get the filtered store portfolio comparison.
', unsafe_allow_html=True)
store_weekpart, region_weekpart = build_weekpart_inventory_views(cat_df)
d1, d2 = st.columns([1.2, 1])
with d1:
region_week_melt = region_weekpart.melt(
id_vars=["region", "week_part"],
value_vars=[
"avg_inventory", "avg_demand", "avg_remaining",
"avg_profit", "stockout_rate", "waste_pct"
],
var_name="metric",
value_name="value",
)
fig = px.bar(
region_week_melt,
x="region",
y="value",
color="week_part",
facet_row="metric",
barmode="group",
title=f"{focus}: same-region weekday vs weekend comparison",
height=1100,
)
fig.update_yaxes(matches=None)
st.plotly_chart(fig, use_container_width=True)
with d2:
filtered_store_focus = (
store_weekpart.groupby("week_part")
.agg(
avg_inventory=("avg_inventory", "mean"),
avg_demand=("avg_demand", "mean"),
avg_remaining=("avg_remaining", "mean"),
unmet_demand=("unmet_demand", "mean"),
stockout_rate=("stockout_rate", "mean"),
waste_pct=("waste_pct", "mean"),
avg_profit=("avg_profit", "mean"),
)
.reset_index()
)
if not filtered_store_focus.empty:
fig = px.bar(
filtered_store_focus.melt(
id_vars=["week_part"],
value_vars=[
"avg_inventory", "avg_demand", "avg_remaining",
"unmet_demand", "stockout_rate", "waste_pct", "avg_profit"
],
var_name="metric",
value_name="value",
),
x="metric",
y="value",
color="week_part",
barmode="group",
title="Filtered stores: weekday vs weekend comparison",
)
st.plotly_chart(fig, use_container_width=True)
e1, e2 = st.columns([1.05, 1.15])
with e1:
region_week_pivot = region_weekpart.pivot(
index="region",
columns="week_part",
values=[
"avg_inventory", "avg_remaining", "avg_demand", "avg_units_sold",
"sell_through", "stockout_rate", "unmet_demand", "waste_pct",
"units_wasted", "avg_profit", "avg_margin", "markdown_rate",
"promo_rate", "avg_days_until_expiry", "temp_dev", "spoilage_risk"
],
)
region_week_pivot.columns = [f"{a}_{b}" for a, b in region_week_pivot.columns]
region_week_pivot = region_week_pivot.reset_index()
delta_metrics = [
"avg_inventory", "avg_remaining", "avg_demand", "avg_units_sold",
"sell_through", "stockout_rate", "unmet_demand", "waste_pct",
"units_wasted", "avg_profit", "avg_margin", "markdown_rate",
"promo_rate", "avg_days_until_expiry", "temp_dev", "spoilage_risk"
]
for metric in delta_metrics:
wd = f"{metric}_Weekday"
we = f"{metric}_Weekend"
if wd in region_week_pivot.columns and we in region_week_pivot.columns:
region_week_pivot[f"{metric}_weekend_minus_weekday"] = region_week_pivot[we] - region_week_pivot[wd]
st.markdown("### Region weekday/weekend delta table")
st.dataframe(region_week_pivot, use_container_width=True, hide_index=True)
with e2:
filtered_store_table = store_weekpart.copy()
if not filtered_store_table.empty:
filtered_store_table = filtered_store_table.rename(columns={"store_id": "store"})
st.markdown("### Filter-aligned store weekday/weekend indicators")
st.dataframe(filtered_store_table, use_container_width=True, hide_index=True)
weekday_view = region_weekpart[region_weekpart["week_part"] == "Weekday"].set_index("region")
weekend_view = region_weekpart[region_weekpart["week_part"] == "Weekend"].set_index("region")
common_regions = sorted(set(weekday_view.index).intersection(set(weekend_view.index)))
if common_regions:
for region in common_regions:
wd = weekday_view.loc[region]
we = weekend_view.loc[region]
pieces = []
demand_delta = we["avg_demand"] - wd["avg_demand"]
inventory_delta = we["avg_inventory"] - wd["avg_inventory"]
remaining_delta = we["avg_remaining"] - wd["avg_remaining"]
stockout_delta = we["stockout_rate"] - wd["stockout_rate"]
waste_delta = we["waste_pct"] - wd["waste_pct"]
profit_delta = we["avg_profit"] - wd["avg_profit"]
markdown_delta = we["markdown_rate"] - wd["markdown_rate"]
promo_delta = we["promo_rate"] - wd["promo_rate"]
if demand_delta > 0:
pieces.append(f"weekend demand is higher by {demand_delta:.1f}")
else:
pieces.append(f"weekday demand is higher by {abs(demand_delta):.1f}")
if inventory_delta > 0:
pieces.append(f"weekend inventory is higher by {inventory_delta:.1f}")
else:
pieces.append(f"weekday inventory is higher by {abs(inventory_delta):.1f}")
if remaining_delta > 0:
pieces.append(f"weekend leftover stock rises by {remaining_delta:.1f}")
elif remaining_delta < 0:
pieces.append(f"weekday leftover stock rises by {abs(remaining_delta):.1f}")
if stockout_delta > 0.01:
pieces.append(f"weekend stockout risk is worse by {stockout_delta:.1%}")
elif stockout_delta < -0.01:
pieces.append(f"weekday stockout risk is worse by {abs(stockout_delta):.1%}")
if waste_delta > 0.01:
pieces.append(f"weekend waste is higher by {waste_delta:.1%}")
elif waste_delta < -0.01:
pieces.append(f"weekday waste is higher by {abs(waste_delta):.1%}")
pieces.append(f"profit shifts by €{profit_delta:.2f} from weekday to weekend")
pieces.append(f"markdown changes by {markdown_delta:.1%} on weekends")
pieces.append(f"promotion rate changes by {promo_delta:.1%} on weekends")
st.markdown(f"- **{region}**: " + "; ".join(pieces) + ".")
st.markdown("### Regional recommendations")
mean_stockout = region_summary["stockout_rate"].mean()
mean_waste = region_summary["waste_pct"].mean()
mean_margin = region_summary["avg_margin"].mean()
mean_temp = region_summary["temp_dev"].mean()
mean_expiry = region_summary["days_until_expiry"].mean()
for _, r in region_summary.iterrows():
advice = []
if r["stockout_rate"] > mean_stockout:
advice.append("raise replenishment and morning safety stock")
if r["waste_pct"] > mean_waste:
advice.append("start markdown earlier")
if r["avg_margin"] < mean_margin:
advice.append("use bundles instead of deeper discounts")
if r["temp_dev"] > mean_temp:
advice.append("tighten storage handling")
if r["days_until_expiry"] < mean_expiry:
advice.append("prioritize fresher inbound allocation")
if not advice:
advice.append("maintain and scale current playbook")
st.markdown(f"- **{r['region']}**: " + "; ".join(advice) + ".")
st.markdown("### Marketing design simulator")
m1, m2, m3, m4 = st.columns(4)
promo_region = m1.selectbox("Target region", sorted(cat_df["region"].dropna().unique()), key="cat_region")
promo_type = m2.selectbox("Promo type", ["Early markdown", "Breakfast bundle", "Happy-hour discount", "Loyalty coupon"])
discount = m3.slider("Discount %", 0, 40, 15, key="cat_discount")
duration = m4.slider("Duration (days)", 1, 10, 4, key="cat_duration")
base = cat_df[cat_df["region"] == promo_region].copy()
base_sales = base["units_sold"].mean()
base_waste = base["waste_pct"].mean()
base_profit = base["profit"].mean()
promo_factor = {"Early markdown": 0.12, "Breakfast bundle": 0.16, "Happy-hour discount": 0.10, "Loyalty coupon": 0.08}[promo_type]
sales_lift = promo_factor + discount / 180 + min(duration / 60, 0.10)
waste_drop = min(0.42, promo_factor + discount / 200)
margin_drag = discount / 160 * (0.75 if promo_type == "Breakfast bundle" else 1.0)
est_sales = base_sales * (1 + sales_lift)
est_waste = max(base_waste * (1 - waste_drop), 0)
est_profit = base_profit * (1 + sales_lift - margin_drag)
x1, x2, x3 = st.columns(3)
x1.metric("Estimated avg units sold", f"{est_sales:.2f}", delta=f"+{(est_sales-base_sales):.2f}")
x2.metric("Estimated waste", f"{est_waste:.1%}", delta=f"-{(base_waste-est_waste):.1%}")
x3.metric("Estimated avg profit", f"€{est_profit:.2f}", delta=f"€{(est_profit-base_profit):.2f}")
def generate_summary(df: pd.DataFrame) -> str:
waste = df["waste_pct"].mean()
profit = df["profit"].mean()
stockout = (df["daily_demand"] > df["initial_quantity"]).mean()
worst_region = df.groupby("region")["waste_pct"].mean().idxmax()
best_region = df.groupby("region")["profit"].mean().idxmax()
return f"""
- Average waste rate is **{waste:.1%}**, indicating {'high inefficiency' if waste > 0.2 else 'acceptable performance'}.
- Average profit is **EUR {profit:.2f}**, with strongest performance in **{best_region}**.
- Stockout rate is **{stockout:.1%}**, suggesting {'understocking risk' if stockout > 0.2 else 'balanced supply'}.
Key issue:
- Highest waste occurs in **{worst_region}**.
Recommended actions:
- Advance markdown timing for short-life products.
- Rebalance inventory using demand signals.
- Use bundles instead of deeper discounts where possible.
"""
def generate_slide_insights(df: pd.DataFrame):
insights = []
if df["waste_pct"].mean() > 0.2:
insights.append("High waste is driven by short shelf-life items and delayed markdown timing.")
if (df["daily_demand"] > df["initial_quantity"]).mean() > 0.2:
insights.append("Frequent stockouts indicate under-forecasting of demand in key regions.")
if df["discount_pct"].mean() > 0.25:
insights.append("Over-reliance on discounting is reducing margin quality.")
if df["temp_deviation"].mean() > 2:
insights.append("Temperature deviation is materially contributing to spoilage risk.")
if not insights:
insights.append("Current performance is stable, with room to optimize promotion quality and inventory precision.")
return insights
def build_transfer_suggestions(view_df: pd.DataFrame, full_df: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
if "store_lat" not in view_df.columns or "store_lon" not in view_df.columns:
view_df = attach_store_locations(view_df.copy())
if "store_lat" not in full_df.columns or "store_lon" not in full_df.columns:
full_df = attach_store_locations(full_df.copy())
store_summary = (
view_df.groupby(["store_id", "region"])
.agg(
total_inventory=("initial_quantity", "sum"),
units_sold=("units_sold", "sum"),
remaining_inventory=("leftover_units", "sum"),
total_demand=("daily_demand", "sum"),
unmet_demand=("lost_sales_units", "sum"),
)
.reset_index()
)
store_summary["inventory_gap"] = store_summary["remaining_inventory"] - store_summary["unmet_demand"]
receiving_need = (
view_df.groupby(["store_id", "region", "category", "store_lat", "store_lon"])
.agg(
remaining_inventory=("leftover_units", "sum"),
demand=("daily_demand", "sum"),
unmet_demand=("lost_sales_units", "sum"),
receiver_days_until_expiry=("days_until_expiry", "mean"),
)
.reset_index()
)
receiving_need = receiving_need[receiving_need["unmet_demand"] > 0].copy()
if receiving_need.empty:
return store_summary, pd.DataFrame(columns=[
"store_id", "region", "category", "remaining_inventory", "demand", "unmet_demand",
"recommended_transfer_qty", "same_region_options", "cross_region_options", "best_route"
])
donor_pool = (
full_df.groupby(["store_id", "region", "category", "store_lat", "store_lon"])
.agg(
donor_remaining=("leftover_units", "sum"),
donor_demand=("daily_demand", "sum"),
donor_days_until_expiry=("days_until_expiry", "mean"),
)
.reset_index()
)
donor_pool["surplus_qty"] = donor_pool["donor_remaining"] - donor_pool["donor_demand"]
donor_pool = donor_pool[donor_pool["surplus_qty"] > 0].copy()
def distance_km(lat1, lon1, lat2, lon2):
# simple equirectangular approximation, good enough for prioritization
x = (math.radians(lon2) - math.radians(lon1)) * math.cos((math.radians(lat1) + math.radians(lat2)) / 2)
y = math.radians(lat2) - math.radians(lat1)
return 6371 * math.sqrt(x * x + y * y)
rows = []
for _, r in receiving_need.iterrows():
donors = donor_pool[
(donor_pool["category"] == r["category"]) &
(donor_pool["store_id"] != r["store_id"]) &
(donor_pool["surplus_qty"] > 0)
].copy()
if donors.empty:
row = r.to_dict()
row["recommended_transfer_qty"] = 0
row["same_region_options"] = "No same-region donor"
row["cross_region_options"] = "No cross-region donor"
row["best_route"] = "No feasible transfer"
rows.append(row)
continue
donors["priority_rank"] = (donors["region"] != r["region"]).astype(int) # same region first
donors["distance_km"] = donors.apply(
lambda d: distance_km(r["store_lat"], r["store_lon"], d["store_lat"], d["store_lon"]),
axis=1
)
# Prefer donors with more remaining shelf life after distance/region
donors = donors.sort_values(
["priority_rank", "distance_km", "donor_days_until_expiry", "surplus_qty"],
ascending=[True, True, False, False]
)
same_region = donors[donors["priority_rank"] == 0].head(3)
cross_region = donors[donors["priority_rank"] == 1].head(3)
best = donors.iloc[0]
transfer_qty = int(min(r["unmet_demand"], max(best["surplus_qty"], 0)))
def donor_label(d):
tier = "same-region" if d["priority_rank"] == 0 else "cross-region"
return f"{d['store_id']} ({tier}, {d['distance_km']:.0f} km, expiry {d['donor_days_until_expiry']:.1f}d, surplus {int(d['surplus_qty'])})"
same_region_text = "; ".join(donor_label(d) for _, d in same_region.iterrows()) if not same_region.empty else "No same-region donor"
cross_region_text = "; ".join(donor_label(d) for _, d in cross_region.iterrows()) if not cross_region.empty else "No cross-region donor"
best_route = donor_label(best)
row = r.to_dict()
row["recommended_transfer_qty"] = transfer_qty
row["same_region_options"] = same_region_text
row["cross_region_options"] = cross_region_text
row["best_route"] = best_route
rows.append(row)
transfer_df = pd.DataFrame(rows)
return store_summary, transfer_df
def train_decision_tree(df: pd.DataFrame):
features = ["daily_demand", "initial_quantity", "days_until_expiry", "temp_deviation", "discount_pct"]
X = df[features]
y = df["high_waste_flag"]
model = DecisionTreeClassifier(max_depth=4, random_state=42)
model.fit(X, y)
return model, features
def manager_summary(df: pd.DataFrame):
st.subheader("Executive Summary")
st.markdown(generate_summary(df))
st.markdown("### Slide-ready insights")
for ins in generate_slide_insights(df):
st.success(ins)
def manager_diagnose(df: pd.DataFrame):
st.subheader("Diagnose")
st.markdown("Use the custom thresholds below to define what counts as **high waste** and **high profit** for the current filtered data.")
w1, w2 = st.columns(2)
with w1:
waste_threshold = st.number_input(
"High waste threshold (waste_pct)",
min_value=0.0,
value=float(df["waste_pct"].median()),
step=0.01,
format="%.3f",
help="Rows with waste_pct above this value are classified as High Waste.",
)
with w2:
profit_threshold = st.number_input(
"High profit threshold (profit)",
value=float(df["profit"].median()),
step=1.0,
format="%.2f",
help="Rows with profit above this value are classified as High Profit.",
)
diag = df.copy()
diag["waste_high_custom"] = (diag["waste_pct"] > waste_threshold).astype(int)
diag["profit_high_custom"] = (diag["profit"] > profit_threshold).astype(int)
st.info(
f"Current rule: High Waste = waste_pct > {waste_threshold:.3f}; High Profit = profit > {profit_threshold:.2f}. "
f"Promotion effectiveness remains defined as promoted items whose sell-through is above the filtered median."
)
c1, c2, c3 = st.columns(3)
c1.metric("High waste share", f"{diag['waste_high_custom'].mean():.1%}")
c2.metric("High profit share", f"{diag['profit_high_custom'].mean():.1%}")
c3.metric("Effective promo share", f"{diag['promo_effective'].mean():.1%}")
tree_df = diag.copy()
tree_df["high_waste_flag"] = tree_df["waste_high_custom"]
model, features = train_decision_tree(tree_df)
fig, ax = plt.subplots(figsize=(12, 6))
plot_tree(model, feature_names=features, class_names=["Low Waste", "High Waste"], filled=True, ax=ax)
st.pyplot(fig)
plt.close(fig)
importance_df = pd.DataFrame({"feature": features, "importance": model.feature_importances_}).sort_values("importance", ascending=False)
fig2 = px.bar(importance_df, x="importance", y="feature", orientation="h", title="Decision Tree Split Importance")
st.plotly_chart(fig2, use_container_width=True)
st.markdown("### Classification views")
c4, c5 = st.columns(2)
with c4:
waste_by_region = diag.groupby("region")[["waste_high_custom", "profit_high_custom"]].mean().reset_index()
melt = waste_by_region.melt(id_vars="region", var_name="label", value_name="rate")
fig3 = px.bar(melt, x="region", y="rate", color="label", barmode="group", title="High Waste vs High Profit by Region")
st.plotly_chart(fig3, use_container_width=True)
with c5:
promo_by_cat = diag.groupby("category")["promo_effective"].mean().sort_values(ascending=False).reset_index()
fig4 = px.bar(promo_by_cat, x="promo_effective", y="category", orientation="h", title="Promotion Effectiveness by Category")
st.plotly_chart(fig4, use_container_width=True)
def manager_inventory(df: pd.DataFrame, full_df: pd.DataFrame):
st.subheader("Inventory & Replenishment")
store_summary, transfer_df = build_transfer_suggestions(df, full_df)
overstock = df.copy()
overstock["recommended_order_qty"] = (
1.2 * overstock["daily_demand"] * (1 + overstock["demand_variability"])
- overstock["leftover_units"]
)
overstock.loc[overstock["shelf_life_days"] <= 7, "recommended_order_qty"] *= 0.7
overstock.loc[overstock["spoilage_risk"] >= overstock["spoilage_risk"].quantile(0.75), "recommended_order_qty"] *= 0.8
overstock["recommended_order_qty"] = overstock["recommended_order_qty"].clip(lower=0).round()
c1, c2 = st.columns([1.3, 1])
with c1:
category_summary = overstock.groupby("category")[["initial_quantity", "recommended_order_qty", "waste_pct", "profit"]].mean().reset_index()
category_summary["order_reduction_pct"] = 1 - category_summary["recommended_order_qty"] / category_summary["initial_quantity"]
fig = px.bar(
category_summary.sort_values("order_reduction_pct", ascending=False),
x="order_reduction_pct",
y="category",
orientation="h",
title="Recommended Order Reduction by Category",
)
st.plotly_chart(fig, use_container_width=True)
with c2:
st.markdown("**Action shortlist**")
shortlist = overstock.sort_values(["waste_pct", "stock_demand_ratio"], ascending=[False, False])[[
"store_id", "product_name", "category", "initial_quantity", "daily_demand",
"days_until_expiry", "waste_pct", "recommended_order_qty"
]].head(20)
shortlist = with_product_elements(shortlist)
st.dataframe(
shortlist[["store_id", "product_item", "category_tag", "initial_quantity", "daily_demand", "days_until_expiry", "waste_pct", "recommended_order_qty"]],
use_container_width=True,
hide_index=True,
)
st.markdown("### What-if Simulator")
col1, col2, col3 = st.columns(3)
selected_category = col1.selectbox("Category for simulation", sorted(df["category"].unique()))
order_cut = col2.slider("Reduce order quantity by %", 0, 40, 10)
markdown_shift = col3.slider("Advance markdown trigger by days", 0, 5, 2)
sim = df[df["category"] == selected_category].copy()
current_waste = sim["waste_pct"].mean()
current_profit = sim["profit"].mean()
waste_reduction = 0.35 * (order_cut / 100) + 0.015 * markdown_shift
sim_waste = max(current_waste * (1 - waste_reduction), 0)
sim_profit = current_profit * (1 + 0.08 * (order_cut / 100) + 0.03 * markdown_shift)
s1, s2, s3 = st.columns(3)
s1.metric("Current waste", f"{current_waste:.1%}")
s2.metric("Simulated waste", f"{sim_waste:.1%}", delta=f"-{(current_waste-sim_waste):.1%}")
s3.metric("Simulated avg profit", f"€{sim_profit:.2f}", delta=f"€{(sim_profit-current_profit):.2f}")
st.markdown("### Store inventory balance")
st.dataframe(store_summary.sort_values(["unmet_demand", "remaining_inventory"], ascending=[False, False]), use_container_width=True, hide_index=True)
st.markdown("### Transfer suggestions for stores where demand exceeds available inventory")
st.caption("Routing logic: same-region donors are prioritized first, cross-region donors are used as second-best options, and donors are ranked by transport distance then remaining shelf life.")
if transfer_df.empty:
st.success("No filtered store currently shows unmet demand that needs transfer support.")
else:
show_cols = [
"store_id", "region", "category", "remaining_inventory", "demand", "unmet_demand",
"recommended_transfer_qty", "best_route", "same_region_options", "cross_region_options"
]
transfer_show = transfer_df.sort_values(["unmet_demand", "recommended_transfer_qty"], ascending=[False, False])[show_cols].copy()
transfer_show = with_product_elements(transfer_show, product_col="category", category_col="category")
st.dataframe(
transfer_show,
use_container_width=True,
hide_index=True,
)
def manager_promotions(df: pd.DataFrame):
st.subheader("Promotion Designer")
left, right = st.columns([1, 1.2])
with left:
promo_category = st.selectbox("Promotion category", sorted(df["category"].unique()), key="promo_cat")
expiry_target = st.selectbox("Target expiry bucket", ["<=1d", "2-3d", "4-7d", "8-30d", ">30d"])
discount = st.slider("Discount %", 0, 50, 18)
bundle = st.checkbox("Bundle with complementary items", value=True)
weekend_only = st.checkbox("Weekend campaign only", value=False)
sub = df[(df["category"] == promo_category) & (df["expiry_bucket"].astype(str) == expiry_target)].copy()
if weekend_only:
sub = sub[sub["is_weekend"] == 1]
demand_lift = 0.08 + discount / 200
if bundle:
demand_lift += 0.06
est_sales_uplift = sub["units_sold"].mean() * demand_lift if len(sub) else 0
est_waste_drop = sub["waste_pct"].mean() * min(0.35, demand_lift) if len(sub) else 0
est_profit = sub["profit"].mean() * (1 + demand_lift - discount / 150) if len(sub) else 0
st.metric("Estimated sales uplift", f"{est_sales_uplift:.2f} units")
st.metric("Estimated waste reduction", f"{est_waste_drop:.1%}")
st.metric("Estimated avg profit", f"€{est_profit:.2f}")
with right:
promo_base = df.groupby(["expiry_bucket"])[["discount_pct", "waste_pct", "profit"]].mean().reset_index()
fig = px.bar(promo_base, x="expiry_bucket", y=["discount_pct", "waste_pct"], barmode="group", title="Current Discount vs Waste by Expiry")
st.plotly_chart(fig, use_container_width=True)
st.markdown("**Recommended promotion copy**")
st.info(
f"Run a {discount}% {promo_category} campaign for {expiry_target} items"
+ (" on weekends" if weekend_only else "")
+ (" with bundle offers" if bundle else " as single-item markdown")
+ ". Position the offer at high-traffic display zones and highlight value + freshness."
)
def manager_risk(df: pd.DataFrame):
st.subheader("Risk & Store Operations")
_, importances = fit_risk_model(df)
c1, c2 = st.columns([1.1, 1])
with c1:
fig = px.bar(importances.head(10).sort_values(), orientation="h", title="Top Drivers of High Waste Risk")
st.plotly_chart(fig, use_container_width=True)
with c2:
heat = df.groupby(["region", "category"])["temp_deviation"].mean().reset_index()
fig = px.density_heatmap(heat, x="category", y="region", z="temp_deviation", title="Temperature Deviation Heatmap")
st.plotly_chart(fig, use_container_width=True)
alerts = (
df.groupby("store_id")[["temp_deviation", "temp_abuse_events", "waste_pct", "profit"]]
.mean()
.assign(alert_score=lambda x: 0.35 * x["temp_deviation"] + 0.25 * x["temp_abuse_events"] + 0.4 * x["waste_pct"] * 10)
.sort_values("alert_score", ascending=False)
.head(15)
.reset_index()
)
st.markdown("### Automated store alerts")
st.dataframe(alerts, use_container_width=True, hide_index=True)
def consumer_deals(df: pd.DataFrame):
st.subheader("Consumer Mode")
c1, c2, c3 = st.columns(3)
max_budget = c1.slider("Budget (€)", 5, 60, 20)
preferred_category = c2.selectbox("Preferred category", ["All"] + sorted(df["category"].unique()))
max_expiry = c3.slider("Maximum days until expiry", 1, 14, 5)
deals = df[df["days_until_expiry"] <= max_expiry].copy()
if preferred_category != "All":
deals = deals[deals["category"] == preferred_category]
deals = deals.assign(
savings=lambda x: x["base_price"] - x["selling_price"],
deal_score=lambda x: x["discount_pct"] * 0.5 + x["value_score"] * 0.35 + (x["profit_margin_pct"].clip(lower=0) / 100) * 0.15,
).sort_values(["deal_score", "savings"], ascending=False)
display = deals[[
"product_name", "category", "store_id", "days_until_expiry",
"base_price", "selling_price", "discount_pct", "savings"
]].head(25)
st.dataframe(display, use_container_width=True, hide_index=True)
fig = px.scatter(
deals.head(500), x="selling_price", y="discount_pct", color="category",
hover_data=["product_name", "store_id", "days_until_expiry"],
title="Discounted Items Map"
)
st.plotly_chart(fig, use_container_width=True)
affordable = deals[deals["selling_price"] <= max_budget].head(10)
if not affordable.empty:
st.markdown("### Best picks for your budget")
for _, row in affordable.iterrows():
st.success(
f"Now €{row['selling_price']:.2f} (save €{row['base_price'] - row['selling_price']:.2f}) · expires in {int(row['days_until_expiry'])} day(s)"
)
st.markdown(
f"""
🛒 **{row['product_name']}**
📦 Category: {row['category']}
🏪 Store: {row['store_id']}
💸 Discount: {row['discount_pct']*100:.0f}%
⏳ Expiry: {row['days_until_expiry']} days
"""
)
def build_bundle(df: pd.DataFrame, budget: float, people: int, theme: str):
work = df.copy()
work = work[work["days_until_expiry"] <= 7].copy()
work["score"] = work["value_score"] + work["discount_pct"]
theme_map = {
"Quick dinner": ["Ready_to_Eat", "Produce", "Bakery", "Dairy"],
"Healthy protein": ["Meat", "Seafood", "Dairy", "Produce"],
"Family breakfast": ["Bakery", "Dairy", "Beverages", "Produce"],
"Budget saver": list(work["category"].unique()),
}
cats = theme_map.get(theme, list(work["category"].unique()))
work = work[work["category"].isin(cats)].sort_values(["score", "selling_price"], ascending=[False, True])
chosen = []
remaining = budget
target_items = min(max(people + 1, 3), 6)
used_categories = set()
for _, row in work.iterrows():
if row["selling_price"] <= remaining:
if theme != "Budget saver" and row["category"] in used_categories:
continue
chosen.append(row)
remaining -= row["selling_price"]
used_categories.add(row["category"])
if len(chosen) >= target_items:
break
if not chosen:
return pd.DataFrame(), 0.0, 0.0
bundle = pd.DataFrame(chosen)
total = bundle["selling_price"].sum()
saved = (bundle["base_price"] - bundle["selling_price"]).sum()
return bundle, total, saved
def consumer_bundles(df: pd.DataFrame):
st.subheader("Bundle Builder")
c1, c2, c3 = st.columns(3)
budget = c1.slider("Bundle budget (€)", 8, 80, 25)
people = c2.slider("People", 1, 6, 2)
theme = c3.selectbox("Bundle theme", ["Quick dinner", "Healthy protein", "Family breakfast", "Budget saver"])
bundle, total, saved = build_bundle(df, budget, people, theme)
if bundle.empty:
st.warning("No bundle found for the current filters.")
return
k1, k2, k3 = st.columns(3)
k1.metric("Bundle total", f"€{total:.2f}")
k2.metric("You save", f"€{saved:.2f}")
k3.metric("Items", f"{len(bundle)}")
st.dataframe(bundle[[
"product_name", "category", "store_id", "selling_price", "base_price", "discount_pct", "days_until_expiry"
]], use_container_width=True, hide_index=True)
st.info(
"Suggested marketing use: turn these bundles into one-click promotions for end customers or pre-designed campaign packs for store managers."
)
def consumer_personal(df: pd.DataFrame):
st.subheader("Personalized Promotions")
favorite = st.selectbox("Favorite category", sorted(df["category"].unique()))
price_cap = st.slider("Max item price (€)", 1, 30, 10)
not_too_close = st.checkbox("Hide items expiring within 1 day", value=False)
recs = df[df["category"] == favorite].copy()
recs = recs[recs["selling_price"] <= price_cap]
if not_too_close:
recs = recs[recs["days_until_expiry"] > 1]
recs = recs.assign(score=lambda x: x["discount_pct"] * 0.55 + x["value_score"] * 0.45).sort_values("score", ascending=False).head(12)
cols = st.columns(3)
for i, (_, row) in enumerate(recs.iterrows()):
with cols[i % 3]:
st.markdown(f"### {row['product_name']}")
st.write(f"{row['category']} · {row['store_id']}")
st.write(f"Now **€{row['selling_price']:.2f}** | Save **€{(row['base_price'] - row['selling_price']):.2f}**")
st.write(f"Expires in {int(row['days_until_expiry'])} day(s)")
st.button("Add to shortlist", key=f"short_{i}")
def main():
inject_css()
st.markdown(
"""
🐱🐟
freshie
Perishable retail optimization for managers and consumers
""",
unsafe_allow_html=True,
)
try:
df = load_data()
except Exception as e:
st.error(str(e))
st.stop()
filtered = apply_filters(df)
if filtered.empty:
st.warning("No data left after filtering.")
st.stop()
role = st.radio("Choose your mode", ["Manager", "Consumer"], horizontal=True)
if role == "Manager":
tabs = st.tabs([
"Overview",
"Executive Summary",
"Category Intelligence",
"Inventory & Replenishment",
"Promotion Designer",
"Diagnose",
])
with tabs[0]:
manager_dashboard(filtered)
with tabs[1]:
manager_summary(filtered)
with tabs[2]:
manager_category_intelligence(filtered)
with tabs[3]:
manager_inventory(filtered, df)
with tabs[4]:
manager_promotions(filtered)
with tabs[5]:
manager_diagnose(filtered)
else:
tabs = st.tabs([
"Deal Finder",
"Bundle Builder",
"Personalized Promotions",
])
with tabs[0]:
consumer_deals(filtered)
with tabs[1]:
consumer_bundles(filtered)
with tabs[2]:
consumer_personal(filtered)
with st.expander("About this app"):
st.markdown(
"""
- **Manager mode** turns data into inventory, markdown, and operational decisions.
- **Consumer mode** surfaces discounted products, smart bundles, and personalized promotions.
- Built for deployment on Hugging Face Docker Spaces with Streamlit.
"""
)
if __name__ == "__main__":
main()