Update app.py

app.py

@@ -1,368 +1,168 @@
 # 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 random
 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):
+from huggingface_hub import HfApi, HfFolder, Repository
+
+# -----------------------------
+# 0. 配置
+# -----------------------------
+openai.api_key = os.getenv("OPENAI_API_KEY")
+HF_TOKEN = os.getenv("HF_TOKEN")  # 需要在 Hugging Face Space Secrets 里设置
+HF_REPO_ID = os.getenv("HF_REPO_ID", "your-username/beer-game-logs")  # 你要创建的 dataset repo
+
+api = HfApi()
+
+# -----------------------------
+# 1. 经典 Beer Game 参数
+# -----------------------------
+WEEKS = 36
+TRANSPORT_DELAY = 2
+ORDER_DELAY = 1
+
+# 经典客户需求序列：前 4 周恒定 4，之后 8，最后再变动
+def classic_demand():
+    demand = []
+    for t in range(WEEKS):
+        if t < 4:
+            demand.append(4)
+        elif 4 <= t < 20:
+            demand.append(8)
+        else:
+            demand.append(random.choice([4, 6, 8, 10]))
+    return demand
+
+CUSTOMER_DEMAND = classic_demand()
+
+# -----------------------------
+# 2. 初始化游戏状态
+# -----------------------------
+def init_state():
     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),
+        "week": 0,
+        "inventory": {"retailer": 12, "distributor": 12, "wholesaler": 12, "factory": 12},
+        "backlog": {"retailer": 0, "distributor": 0, "wholesaler": 0, "factory": 0},
+        "orders": {"retailer": [], "distributor": [], "wholesaler": [], "factory": []},
+        "pipeline": {"retailer": [], "distributor": [], "wholesaler": [], "factory": []},
+        "logs": []
     }
 
-
-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 = ""
+# -----------------------------
+# 3. LLM 决策（OpenAI 调用）
+# -----------------------------
+def llm_decision(role, state):
+    prompt = f"""
+    You are playing the Beer Game as the {role}.
+    Current week: {state['week']}
+    Inventory: {state['inventory'][role]}
+    Backlog: {state['backlog'][role]}
+    Please decide how many units to order from your upstream partner.
+    Return only an integer.
+    """
     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,
+        response = openai.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=10,
         )
-        raw = resp.choices[0].message.get("content", "").strip()
+        order = int("".join([c for c in response.choices[0].message.content if c.isdigit()]) or 4)
     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}")
+        st.error(f"LLM error ({role}): {e}")
+        order = 4
+    return order
+
+# -----------------------------
+# 4. 更新状态
+# -----------------------------
+def update_state(state, distributor_order):
+    t = state["week"]
+
+    # 客户需求作用在零售商
+    demand = CUSTOMER_DEMAND[t]
+    retailer_inventory = state["inventory"]["retailer"]
+    shipped = min(retailer_inventory, demand)
+    state["inventory"]["retailer"] -= shipped
+    state["backlog"]["retailer"] += demand - shipped
+
+    # 其他角色按 pipeline 收货
+    for role in ["retailer", "distributor", "wholesaler", "factory"]:
+        if state["pipeline"][role]:
+            arrived = state["pipeline"][role].pop(0)
+            state["inventory"][role] += arrived
+
+    # 下单：零售商由 LLM 控制
+    state["orders"]["retailer"].append(llm_decision("retailer", state))
+    state["orders"]["distributor"].append(distributor_order)
+    state["orders"]["wholesaler"].append(llm_decision("wholesaler", state))
+    state["orders"]["factory"].append(llm_decision("factory", state))
+
+    # 加入运输延迟
+    for role in ["retailer", "distributor", "wholesaler", "factory"]:
+        order = state["orders"][role][-1]
+        state["pipeline"][role].append(0)  # 本周发不出
+        state["pipeline"][role].append(order)  # 延迟两周才到
+
+    # 记录日志
+    log = {
+        "week": t,
+        "demand": demand,
+        "orders": {r: state["orders"][r][-1] for r in state["orders"]},
+        "inventory": dict(state["inventory"]),
+        "backlog": dict(state["backlog"]),
+        "timestamp": time.time(),
+    }
+    state["logs"].append(log)
+
+    state["week"] += 1
+    return state
+
+# -----------------------------
+# 5. 保存日志到 HF Datasets
+# -----------------------------
+def save_logs_to_hf(participant_id, logs):
+    df = pd.DataFrame(logs)
+    filename = f"logs_{participant_id}.csv"
+    df.to_csv(filename, index=False)
+
+    # 推送到 HF Hub dataset
+    repo_url = api.create_repo(repo_id=HF_REPO_ID, token=HF_TOKEN, repo_type="dataset", exist_ok=True)
+    repo = Repository(local_dir="hf_logs", clone_from=HF_REPO_ID, use_auth_token=HF_TOKEN)
+    os.makedirs("hf_logs", exist_ok=True)
+    df.to_csv(f"hf_logs/{filename}", index=False)
+    repo.git_add()
+    repo.git_commit(f"Add logs for {participant_id}")
+    repo.git_push()
+
+# -----------------------------
+# 6. Streamlit 界面
+# -----------------------------
+st.set_page_config(page_title="Beer Game Experiment", layout="wide")
+st.title("Beer Game Experiment")
+
+if "state" not in st.session_state:
+    st.session_state["participant_id"] = str(uuid.uuid4())
+    st.session_state["state"] = init_state()
+
+state = st.session_state["state"]
+
+st.write(f"### Week {state['week']} / {WEEKS}")
+st.write(f"Your Inventory: {state['inventory']['distributor']}, Backlog: {state['backlog']['distributor']}")
+
+distributor_order = st.number_input("Enter your order (units):", min_value=0, step=1, value=4)
+
+if st.button("Submit Order"):
+    st.session_state["state"] = update_state(state, distributor_order)
+
+    if state["week"] >= WEEKS:
+        st.success("Game finished! Saving logs...")
+        save_logs_to_hf(st.session_state["participant_id"], state["logs"])
+        st.balloons()
+        st.stop()
+
+# 显示实时日志
+st.write("### Logs (this session)")
+st.dataframe(pd.DataFrame(state["logs"]))