Upload app.py

app.py

@@ -0,0 +1,368 @@
+# app.py
+"""
+Beer Game (Streamlit) for Hugging Face Spaces
+- Multi-participant support (participant_id)
+- Per-participant game state
+- Per-participant CSV logs saved server-side
+- Optional export to S3 (AWS creds via env/secrets)
+- LLM agents use OpenAI gpt-4o-mini
+"""
+
+import os
+import re
+import time
+from datetime import datetime
+import io
+import uuid
+import pandas as pd
+import streamlit as st
+from dotenv import load_dotenv
+
+# Load local .env if present (spaces will inject secrets into env)
+load_dotenv()
+
+# OpenAI
+import openai
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    st.warning("OPENAI_API_KEY not found. Set OPENAI_API_KEY secret in the Space settings.")
+openai.api_key = OPENAI_API_KEY
+
+# Optional S3 (boto3)
+USE_S3 = False
+try:
+    import boto3
+
+    AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
+    AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+    S3_BUCKET = os.getenv("S3_BUCKET")
+    S3_REGION = os.getenv("S3_REGION", "us-east-1")
+
+    if AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY and S3_BUCKET:
+        USE_S3 = True
+except Exception:
+    USE_S3 = False
+
+# ---------------- Config ----------------
+ROLES = ["factory", "wholesaler", "distributor", "retailer"]
+AGENT_ROLES = ["factory", "wholesaler", "retailer"]
+MODEL_NAME = "gpt-4o-mini"
+
+DEFAULT_INITIAL_INVENTORY = 12
+PIPELINE_WEEKS = 2
+DEFAULT_DEMAND_PRE = 4
+DEMAND_SHOCK_FROM_WEEK = 6
+DEMAND_SHOCK_VALUE = 8
+DEFAULT_TOTAL_WEEKS = 24
+
+DATA_DIR = "logs"  # local folder to store per-participant csvs
+
+# Ensure logs dir exists
+if not os.path.exists(DATA_DIR):
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+
+# ---------------- Utilities ----------------
+def now_ts():
+    return datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + " UTC"
+
+
+def init_game_state(total_weeks=DEFAULT_TOTAL_WEEKS):
+    game = {}
+    for r in ROLES:
+        game[r] = {
+            "inventory": DEFAULT_INITIAL_INVENTORY,
+            "backlog": 0,
+            "incoming_shipments": [0] * PIPELINE_WEEKS,
+            "incoming_order": DEFAULT_DEMAND_PRE if r == "retailer" else 0,
+            "past_orders": [],
+            "demand_history": [],
+        }
+    demand = [DEFAULT_DEMAND_PRE] * (DEMAND_SHOCK_FROM_WEEK - 1) + \
+             [DEMAND_SHOCK_VALUE] * (total_weeks - (DEMAND_SHOCK_FROM_WEEK - 1))
+    game["week"] = 1
+    game["max_weeks"] = total_weeks
+    game["customer_demand"] = demand
+    game["logs"] = []
+    return game
+
+
+def log_row(role, week, order, state, raw, info_sharing_flag, action_by):
+    return {
+        "timestamp": now_ts(),
+        "week": int(week),
+        "role": role,
+        "action_by": action_by,
+        "order_submitted": int(order),
+        "inventory": int(state.get("inventory", 0)),
+        "backlog": int(state.get("backlog", 0)),
+        "incoming_order": int(state.get("incoming_order", 0)),
+        "incoming_shipment_next_week": int(state.get("incoming_shipments", [0])[0]),
+        "info_sharing": bool(info_sharing_flag),
+        "raw_output": str(raw),
+    }
+
+
+def append_log(game, row):
+    game["logs"].append(row)
+
+
+def logs_to_df(game):
+    return pd.DataFrame(game["logs"])
+
+
+# ---------------- OpenAI call ----------------
+def call_openai_for_order(role, state, model=MODEL_NAME, max_tokens=40, temperature=0.7):
+    prompt = (
+        f"You are the {role} (LLM agent) in a 4-player Beer Game.\n\n"
+        f"Local state:\n"
+        f"- Inventory: {state['inventory']}\n"
+        f"- Backlog: {state['backlog']}\n"
+        f"- Incoming shipment next week (front): {state['incoming_shipments'][0]}\n"
+        f"- Incoming order this week: {state['incoming_order']}\n"
+        f"- Past orders (last 5): {state['past_orders'][-5:]}\n"
+        f"- Customer demand history (visible): {state.get('demand_history', [])}\n\n"
+        f"Decide a non-negative integer order quantity to place to your upstream supplier this week.\n"
+        f"Reply with a single integer only (you may append a brief reason after a dash)."
+    )
+    raw = ""
+    try:
+        resp = openai.ChatCompletion.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are a beer game decision-making agent."},
+                {"role": "user", "content": prompt},
+            ],
+            max_tokens=max_tokens,
+            temperature=temperature,
+            n=1,
+        )
+        raw = resp.choices[0].message.get("content", "").strip()
+    except Exception as e:
+        raw = f"OPENAI_ERROR: {str(e)}"
+
+    # extract integer
+    m = re.search(r"(-?\d+)", raw)
+    order = None
+    if m:
+        try:
+            order = int(m.group(1))
+            if order < 0:
+                order = 0
+        except Exception:
+            order = None
+
+    if order is None:
+        target = DEFAULT_INITIAL_INVENTORY + (state.get("incoming_order") or 0)
+        order = max(0, target - (state.get("inventory") or 0))
+        raw = (raw + " | PARSE_FALLBACK").strip()
+
+    return int(order), raw
+
+
+# ---------------- Game mechanics ----------------
+def advance_week(game, participant_id, human_order_qty, info_sharing_flag, demand_history_length):
+    week = game["week"]
+    roles = ROLES
+
+    # Record distributor (human)
+    d_state = game["distributor"]
+    d_state["past_orders"].append(int(human_order_qty))
+    append_log(game, log_row("distributor", week, int(human_order_qty), d_state, "HUMAN", info_sharing_flag, "HUMAN"))
+
+    # Make demand history visible if info sharing enabled
+    if info_sharing_flag:
+        for r in ROLES:
+            game[r]["demand_history"] = game["customer_demand"][max(0, week - demand_history_length): week]
+
+    # LLM agents decide
+    for role in AGENT_ROLES:
+        state = game[role]
+        order_val, raw = call_openai_for_order(role, state)
+        state["past_orders"].append(int(order_val))
+        append_log(game, log_row(role, week, int(order_val), state, raw, info_sharing_flag, "LLM"))
+
+    # Demand arrives at retailer this week
+    demand = game["customer_demand"][week - 1]
+    game["retailer"]["incoming_order"] = demand
+
+    # Propagate orders downstream
+    for i in range(len(roles) - 1, 0, -1):
+        downstream = roles[i]
+        upstream = roles[i - 1]
+        latest_downstream_order = game[downstream]["past_orders"][-1] if game[downstream]["past_orders"] else 0
+        game[upstream]["incoming_order"] = latest_downstream_order
+
+    # Shipments flow (2-week pipeline)
+    for r in roles:
+        st_state = game[r]
+        arriving = st_state["incoming_shipments"].pop(0) if st_state["incoming_shipments"] else 0
+        if st_state["backlog"] > 0 and arriving > 0:
+            fulfilled = min(arriving, st_state["backlog"])
+            st_state["backlog"] -= fulfilled
+            arriving -= fulfilled
+        st_state["inventory"] += arriving
+
+        order_to_fill = st_state["incoming_order"] or 0
+        shipped = min(st_state["inventory"], order_to_fill)
+        st_state["inventory"] -= shipped
+        idx = ROLES.index(r)
+        if idx < len(ROLES) - 1:
+            downstream_role = ROLES[idx + 1]
+            game[downstream_role]["incoming_shipments"][-1] += shipped
+
+        if order_to_fill > shipped:
+            st_state["backlog"] += (order_to_fill - shipped)
+
+    # increment week
+    game["week"] += 1
+
+
+# ---------------- Persistence ----------------
+def local_save_logs(participant_id, game):
+    df = logs_to_df(game)
+    fname = os.path.join(DATA_DIR, f"logs_{participant_id}.csv")
+    df.to_csv(fname, index=False)
+    return fname
+
+
+def s3_upload_file(local_path, s3_key):
+    if not USE_S3:
+        raise RuntimeError("S3 not configured (missing AWS credentials or S3_BUCKET).")
+    s3 = boto3.client(
+        "s3",
+        aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+        aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+        region_name=os.getenv("S3_REGION", "us-east-1"),
+    )
+    s3.upload_file(local_path, os.getenv("S3_BUCKET"), s3_key)
+    s3_url = f"s3://{os.getenv('S3_BUCKET')}/{s3_key}"
+    return s3_url
+
+
+# ---------------- Streamlit UI (multi-session) ----------------
+st.set_page_config(page_title="Beer Game — Multi-Participant", layout="wide")
+
+st.title("Beer Game — Distributor (Multi-Participant Sessions)")
+st.caption("Deploy on Hugging Face Spaces. LLM agents powered by OpenAI gpt-4o-mini.")
+
+# Participant ID handling: URL query or input
+query_params = st.experimental_get_query_params()
+default_pid = query_params.get("participant_id", [None])[0]
+
+participant_col, info_col = st.columns([2, 1])
+with participant_col:
+    st.markdown("### Participant identification")
+    pid_input = st.text_input("Enter participant ID (leave blank to auto-generate):", value=default_pid or "")
+    if pid_input == "":
+        if "auto_pid" not in st.session_state:
+            st.session_state["auto_pid"] = str(uuid.uuid4())[:8]
+        pid_display = st.session_state["auto_pid"]
+        st.info(f"Auto-generated participant_id: **{pid_display}** — you can copy this or enter your own.")
+        participant_id = pid_display
+    else:
+        participant_id = pid_input.strip()
+
+with info_col:
+    st.markdown("### Space secrets & persistence")
+    if USE_S3:
+        st.success("S3 export ENABLED")
+        st.write(f"Bucket: `{os.getenv('S3_BUCKET')}`")
+    else:
+        st.info("S3 export not configured. To enable, set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and S3_BUCKET secrets.")
+
+# Initialize sessions container
+if "sessions" not in st.session_state:
+    st.session_state["sessions"] = {}
+
+# Create session for participant if not exists
+if participant_id not in st.session_state["sessions"]:
+    st.session_state["sessions"][participant_id] = init_game_state()
+
+game = st.session_state["sessions"][participant_id]
+week = game["week"]
+
+# Sidebar controls (per participant)
+st.sidebar.header("Experiment controls")
+st.sidebar.write(f"Participant: **{participant_id}**")
+st.sidebar.checkbox("Enable Information Sharing (visible to all roles)", key=f"info_sharing_{participant_id}")
+st.sidebar.slider("Demand history visible (weeks)", 0, game["max_weeks"], 2, key=f"demand_history_length_{participant_id}")
+st.sidebar.markdown("---")
+st.sidebar.write("Model for LLM agents:")
+st.sidebar.write(MODEL_NAME)
+st.sidebar.markdown("---")
+st.sidebar.write("Persistence:")
+st.sidebar.write(f"- Local logs stored in `{DATA_DIR}/logs_{participant_id}.csv`")
+
+# Display local state
+st.subheader(f"Participant `{participant_id}` — Week {week} / {game['max_weeks']}")
+dist = game["distributor"]
+left, right = st.columns([2, 1])
+
+with left:
+    st.markdown("#### Your (Distributor) Local State")
+    st.write(f"- Inventory: **{dist['inventory']}**")
+    st.write(f"- Backlog: **{dist['backlog']}**")
+    st.write(f"- Incoming order (this week): **{dist['incoming_order']}**")
+    st.write(f"- Incoming shipment next week: **{dist['incoming_shipments'][0] if dist['incoming_shipments'] else 0}**")
+
+    if st.session_state.get(f"info_sharing_{participant_id}", False):
+        hlen = st.session_state.get(f"demand_history_length_{participant_id}", 2)
+        shown = game["customer_demand"][max(0, week - hlen - 1): week-1] if week > 1 else []
+        st.markdown("**Customer demand history (visible):**")
+        st.write(shown)
+
+    st.markdown("---")
+    order_qty = st.number_input("Place your order to the Wholesaler (units):", min_value=0, step=1, value=dist.get("incoming_order", DEFAULT_DEMAND_PRE), key=f"order_input_{participant_id}")
+    submit = st.button("Submit Order and Advance Week", key=f"submit_{participant_id}")
+
+with right:
+    st.markdown("#### Logs (recent)")
+    if game["logs"]:
+        df_tail = logs_to_df(game).tail(10)
+        st.dataframe(df_tail)
+    else:
+        st.write("No actions logged yet.")
+
+    st.markdown("---")
+    if st.button("Save logs locally now", key=f"save_local_{participant_id}"):
+        saved_path = local_save_logs(participant_id, game)
+        st.success(f"Saved local logs to `{saved_path}`")
+        st.write(f"Filesize: {os.path.getsize(saved_path)} bytes")
+
+    if USE_S3:
+        if st.button("Upload latest logs to S3", key=f"upload_s3_{participant_id}"):
+            try:
+                saved_path = local_save_logs(participant_id, game)
+                s3_key = f"beer_game_logs/{participant_id}/logs_{participant_id}_{int(time.time())}.csv"
+                url = s3_upload_file(saved_path, s3_key)
+                st.success(f"Uploaded to S3: `{url}`")
+            except Exception as e:
+                st.error(f"S3 upload failed: {e}")
+
+# Submit action
+if submit:
+    info_flag = st.session_state.get(f"info_sharing_{participant_id}", False)
+    demand_history_length = st.session_state.get(f"demand_history_length_{participant_id}", 2)
+    append_log(game, log_row("info_sharing_toggle", week, int(order_qty), dist, f"info_sharing={info_flag}", info_flag, "HUMAN"))
+    advance_week(game, participant_id, order_qty, info_flag, demand_history_length)
+    st.experimental_rerun()
+
+# Post-game download if finished
+if game["week"] > game["max_weeks"]:
+    st.balloons()
+    st.success("Game finished for this participant.")
+    df = logs_to_df(game)
+    csv_bytes = df.to_csv(index=False).encode("utf-8")
+    st.download_button("Download final logs CSV", data=csv_bytes, file_name=f"logs_{participant_id}.csv", mime="text/csv")
+    # save local and optionally upload
+    local_path = local_save_logs(participant_id, game)
+    st.write(f"Saved local file: `{local_path}`")
+    if USE_S3:
+        try:
+            s3_key = f"beer_game_logs/{participant_id}/logs_{participant_id}_final_{int(time.time())}.csv"
+            url = s3_upload_file(local_path, s3_key)
+            st.success(f"Uploaded final logs to S3: `{url}`")
+        except Exception as e:
+            st.error(f"S3 final upload failed: {e}")