Flatten project to root for OpenEnv submission readiness.

Move backend/frontend/data/scripts and manifests out of nested openenv-polypharmacy directory, add root-compliant inference/server entrypoints, and align validator artifacts for Hugging Face submission checks.

Made-with: Cursor

.dockerignore

@@ -9,4 +9,4 @@
 **/dist
 **/.env
 **/.env.*
-!openenv-polypharmacy/.env.example
+!.env.example

.gitignore

@@ -4,7 +4,7 @@ venv/
 env/
 .env
 .env.*
-!openenv-polypharmacy/.env.example
+!.env.example
 *.py[cod]
 __pycache__/
 .pytest_cache/
@@ -29,7 +29,3 @@ pnpm-debug.log*
 *.swp
 .DS_Store
 
-# --- Project-specific nested paths ---
-openenv-polypharmacy/frontend/node_modules/
-openenv-polypharmacy/frontend/dist/
-openenv-polypharmacy/.pytest_cache/

Dockerfile

@@ -1,8 +1,8 @@
 FROM node:20-alpine AS frontend-builder
 WORKDIR /app/frontend
-COPY openenv-polypharmacy/frontend/package*.json ./
+COPY frontend/package*.json ./
 RUN npm ci
-COPY openenv-polypharmacy/frontend/ ./
+COPY frontend/ ./
 RUN npm run build
 
 FROM python:3.11-slim
@@ -13,15 +13,15 @@ RUN apt-get update && \
 
 WORKDIR /app
 
-COPY openenv-polypharmacy/backend/requirements.txt /app/backend/requirements.txt
+COPY backend/requirements.txt /app/backend/requirements.txt
 RUN pip install --no-cache-dir -r /app/backend/requirements.txt
 
-COPY openenv-polypharmacy/backend /app/backend
-COPY openenv-polypharmacy/data /app/data
-COPY openenv-polypharmacy/scripts /app/scripts
-COPY openenv-polypharmacy/openenv.yaml /app/openenv.yaml
-COPY openenv-polypharmacy/.env.example /app/.env.example
-COPY openenv-polypharmacy/inference.py /app/inference.py
+COPY backend /app/backend
+COPY data /app/data
+COPY scripts /app/scripts
+COPY openenv.yaml /app/openenv.yaml
+COPY .env.example /app/.env.example
+COPY inference.py /app/inference.py
 
 COPY --from=frontend-builder /app/frontend/dist /app/frontend/dist
 

README.md

@@ -7,4 +7,250 @@ sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PolypharmacyEnv
+
+Monorepo for an OpenEnv-compatible medication safety environment with:
+
+- a FastAPI backend (`backend/`)
+- a React frontend (`frontend/`)
+- data assets (`data/`)
+- utility scripts (`scripts/`)
+
+---
+
+## Repository Structure
+
+```text
+backend/
+    main.py                      # ASGI entrypoint (uvicorn target)
+    requirements.txt             # Backend dependencies
+    Dockerfile                   # Backend container
+    src/polypharmacy_env/        # Python package source
+      api/
+        app.py                   # FastAPI/OpenEnv app assembly
+        server.py                # Compatibility import wrapper
+        routes/agent.py          # /agent/suggest route
+      services/
+        groq_agent.py            # Groq-based action suggestion logic
+      env_core.py                # OpenEnv environment core
+      models.py                  # Action/observation/state models
+      data_loader.py             # CSV loading
+      ddi_simulator.py           # DDI and Beers lookups
+      rewards.py                 # Reward shaping
+      graders.py                 # Task graders
+      tasks.py                   # Task/episode selection
+      tests/                     # Backend tests
+frontend/
+    src/                         # React UI code
+    package.json
+    Dockerfile                   # Frontend container
+data/
+    lookups/                     # drug_metadata.csv, ddi_rules.csv, beers_criteria.csv
+    processed/                   # patients_polypharmacy.csv
+scripts/
+    preprocess_data.py           # Synthetic data generation
+    dev_backend.sh               # Local backend run helper
+    dev_frontend.sh              # Local frontend run helper
+    run_validation.sh            # Tests + baseline validation
+docker-compose.yml             # Full stack orchestration
+openenv.yaml                   # OpenEnv manifest
+inference.py                   # Baseline inference script (required at root)
+.env.example                   # Environment template
+```
+
+---
+
+## What It Does
+
+The environment simulates elderly polypharmacy review. Agent actions:
+
+- `query_ddi`
+- `propose_intervention`
+- `finish_review`
+
+Supported tasks:
+
+- `easy_screening`
+- `budgeted_screening`
+- `complex_tradeoff`
+
+---
+
+## Prerequisites
+
+- Python 3.10+
+- Node.js 18+ (or 20+ recommended)
+- npm
+- Docker + Docker Compose (optional, for containerized run)
+
+---
+
+## Environment Setup
+
+Create `.env`:
+
+```bash
+cp .env.example .env
+```
+
+Set values for local backend integrations as needed.
+
+---
+
+## Local Run (Recommended During Development)
+
+### 1) Install dependencies
+
+Backend:
+
+```bash
+pip install -r backend/requirements.txt
+```
+
+Frontend:
+
+```bash
+cd frontend
+npm install
+cd ..
+```
+
+### 2) Generate/update synthetic data (if needed)
+
+```bash
+python scripts/preprocess_data.py
+```
+
+### 3) Start services in two terminals
+
+Terminal A:
+
+```bash
+./scripts/dev_backend.sh
+```
+
+Terminal B:
+
+```bash
+./scripts/dev_frontend.sh
+```
+
+### 4) Open app
+
+- Frontend: [http://localhost:5173](http://localhost:5173)
+- Backend health: [http://localhost:7860/health](http://localhost:7860/health)
+
+---
+
+## Docker Run
+
+Run both services:
+
+```bash
+docker compose up --build
+```
+
+Stop:
+
+```bash
+docker compose down
+```
+
+Ports:
+
+- backend: `7860`
+- frontend: `5173`
+
+---
+
+## Hugging Face Spaces Deployment (Docker)
+
+This repo now includes a **root `Dockerfile`** that builds frontend + backend into one container, so Spaces can host both API and UI together.
+
+### 1) Create a new Space
+
+- Go to [Hugging Face Spaces](https://huggingface.co/new-space)
+- Choose **Docker** SDK
+- Create the Space
+
+### 2) Add Space secrets/variables
+
+In Space Settings -> Variables and Secrets:
+
+- Secret: `HF_TOKEN`
+- Variable: `API_BASE_URL=https://router.huggingface.co/v1`
+- Variable: `MODEL_NAME=Qwen/Qwen2.5-72B-Instruct`
+
+### 3) Push this repository to the Space
+
+Commit and push all files, including root `Dockerfile`.
+
+### 4) Verify after build
+
+- Space root URL loads the React UI
+- `/health` returns healthy status
+- OpenEnv endpoints are available (`/reset`, `/step`, `/state`, `/schema`)
+
+Notes:
+
+- Container reads `PORT` (defaults to `7860`) which is Space-friendly.
+- Frontend static assets are served by FastAPI from `frontend/dist`.
+
+---
+
+## API Endpoints
+
+OpenEnv/health:
+
+- `POST /reset`
+- `POST /step`
+- `GET /state`
+- `GET /health`
+- `GET /schema`
+- `WS /ws` (stateful session)
+
+AI helper:
+
+- `POST /agent/suggest`
+
+---
+
+## Testing
+
+Run backend tests:
+
+```bash
+python -m pytest backend/src/polypharmacy_env/tests -v
+```
+
+Or run validation script:
+
+```bash
+./scripts/run_validation.sh
+```
+
+### Submission validation
+
+```bash
+openenv validate
+python inference.py
+```
+
+---
+
+## Notes
+
+- OpenEnv HTTP reset/step is stateless; multi-step episode continuity should use websocket (`/ws`).
+- The frontend uses websocket for episode continuity and HTTP for AI suggestion.
+- AI behavior includes rule-based guardrails to avoid repetitive low-value loops.
+
+---
+
+## Troubleshooting
+
+- `ModuleNotFoundError: polypharmacy_env`
+  - Start backend using `./scripts/dev_backend.sh` from repo root.
+- `/agent/suggest` fails
+  - Check `.env` keys and restart backend.
+- UI state looks stale
+  - Hard refresh browser and click `Reset Episode`.

inference.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""Submission inference script for Polypharmacy OpenEnv environment.
+
+Required environment variables:
+  API_BASE_URL   OpenAI-compatible base URL
+  MODEL_NAME     Model identifier
+  HF_TOKEN       API key/token
+
+Optional:
+  POLYPHARMACY_ENV_URL  Environment API base (default: http://localhost:7860)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any, Dict, List
+
+import requests
+from openai import OpenAI
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+ENV_URL = os.getenv("POLYPHARMACY_ENV_URL", "http://localhost:7860").rstrip("/")
+
+BENCHMARK = "polypharmacy_env"
+TASKS = ["easy_screening", "budgeted_screening", "complex_tradeoff"]
+MAX_STEPS = 16
+TEMPERATURE = 0.0
+MAX_TOKENS = 220
+
+SYSTEM_PROMPT = (
+    "You are a clinical-pharmacist agent. "
+    "Return one JSON action only with keys matching this schema: "
+    '{"action_type":"query_ddi|propose_intervention|finish_review",'
+    '"drug_id_1":"", "drug_id_2":"", "target_drug_id":"",'
+    '"intervention_type":"stop|dose_reduce|substitute|add_monitoring",'
+    '"proposed_new_drug_id":"", "rationale":""}. '
+    "Prefer safe, high-impact actions and finish when useful actions are exhausted."
+)
+
+
+def _b(v: bool) -> str:
+    return str(bool(v)).lower()
+
+
+def _fmt_reward(v: float) -> str:
+    return f"{float(v):.2f}"
+
+
+def _clamp01(v: float) -> float:
+    return max(0.0, min(1.0, float(v)))
+
+
+def log_start(task: str) -> None:
+    print(f"[START] task={task} env={BENCHMARK} model={MODEL_NAME}", flush=True)
+
+
+def log_step(step: int, action_str: str, reward: float, done: bool, error: str | None) -> None:
+    err = error if error else "null"
+    print(
+        f"[STEP] step={step} action={action_str} reward={_fmt_reward(reward)} "
+        f"done={_b(done)} error={err}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(_fmt_reward(r) for r in rewards)
+    print(
+        f"[END] success={_b(success)} steps={steps} score={_clamp01(score):.3f} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+def _safe_json(text: str) -> Dict[str, Any]:
+    text = text.strip()
+    if text.startswith("```"):
+        text = re.sub(r"^```[a-zA-Z]*\n?", "", text)
+        text = text.replace("```", "").strip()
+    try:
+        data = json.loads(text)
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        pass
+    return {"action_type": "finish_review"}
+
+
+def _llm_action(client: OpenAI, obs: Dict[str, Any]) -> Dict[str, Any]:
+    meds = obs.get("current_medications", [])
+    summary = {
+        "step_index": obs.get("step_index", 0),
+        "remaining_query_budget": obs.get("remaining_query_budget", 0),
+        "remaining_intervention_budget": obs.get("remaining_intervention_budget", 0),
+        "conditions": obs.get("conditions", []),
+        "current_medications": [
+            {
+                "drug_id": m.get("drug_id"),
+                "generic_name": m.get("generic_name"),
+                "dose_mg": m.get("dose_mg"),
+                "beers_flags": m.get("beers_flags", []),
+            }
+            for m in meds
+        ],
+        "interaction_queries": obs.get("interaction_queries", []),
+        "interventions": obs.get("interventions", []),
+    }
+    resp = client.chat.completions.create(
+        model=MODEL_NAME,
+        temperature=TEMPERATURE,
+        max_tokens=MAX_TOKENS,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": json.dumps(summary, separators=(",", ":"))},
+        ],
+    )
+    content = (resp.choices[0].message.content or "").strip()
+    return _safe_json(content)
+
+
+def _reset(task_id: str) -> Dict[str, Any]:
+    r = requests.post(f"{ENV_URL}/reset", json={"task_id": task_id}, timeout=45)
+    r.raise_for_status()
+    return r.json()
+
+
+def _step(action: Dict[str, Any]) -> Dict[str, Any]:
+    r = requests.post(f"{ENV_URL}/step", json={"action": action}, timeout=45)
+    r.raise_for_status()
+    return r.json()
+
+
+def run_task(client: OpenAI, task_id: str) -> None:
+    rewards: List[float] = []
+    steps = 0
+    success = False
+    score = 0.0
+    log_start(task_id)
+    try:
+        reset_payload = _reset(task_id)
+        obs = reset_payload.get("observation", {})
+        done = bool(reset_payload.get("done", False))
+
+        for i in range(1, MAX_STEPS + 1):
+            if done:
+                break
+            action = _llm_action(client, obs)
+            action_str = json.dumps(action, separators=(",", ":"))
+            step_payload = _step(action)
+            obs = step_payload.get("observation", {})
+            reward = float(step_payload.get("reward") or 0.0)
+            done = bool(step_payload.get("done", False))
+            metadata = (obs or {}).get("metadata", {}) or {}
+            last_error = metadata.get("error")
+            rewards.append(reward)
+            steps = i
+            log_step(i, action_str, reward, done, str(last_error) if last_error else None)
+
+            if done:
+                raw_score = metadata.get("grader_score", None)
+                if raw_score is not None:
+                    score = _clamp01(float(raw_score))
+                else:
+                    score = _clamp01(sum(max(0.0, r) for r in rewards) / max(len(rewards), 1))
+                success = score > 0.0
+                break
+    except Exception:
+        # Still emit END to keep evaluator parser stable.
+        success = False
+    finally:
+        log_end(success=success, steps=steps, score=score, rewards=rewards)
+
+
+def main() -> int:
+    if not HF_TOKEN:
+        print("HF_TOKEN is required", flush=True)
+        return 1
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+    for task in TASKS:
+        run_task(client, task)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openenv-polypharmacy/.dockerignore

@@ -1,8 +0,0 @@
-.git
-.gitignore
-**/__pycache__/
-**/.pytest_cache/
-**/.DS_Store
-.env
-frontend/node_modules
-frontend/dist

openenv-polypharmacy/Dockerfile

@@ -1,39 +0,0 @@
-FROM node:20-alpine AS frontend-builder
-WORKDIR /app/frontend
-COPY frontend/package*.json ./
-RUN npm ci
-COPY frontend/ ./
-RUN npm run build
-
-FROM python:3.11-slim
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends build-essential curl && \
-    rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY backend/requirements.txt /app/backend/requirements.txt
-RUN pip install --no-cache-dir -r /app/backend/requirements.txt
-
-COPY backend /app/backend
-COPY data /app/data
-COPY scripts /app/scripts
-COPY openenv.yaml /app/openenv.yaml
-COPY .env.example /app/.env.example
-COPY inference.py /app/inference.py
-
-COPY --from=frontend-builder /app/frontend/dist /app/frontend/dist
-
-RUN python3 /app/scripts/preprocess_data.py
-
-ENV PORT=7860
-ENV PYTHONPATH="/app/backend/src:${PYTHONPATH}"
-ENV PYTHONUNBUFFERED=1
-
-EXPOSE 7860
-
-HEALTHCHECK --interval=30s --timeout=3s --start-period=15s --retries=3 \
-    CMD curl -f http://localhost:7860/health || exit 1
-
-CMD ["sh", "-c", "uvicorn backend.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

openenv-polypharmacy/README.md

@@ -1,245 +0,0 @@
-# PolypharmacyEnv
-
-Monorepo for an OpenEnv-compatible medication safety environment with:
-
-- a FastAPI backend (`backend/`)
-- a React frontend (`frontend/`)
-- data assets (`data/`)
-- utility scripts (`scripts/`)
-
----
-
-## Repository Structure
-
-```text
-openenv-polypharmacy/
-  backend/
-    main.py                      # ASGI entrypoint (uvicorn target)
-    requirements.txt             # Backend dependencies
-    Dockerfile                   # Backend container
-    src/polypharmacy_env/        # Python package source
-      api/
-        app.py                   # FastAPI/OpenEnv app assembly
-        server.py                # Compatibility import wrapper
-        routes/agent.py          # /agent/suggest route
-      services/
-        groq_agent.py            # Groq-based action suggestion logic
-      env_core.py                # OpenEnv environment core
-      models.py                  # Action/observation/state models
-      data_loader.py             # CSV loading
-      ddi_simulator.py           # DDI and Beers lookups
-      rewards.py                 # Reward shaping
-      graders.py                 # Task graders
-      tasks.py                   # Task/episode selection
-      tests/                     # Backend tests
-  frontend/
-    src/                         # React UI code
-    package.json
-    Dockerfile                   # Frontend container
-  data/
-    lookups/                     # drug_metadata.csv, ddi_rules.csv, beers_criteria.csv
-    processed/                   # patients_polypharmacy.csv
-  scripts/
-    preprocess_data.py           # Synthetic data generation
-    dev_backend.sh               # Local backend run helper
-    dev_frontend.sh              # Local frontend run helper
-    run_validation.sh            # Tests + baseline validation
-  docker-compose.yml             # Full stack orchestration
-  openenv.yaml                   # OpenEnv manifest
-  inference.py                   # Optional CLI inference baseline
-  .env.example                   # Environment template
-```
-
----
-
-## What It Does
-
-The environment simulates elderly polypharmacy review. Agent actions:
-
-- `query_ddi`
-- `propose_intervention`
-- `finish_review`
-
-Supported tasks:
-
-- `easy_screening`
-- `budgeted_screening`
-- `complex_tradeoff`
-
----
-
-## Prerequisites
-
-- Python 3.10+
-- Node.js 18+ (or 20+ recommended)
-- npm
-- Docker + Docker Compose (optional, for containerized run)
-
----
-
-## Environment Setup
-
-Create `.env`:
-
-```bash
-cp .env.example .env
-```
-
-Set values:
-
-- `GROQ_API_KEY=...` (required)
-- `GROQ_BASE_URL=https://api.groq.com/openai/v1` (recommended)
-- `GROQ_MODEL_NAME=llama-3.3-70b-versatile` (recommended)
-
----
-
-## Local Run (Recommended During Development)
-
-### 1) Install dependencies
-
-Backend:
-
-```bash
-pip install -r backend/requirements.txt
-```
-
-Frontend:
-
-```bash
-cd frontend
-npm install
-cd ..
-```
-
-### 2) Generate/update synthetic data (if needed)
-
-```bash
-python scripts/preprocess_data.py
-```
-
-### 3) Start services in two terminals
-
-Terminal A:
-
-```bash
-./scripts/dev_backend.sh
-```
-
-Terminal B:
-
-```bash
-./scripts/dev_frontend.sh
-```
-
-### 4) Open app
-
-- Frontend: [http://localhost:5173](http://localhost:5173)
-- Backend health: [http://localhost:7860/health](http://localhost:7860/health)
-
----
-
-## Docker Run
-
-Run both services:
-
-```bash
-docker compose up --build
-```
-
-Stop:
-
-```bash
-docker compose down
-```
-
-Ports:
-
-- backend: `7860`
-- frontend: `5173`
-
----
-
-## Hugging Face Spaces Deployment (Docker)
-
-This repo now includes a **root `Dockerfile`** that builds frontend + backend into one container, so Spaces can host both API and UI together.
-
-### 1) Create a new Space
-
-- Go to [Hugging Face Spaces](https://huggingface.co/new-space)
-- Choose **Docker** SDK
-- Create the Space
-
-### 2) Add Space secrets/variables
-
-In Space Settings -> Variables and Secrets:
-
-- Secret: `GROQ_API_KEY`
-- Variable: `GROQ_BASE_URL=https://api.groq.com/openai/v1`
-- Variable: `GROQ_MODEL_NAME=llama-3.3-70b-versatile`
-
-### 3) Push this repository to the Space
-
-Commit and push all files, including root `Dockerfile`.
-
-### 4) Verify after build
-
-- Space root URL loads the React UI
-- `/health` returns healthy status
-- OpenEnv endpoints are available (`/reset`, `/step`, `/state`, `/schema`)
-
-Notes:
-
-- Container reads `PORT` (defaults to `7860`) which is Space-friendly.
-- Frontend static assets are served by FastAPI from `frontend/dist`.
-
----
-
-## API Endpoints
-
-OpenEnv/health:
-
-- `POST /reset`
-- `POST /step`
-- `GET /state`
-- `GET /health`
-- `GET /schema`
-- `WS /ws` (stateful session)
-
-AI helper:
-
-- `POST /agent/suggest`
-
----
-
-## Testing
-
-Run backend tests:
-
-```bash
-python -m pytest backend/src/polypharmacy_env/tests -v
-```
-
-Or run validation script:
-
-```bash
-./scripts/run_validation.sh
-```
-
----
-
-## Notes
-
-- OpenEnv HTTP reset/step is stateless; multi-step episode continuity should use websocket (`/ws`).
-- The frontend uses websocket for episode continuity and HTTP for AI suggestion.
-- AI behavior includes rule-based guardrails to avoid repetitive low-value loops.
-
----
-
-## Troubleshooting
-
-- `ModuleNotFoundError: polypharmacy_env`
-  - Start backend using `./scripts/dev_backend.sh` from repo root.
-- `/agent/suggest` fails
-  - Check `.env` keys and restart backend.
-- UI state looks stale
-  - Hard refresh browser and click `Reset Episode`.