Update app.py

app.py

@@ -195,104 +195,99 @@ def init_game(weeks=DEFAULT_WEEKS):
 def step_game(state: dict, distributor_order: int):
     """
     Apply one week's dynamics.
-    Defensive: ensure 'pipeline' exists and lists are padded; safe pops and appends.
+    Order of events (typical simplification):
+    1. Customer demand hits retailer this week.
+    2. Deliveries that are at pipeline[front] arrive to each role this week.
+    3. Roles fulfill incoming orders from downstream (if backlog arises).
+    4. Human (distributor) order is recorded; LLMs decide orders for their roles.
+    5. Place orders into upstream's pipeline so they will arrive after TRANSPORT_DELAY.
+    6. Log everything.
     """
-    # Defensive defaults
-    if "roles" not in state:
-        state["roles"] = ["retailer", "wholesaler", "distributor", "factory"]
+    week = state["week"]
     roles = state["roles"]
 
-    # Ensure pipeline structure exists and each role has a list of length >= TRANSPORT_DELAY
-    if "pipeline" not in state or not isinstance(state["pipeline"], dict):
-        state["pipeline"] = {r: [0] * TRANSPORT_DELAY for r in roles}
-    else:
-        for r in roles:
-            state["pipeline"].setdefault(r, [0] * TRANSPORT_DELAY)
-            if len(state["pipeline"][r]) < TRANSPORT_DELAY:
-                state["pipeline"][r].extend([0] * (TRANSPORT_DELAY - len(state["pipeline"][r])))
-
-    week = state.get("week", 1)
-
     # 1) Customer demand for this week to retailer
-    demand = state.get("customer_demand", [])[week - 1] if (state.get("customer_demand") and week - 1 < len(state["customer_demand"])) else 0
-    state.setdefault("incoming_orders", {})
+    demand = state["customer_demand"][week - 1]  # week is 1-indexed
     state["incoming_orders"]["retailer"] = demand
 
-    # 2) Shipments arrive (front of pipeline) -- safe pop
+    # 2) Shipments arrive (front of pipeline)
     arriving = {}
     for r in roles:
+        # Pop front arrival if exists
         arr = 0
-        pl = state["pipeline"].get(r, [])
-        if len(pl) > 0:
-            try:
-                arr = pl.pop(0)
-            except Exception:
-                arr = 0
-        # ensure inventory keys
-        state.setdefault("inventory", {})
-        state["inventory"].setdefault(r, 0)
+        if len(state["pipeline"][r]) > 0:
+            arr = state["pipeline"][r].pop(0)
         state["inventory"][r] += arr
         arriving[r] = arr
 
-    # 3) Fulfill incoming orders from downstream
-    state.setdefault("backlog", {})
-    state.setdefault("shipments_history", {r: [] for r in roles})
+    # 3) Fulfill incoming orders from downstream (downstream -> this role)
+    # For each role, the incoming_order is whatever downstream ordered last turn.
+    # For first week, incoming_orders maybe zero for non-retailer; that's fine.
     shipments_out = {}
     for r in roles:
-        incoming = state.get("incoming_orders", {}).get(r, 0) or 0
-        inv = state.get("inventory", {}).get(r, 0) or 0
+        incoming = state["incoming_orders"].get(r, 0) or 0
+        inv = state["inventory"].get(r, 0) or 0
         shipped = min(inv, incoming)
-        state["inventory"][r] = inv - shipped
+        state["inventory"][r] -= shipped
+        # any unfilled becomes backlog
         unfilled = incoming - shipped
         if unfilled > 0:
-            state["backlog"].setdefault(r, 0)
             state["backlog"][r] += unfilled
         shipments_out[r] = shipped
-        state["shipments_history"].setdefault(r, []).append(shipped)
+        state["shipments_history"][r].append(shipped)
 
-    # 4) Record human distributor order
-    state.setdefault("orders_history", {r: [] for r in roles})
-    state["orders_history"].setdefault("distributor", []).append(int(distributor_order))
-    # set incoming_orders for upstream relation
+    # 4) Record human distributor order (this week's order placed by distributor)
+    # distributor_order is the order placed to wholesaler by the distributor this week
+    # Save to orders_history for distributor
+    state["orders_history"]["distributor"].append(int(distributor_order))
+    # Also set downstream->upstream linking: the upstream (wholesaler) will see distributor_order as incoming next period
     state["incoming_orders"]["wholesaler"] = int(distributor_order)
 
     # 5) LLM decisions for AI roles (retailer, wholesaler, factory)
     demand_history_visible = []
-    if state.get("info_sharing") and state.get("info_history_weeks", 0) > 0:
-        start_idx = max(0, (week - 1) - state.get("info_history_weeks", 0))
-        demand_history_visible = state.get("customer_demand", [])[start_idx: (week - 1)]
+    if state["info_sharing"] and state["info_history_weeks"] > 0:
+        start_idx = max(0, (week - 1) - state["info_history_weeks"])
+        demand_history_visible = state["customer_demand"][start_idx: (week - 1)]
 
     llm_outputs = {}
     for role in ["retailer", "wholesaler", "factory"]:
-        order_val, raw = call_llm_for_order(role, state_snapshot_for_prompt(state), state.get("info_sharing", False), demand_history_visible)
+        order_val, raw = call_llm_for_order(role, state_snapshot_for_prompt(state), state["info_sharing"], demand_history_visible)
         order_val = max(0, int(order_val))
-        state["orders_history"].setdefault(role, []).append(order_val)
+        state["orders_history"][role].append(order_val)
         llm_outputs[role] = {"order": order_val, "raw": raw}
-        # set incoming_orders mapping for next period
+        # set incoming_orders for upstream relation: upstream will see this order next period
+        # e.g., if retailer orders X, upstream (distributor) incoming_orders will be X
         if role == "retailer":
             state["incoming_orders"]["distributor"] = order_val
         elif role == "wholesaler":
             state["incoming_orders"]["factory"] = order_val
-        # factory's upstream beyond model
-
-    # 6) Place orders into pipelines: append to downstream partner's pipeline tail
-    downstream_map = {
-        "factory": "wholesaler",
-        "wholesaler": "distributor",
-        "distributor": "retailer",
-        "retailer": None
-    }
+        # factory's upstream is the supplier/external: we don't model beyond factory
+
+    # 6) Place orders into pipelines: these are shipments that will be sent upstream now and arrive after TRANSPORT_DELAY
+    # In the simple Beer Game, the shipped amounts are based on inventories; but orders placed lead to upstream shipments in future after they process.
+    # We'll model that orders placed this week translate into future shipments arriving after TRANSPORT_DELAY at the ordering party.
     for role in roles:
+        # Determine the order placed by this role this week:
         if role == "distributor":
             placed_order = int(distributor_order)
         else:
-            placed_order = int(state["orders_history"].get(role, [0])[-1] if state["orders_history"].get(role) else 0)
-
+            # role in orders_history last appended
+            placed_order = state["orders_history"][role][-1] if state["orders_history"][role] else 0
+
+        # For the downstream partner (the entity that will receive the shipment), we append to that partner's pipeline tail
+        # Example: distributor placed order to wholesaler -> wholesaler will receive shipment after TRANSPORT_DELAY
+        # Map role -> downstream partner (who receives shipments from role)
+        # shipments flow downstream: factory -> wholesaler -> distributor -> retailer
+        downstream_map = {
+            "factory": "wholesaler",
+            "wholesaler": "distributor",
+            "distributor": "retailer",
+            "retailer": None
+        }
         downstream = downstream_map.get(role)
         if downstream:
-            # ensure downstream pipeline exists
-            state["pipeline"].setdefault(downstream, [0] * TRANSPORT_DELAY)
-            # append placed_order at tail (arrival after TRANSPORT_DELAY)
+            # append zeros if pipeline too short to ensure correct index, then append placed_order at tail
+            # We want the placed_order to be delivered to downstream after TRANSPORT_DELAY weeks (so push at tail)
             state["pipeline"][downstream].append(placed_order)
 
     # 7) Log the week's summary
@@ -304,49 +299,35 @@ def step_game(state: dict, distributor_order: int):
         "shipments_out": shipments_out,
         "orders_submitted": {
             "distributor": int(distributor_order),
-            "retailer": state["orders_history"].get("retailer", [None])[-1],
-            "wholesaler": state["orders_history"].get("wholesaler", [None])[-1],
-            "factory": state["orders_history"].get("factory", [None])[-1],
+            "retailer": state["orders_history"]["retailer"][-1] if state["orders_history"]["retailer"] else None,
+            "wholesaler": state["orders_history"]["wholesaler"][-1] if state["orders_history"]["wholesaler"] else None,
+            "factory": state["orders_history"]["factory"][-1] if state["orders_history"]["factory"] else None,
         },
-        "inventory": dict(state.get("inventory", {})),
-        "backlog": dict(state.get("backlog", {})),
-        "info_sharing": state.get("info_sharing", False),
-        "info_history_weeks": state.get("info_history_weeks", 0),
+        "inventory": dict(state["inventory"]),
+        "backlog": dict(state["backlog"]),
+        "info_sharing": state["info_sharing"],
+        "info_history_weeks": state["info_history_weeks"],
         "llm_raw": {k: v["raw"] for k, v in llm_outputs.items()}
     }
-    state.setdefault("logs", []).append(log_entry)
+    state["logs"].append(log_entry)
 
     # 8) Advance week
-    state["week"] = state.get("week", 1) + 1
+    state["week"] += 1
 
     return state
 
 def state_snapshot_for_prompt(state):
     """
     Prepare a compact snapshot of state for LLM prompt (avoid sending huge objects).
-    Robust to missing 'pipeline' key or missing role entries.
+    We'll include week, inventory and backlog for each role and incoming_orders for this week.
     """
-    roles = state.get("roles", ["retailer", "wholesaler", "distributor", "factory"])
-    # Ensure pipeline exists and has at least TRANSPORT_DELAY entries per role
-    pipeline = state.get("pipeline", {})
-    for r in roles:
-        if r not in pipeline:
-            pipeline[r] = [0] * TRANSPORT_DELAY
-        else:
-            # if pipeline exists but is shorter than transport delay, pad with zeros
-            if len(pipeline[r]) < TRANSPORT_DELAY:
-                pipeline[r] = pipeline[r] + [0] * (TRANSPORT_DELAY - len(pipeline[r]))
-
     snap = {
-        "week": state.get("week", 1),
-        "inventory": state.get("inventory", {}).copy(),
-        "backlog": state.get("backlog", {}).copy(),
-        "incoming_orders": state.get("incoming_orders", {}).copy(),
-        # pipeline front (arriving next week) -- safe access
-        "incoming_shipments_next_week": {
-            r: (pipeline.get(r, [0])[0] if pipeline.get(r) and len(pipeline.get(r)) > 0 else 0)
-            for r in roles
-        }
+        "week": state["week"],
+        "inventory": state["inventory"].copy(),
+        "backlog": state["backlog"].copy(),
+        "incoming_orders": state["incoming_orders"].copy(),
+        # pipeline front (arriving next week)
+        "incoming_shipments_next_week": {r: (state["pipeline"][r][0] if state["pipeline"][r] else 0) for r in state["roles"]}
     }
     return snap
 
@@ -549,3 +530,4 @@ if state["week"] > state["weeks_total"]:
         url = upload_log_to_hf(final_csv, participant_id)
         if url:
             st.write(f"Final logs uploaded to HF Hub: {url}")
+