Upload folder using huggingface_hub

baseline.py

@@ -62,7 +62,6 @@ RULE_POLICIES = {
     ],
 }
 
-
 def run_rule_baseline(base_url: str) -> dict[str, float]:
     """Run deterministic rule-based baseline — no LLM required."""
     scores = {}
@@ -91,7 +90,6 @@ def run_rule_baseline(base_url: str) -> dict[str, float]:
 
     return scores
 
-
 # ---------------------------------------------------------------------------
 # LLM agent (uses OpenAI API)
 # ---------------------------------------------------------------------------
@@ -116,7 +114,6 @@ or with an optional column:
 
 No explanation. JSON only."""
 
-
 def run_llm_baseline(base_url: str, api_key: str, max_steps: int = 10) -> dict[str, float]:
     """Run an LLM agent (GPT-4o-mini) against the environment."""
     client = OpenAI(api_key=api_key)
@@ -184,7 +181,6 @@ def run_llm_baseline(base_url: str, api_key: str, max_steps: int = 10) -> dict[s
 
     return scores
 
-
 # ---------------------------------------------------------------------------
 # Main
 # ---------------------------------------------------------------------------

client.py

@@ -1,6 +1,6 @@
 """Data Cleaning Env Environment Client."""
 
-from typing import Dict
+from typing import Dict, Optional
 
 from openenv.core import EnvClient
 from openenv.core.client_types import StepResult
@@ -8,7 +8,6 @@ from openenv.core.env_server.types import State
 
 from .models import DataCleaningAction, DataCleaningObservation
 
-
 class DataCleaningEnv(
     EnvClient[DataCleaningAction, DataCleaningObservation, State]
 ):
@@ -34,19 +33,25 @@ class DataCleaningEnv(
     def _parse_result(self, payload: Dict) -> StepResult[DataCleaningObservation]:
         """Parse server response into StepResult[DataCleaningObservation]."""
         obs_data = payload.get("observation", {})
+        
+        # done and reward live at top-level in the server response
+        done   = payload.get("done", obs_data.get("done", False))
+        reward = payload.get("reward", obs_data.get("reward"))
 
         observation = DataCleaningObservation(
             current_text=obs_data.get("current_text", ""),
             is_normalized=obs_data.get("is_normalized", False),
             html_found=obs_data.get("html_found", False),
             remaining_typos=obs_data.get("remaining_typos", 0),
+            done=done,
+            reward=reward,
             metadata=obs_data.get("metadata", {}),
         )
 
         return StepResult(
             observation=observation,
-            reward=payload.get("reward"),
-            done=payload.get("done", False),
+            reward=reward,
+            done=done,
         )
 
     def _parse_state(self, payload: Dict) -> State:

inference.py

@@ -61,7 +61,7 @@ RULE_POLICIES = {
     ],
 }
 
-# ── System prompt — fact-driven, no hint dependency ────────────────────────
+# ── System prompt ─────────────────
 SYSTEM_PROMPT = """\
 You are a data cleaning agent. Pick ONE operation per turn.
 
@@ -71,14 +71,14 @@ OUTPUT RULE: Respond with ONLY a JSON object. No explanation. No markdown. No ot
 Format: {"operation": "operation_name"}
 
 SELECTION RULES — apply in order based on PROBLEMS DETECTED:
-1. If missing values > 0 and quantity column is affected  -> fill_quantity_mean
-2. If missing values > 0 and numeric columns affected     -> impute_mean
-3. If missing values > 0 and text columns affected        -> impute_mode
-4. If has_duplicates is true                              -> remove_duplicates
-5. If has_outliers is true                                -> remove_outliers
-6. If non-numeric values exist in numeric columns         -> fix_type_errors
-7. If text columns have inconsistent casing/whitespace    -> normalize_text
-8. If any rows still have missing values                  -> drop_missing_rows
+1. If missing values > 0 and quantity column affected  -> fill_quantity_mean
+2. If missing values > 0 and numeric columns affected  -> impute_mean
+3. If missing values > 0 and text columns affected     -> impute_mode
+4. If has_duplicates is true                           -> remove_duplicates
+5. If has_outliers is true                             -> remove_outliers
+6. If non-numeric values in numeric columns            -> fix_type_errors
+7. If text columns have inconsistent casing/whitespace -> normalize_text
+8. If rows still have missing values                   -> drop_missing_rows
 9. Pick the first operation from AVAILABLE that makes sense.
 
 You MUST pick from the AVAILABLE list only — operations not listed are already done.
@@ -136,20 +136,25 @@ def _sanitize(text: str) -> str:
 # ── Pick next unused op from a policy list ─────────────────────────────────
 
 def _next_unused(policy: List[str], applied: List[str]) -> Optional[str]:
-    """Return the first op in policy not already applied, or None."""
     applied_set = set(applied)
     for op in policy:
         if op not in applied_set:
             return op
     return None
 
-# ── Robust JSON parser ──────────────────────────────────────────────────────
+def _fallback(task: str, applied: List[str]) -> dict:
+    policy = RULE_POLICIES.get(task, RULE_POLICIES["easy"])
+    op = _next_unused(policy, applied)
+    if op:
+        return {"operation": op}
+    op = _next_unused(VALID_OPS, applied)
+    if op:
+        print(f"[DEBUG] Policy exhausted, global fallback: {op}", flush=True)
+        return {"operation": op}
+    print("[DEBUG] All ops exhausted — repeating first policy op.", flush=True)
+    return {"operation": policy[0]}
 
 def parse_llm_response(raw: str, task: str, applied: List[str]) -> dict:
-    """
-    3-layer fallback parser. Hard-enforces that the chosen operation
-    has not already been applied.
-    """
     if not raw:
         return _fallback(task, applied)
 
@@ -158,7 +163,6 @@ def parse_llm_response(raw: str, task: str, applied: List[str]) -> dict:
 
     candidate = None
 
-    # Layer 1: direct JSON parse
     try:
         result = json.loads(text)
         if "operation" in result and result["operation"] in VALID_OPS:
@@ -166,7 +170,6 @@ def parse_llm_response(raw: str, task: str, applied: List[str]) -> dict:
     except Exception:
         pass
 
-    # Layer 2: find first {...} in string
     if not candidate:
         match = re.search(r"\{[^{}]*\}", text, re.DOTALL)
         if match:
@@ -177,7 +180,6 @@ def parse_llm_response(raw: str, task: str, applied: List[str]) -> dict:
             except Exception:
                 pass
 
-    # Layer 3: op name mentioned anywhere in raw text
     if not candidate:
         for op in VALID_OPS:
             if op in raw:
@@ -215,10 +217,6 @@ def _fallback(task: str, applied: List[str]) -> dict:
 # ── LLM call ───────────────────────────────────────────────────────────────
 
 def get_llm_action(client: OpenAI, obs: dict, task: str, applied: List[str]) -> dict:
-    """
-    Build prompt from observed facts only (no hint field).
-    Inject available ops explicitly so model cannot repeat a done op.
-    """
     metadata     = obs.get("metadata", {})
     quality      = metadata.get("quality_score", "?")
     missing      = metadata.get("missing_count", 0)
@@ -254,7 +252,7 @@ def get_llm_action(client: OpenAI, obs: dict, task: str, applied: List[str]) ->
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user",   "content": user_msg},
             ],
-            temperature=0.0,  # fully deterministic
+            temperature=0.3, 
             max_tokens=50,
         )
         raw = (completion.choices[0].message.content or "").strip()
@@ -265,7 +263,21 @@ def get_llm_action(client: OpenAI, obs: dict, task: str, applied: List[str]) ->
         print(f"[DEBUG] LLM call failed: {exc}", flush=True)
         return _fallback(task, applied)
 
-# ── Episode runner ─────────────────────────────────────────────────────────
+def _extract_reward(result: dict, obs: dict) -> float:
+    # Top-level first (standard)
+    r = result.get("reward")
+    if r is not None:
+        return float(r)
+    # Inside observation object
+    r = obs.get("reward")
+    if r is not None:
+        return float(r)
+    # Inside metadata as quality delta (last resort)
+    meta = obs.get("metadata", {})
+    r = meta.get("last_reward")
+    if r is not None:
+        return float(r)
+    return 0.0
 
 def run_episode(base_url: str, task: str, mode: str, client=None) -> None:
     import requests

models.py

@@ -2,7 +2,6 @@ from typing import Any, Dict, Optional
 from openenv.core.env_server.types import Action, Observation
 from pydantic import Field
 
-
 class DataCleaningAction(Action):
     """Actions the agent can take to clean a dirty dataset."""
 
@@ -20,7 +19,6 @@ class DataCleaningAction(Action):
         description="Target column (optional). If omitted the op applies to all relevant columns.",
     )
 
-
 class DataCleaningObservation(Observation):
     """The dataset state observed after each cleaning step."""
 

server/app.py

@@ -18,12 +18,14 @@ Additional hackathon-required endpoints:
 try:
     from openenv.core.env_server.http_server import create_app
 except Exception as e:
-    raise ImportError(
-        "openenv is required. Install dependencies with: uv sync"
-    ) from e
+    raise ImportError("openenv is required. Install with: uv sync") from e
 
-from models import DataCleaningAction, DataCleaningObservation
-from server.data_cleaning_env_environment import DataCleaningEnvironment
+try:
+    from ..models import DataCleaningAction, DataCleaningObservation
+    from .data_cleaning_env_environment import DataCleaningEnvironment
+except ModuleNotFoundError:
+    from models import DataCleaningAction, DataCleaningObservation
+    from server.data_cleaning_env_environment import DataCleaningEnvironment
 
 from fastapi import HTTPException
 from fastapi.responses import JSONResponse
@@ -39,17 +41,25 @@ app = create_app(
     max_concurrent_envs=1,
 )
 
-# ---------------------------------------------------------------------------
-# Shared environment instance for grader/baseline
-# ---------------------------------------------------------------------------
-_env: DataCleaningEnvironment | None = None
-
 def _get_env() -> DataCleaningEnvironment:
-    global _env
-    if _env is None:
-        _env = DataCleaningEnvironment()
-    return _env
-
+    """
+    openenv stores the managed env at app.state.env or app.state.server.env.
+    Fall back to a fresh instance only if neither attribute exists.
+    """
+    state = getattr(app, "state", None)
+    if state:
+        env = getattr(state, "env", None)
+        if env:
+            return env
+        server = getattr(state, "server", None)
+        if server:
+            env = getattr(server, "env", None)
+            if env:
+                return env
+    print("[WARN] Could not find openenv internal env — grader uses fresh instance", flush=True)
+    e = DataCleaningEnvironment()
+    e.reset(task="easy")
+    return e
 # ---------------------------------------------------------------------------
 # GET /health
 # ---------------------------------------------------------------------------
@@ -57,7 +67,6 @@ def _get_env() -> DataCleaningEnvironment:
 def health():
     """Simple health check endpoint."""
     return {"status": "ok"}
-
 # ---------------------------------------------------------------------------
 # GET /tasks
 # ---------------------------------------------------------------------------
@@ -86,8 +95,6 @@ def run_grader():
 
         if isinstance(result, dict) and "score" in result:
             return JSONResponse(content=result)
-
-        # fallback safety
         return JSONResponse(content={"score": float(result)})
 
     except Exception as e:
@@ -98,9 +105,6 @@ def run_grader():
 # ---------------------------------------------------------------------------
 @app.post("/baseline")
 def run_baseline():
-    """
-    Run deterministic baseline agent across all tasks.
-    """
     try:
         result = _get_env().run_baseline()
         return JSONResponse(content=result)

server/data_cleaning_env_environment.py

@@ -112,12 +112,14 @@ def _grade_medium(rows: list[dict]) -> float:
             dupes += 1
         seen.add(key)
     dedup_score = 1.0 if dupes == 0 else max(0.0, 1.0 - dupes * 0.5)
+
     # Type-fix check: all 'age' values must be int or float
     type_errors = sum(1 for r in rows if not isinstance(r.get("age"), (int, float)))
     type_score = 1.0 if type_errors == 0 else max(0.0, 1.0 - type_errors * 0.5)
 
     return round((dedup_score + type_score) / 2, 4)
 
+
 def _grade_hard(rows: list[dict]) -> float:
     """Score 0-1 across 4 sub-criteria."""
     if not rows:
@@ -161,6 +163,7 @@ DATASETS = {
     "hard":   _make_hard_dataset,
 }
 
+
 # ---------------------------------------------------------------------------
 # Environment
 # ---------------------------------------------------------------------------
@@ -202,7 +205,9 @@ class DataCleaningEnvironment(Environment):
     Each task presents a different level of difficulty and requires
     different cleaning operations.
     """
+
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
     # -----------------------------------------------------------------------
     # Lifecycle
     # -----------------------------------------------------------------------
@@ -274,7 +279,7 @@ class DataCleaningEnvironment(Environment):
             reward = -0.05
             self._last_reward = reward
             obs = self._make_observation(reward=reward, done=False)
-            obs.metadata["error"] = f"Unknown operation '{op}'. Valid: {sorted(valid_ops)}"
+            obs.metadata["error"] = f"Unknown operation '{op}'. Valid: {sorted(VALID_OPERATIONS)}"
             return obs
 
         before_score = GRADERS[self._task](self._rows)
@@ -283,9 +288,8 @@ class DataCleaningEnvironment(Environment):
 
         # Reward = improvement in quality score (partial progress signal)
         improvement = after_score - before_score
-        # 0.01
         if improvement > 0:
-            reward = round(improvement + 0.02, 4)   # bonus for improvement
+            reward = round(improvement + 0.02, 4)   # bonus for any improvement
         elif improvement < 0:
             reward = round(improvement - 0.02, 4)   # penalty for harming dataset
         else:
@@ -301,7 +305,6 @@ class DataCleaningEnvironment(Environment):
         max_steps = MAX_STEPS[self._task]
         done = (after_score >= 1.0) or (self._step_count >= max_steps)
         self._done = done
-
         return self._make_observation(reward=reward, done=done)
 
     # -----------------------------------------------------------------------
@@ -392,7 +395,7 @@ class DataCleaningEnvironment(Environment):
     def run_baseline(self) -> dict:
         """
         Run a deterministic rule-based baseline agent on all 3 tasks.
-        Returns scores dict compatible with the hackathon /baseline endpoint.
+        Returns scores dict compatible with the /baseline endpoint.
         """
         results = {}
         for task_id in ["easy", "medium", "hard"]:
@@ -431,6 +434,9 @@ class DataCleaningEnvironment(Environment):
                 "quality_score": score,
                 "valid_operations": sorted(valid_ops),
                 "ops_already_applied": list(self._applied_ops),
+                "recommended_next": _recommend_next(
+                    self._task, missing_count, has_dupes, has_outliers, self._applied_ops
+                ),
             },
         )
 
@@ -540,8 +546,8 @@ _BASELINE_POLICIES: dict[str, list[str]] = {
     "easy":   ["impute_mean", "impute_mode", "drop_missing_rows"],
     "medium": ["remove_duplicates", "fix_type_errors", "drop_missing_rows"],
     "hard":   [
-        "drop_missing_rows",
         "fill_quantity_mean",
+        "drop_missing_rows",
         "remove_duplicates",
         "fix_type_errors",
         "remove_outliers",
@@ -553,42 +559,43 @@ _BASELINE_POLICIES: dict[str, list[str]] = {
 # Recommendation helper (guides the LLM toward correct next op)
 # ---------------------------------------------------------------------------
 
-# def _recommend_next(
-#     task: str,
-#     missing_count: int,
-#     has_dupes: bool,
-#     has_outliers: bool,
-#     applied_ops: list,
-# ) -> str:
-#     """Return a plain-English hint for the LLM about the best next operation."""
-#     applied = set(applied_ops)
-
-#     if task == "easy":
-#         if missing_count > 0:
-#             return "There are missing values. Use impute_mean (numeric) or impute_mode (text)."
-#         return "No issues remain. Episode should be complete."
-
-#     if task == "medium":
-#         if has_dupes and "remove_duplicates" not in applied:
-#             return "Duplicate rows exist. Use remove_duplicates."
-#         if "fix_type_errors" not in applied:
-#             return "Non-numeric values in numeric columns. Use fix_type_errors."
-#         if missing_count > 0 and "drop_missing_rows" not in applied:
-#             return "Some values still missing after type fix. Use drop_missing_rows."
-#         return "No issues remain. Episode should be complete."
-
-#     # hard
-#     if missing_count > 0 and "fill_quantity_mean" not in applied:
-#         return "Missing quantity values. Use fill_quantity_mean first."
-#     if missing_count > 0 and "drop_missing_rows" not in applied:
-#         return "Missing product/category values. Use drop_missing_rows."
-#     if has_outliers and "remove_outliers" not in applied:
-#         return "Price outliers detected (price<=0 or price>=500). Use remove_outliers."
-#     if "normalize_text" not in applied:
-#         return "String columns have inconsistent casing/whitespace. Use normalize_text."
-#     if has_dupes and "remove_duplicates" not in applied:
-#         return "Duplicate rows remain. Use remove_duplicates."
-#     return "All issues fixed. Episode should be complete."
+def _recommend_next(
+    task: str,
+    missing_count: int,
+    has_dupes: bool,
+    has_outliers: bool,
+    applied_ops: list,
+) -> str:
+    """Return a plain-English hint for the LLM about the best next operation."""
+    applied = set(applied_ops)
+
+    if task == "easy":
+        if missing_count > 0:
+            return "There are missing values. Use impute_mean (numeric) or impute_mode (text)."
+        return "No issues remain. Episode should be complete."
+
+    if task == "medium":
+        if has_dupes and "remove_duplicates" not in applied:
+            return "Duplicate rows exist. Use remove_duplicates."
+        if "fix_type_errors" not in applied:
+            return "Non-numeric values in numeric columns. Use fix_type_errors."
+        if missing_count > 0 and "drop_missing_rows" not in applied:
+            return "Some values still missing after type fix. Use drop_missing_rows."
+        return "No issues remain. Episode should be complete."
+
+    # hard
+    if missing_count > 0 and "fill_quantity_mean" not in applied:
+        return "Missing quantity values. Use fill_quantity_mean first."
+    if missing_count > 0 and "drop_missing_rows" not in applied:
+        return "Missing product/category values. Use drop_missing_rows."
+    if has_outliers and "remove_outliers" not in applied:
+        return "Price outliers detected (price<=0 or price>=500). Use remove_outliers."
+    if "normalize_text" not in applied:
+        return "String columns have inconsistent casing/whitespace. Use normalize_text."
+    if has_dupes and "remove_duplicates" not in applied:
+        return "Duplicate rows remain. Use remove_duplicates."
+    return "All issues fixed. Episode should be complete."
+
 
 # ---------------------------------------------------------------------------
 # Column utility helpers