Upload folder using huggingface_hub

README.md

@@ -6,6 +6,7 @@ colorTo: green
 sdk: docker
 pinned: false
 app_port: 8000
+base_path: /web
 tags:
   - openenv
 ---
@@ -98,7 +99,7 @@ Our reward function is designed for efficient RL convergence:
 - ✅ **Typed Models**: Fully Pydantic-powered `Observation` and `Action`.
 - ✅ **API Standard**: Implements `step()`, `reset()`, and `state()`.
 - ✅ **Strict Logs**: Emits `[START]`, `[STEP]`, and `[END]` traces exactly as required.
-- ✅ **Robustness**: Handles network timeouts and invalid JSON gracefully.
+- ✅ **Robustness**: Handles network timeouts and invalid JSON carefully.
 
 ---
 Built with ❤️ for the Meta & Hugging Face OpenEnv Hackathon.

client.py

@@ -1,19 +1,22 @@
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 from openenv.core.client_types import StepResult
-from openenv.core.env_server.types import State
 from openenv.core import EnvClient
 
-from models import DataCleanAction, DataCleanObservation
-from server.data_clean_env_environment import DataCleanState
+try:
+    from .models import DataCleanAction, DataCleanObservation
+    from .server.data_clean_env_environment import DataCleanState
+except ImportError:
+    from models import DataCleanAction, DataCleanObservation
+    from server.data_clean_env_environment import DataCleanState
 
 class DataCleanEnv(
     EnvClient[DataCleanAction, DataCleanObservation, DataCleanState]
 ):
-    def _step_payload(self, action: DataCleanAction) -> Dict:
+    def _step_payload(self, action: DataCleanAction) -> Dict[str, Any]:
         return action.model_dump()
 
-    def _parse_result(self, payload: Dict) -> StepResult[DataCleanObservation]:
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[DataCleanObservation]:
         obs_data = payload.get("observation", {})
         observation = DataCleanObservation(
             df_schema=obs_data.get("df_schema", ""),
@@ -28,11 +31,11 @@ class DataCleanEnv(
 
         return StepResult(
             observation=observation,
-            reward=payload.get("reward"),
+            reward=payload.get("reward", 0.0),
             done=payload.get("done", False),
         )
 
-    def _parse_state(self, payload: Dict) -> DataCleanState:
+    def _parse_state(self, payload: Dict[str, Any]) -> DataCleanState:
         return DataCleanState(
             episode_id=payload.get("episode_id", ""),
             step_count=payload.get("step_count", 0),
@@ -41,7 +44,7 @@ class DataCleanEnv(
             target_df_json=payload.get("target_df_json", ""),
         )
 
-async def get_client(image_name: Optional[str] = None):
+async def get_client(image_name: Optional[str] = None) -> DataCleanEnv:
     if image_name:
         client = await DataCleanEnv.from_docker_image(image_name)
     else:

inference.py

@@ -131,14 +131,18 @@ async def run_task(task_name: str, client: OpenAI, env_client) -> None:
         log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
 
 async def main() -> None:
+    task_name_env = os.getenv("DATA_CLEAN_ENV_TASK")
+    tasks_to_run = [task_name_env] if task_name_env else ["easy_clean", "medium_clean", "hard_clean"]
+
     if HF_TOKEN is None:
-        raise ValueError("HF_TOKEN environment variable is required")
+        print("[DEBUG] HF_TOKEN environment variable is required", flush=True)
+        for task in tasks_to_run:
+            log_start(task=task, env=BENCHMARK, model=MODEL_NAME)
+            log_end(success=False, steps=0, score=0.0, rewards=[])
+        return
 
     client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
     image_name = os.getenv("LOCAL_IMAGE_NAME") or os.getenv("IMAGE_NAME")
-    
-    task_name_env = os.getenv("DATA_CLEAN_ENV_TASK")
-    tasks_to_run = [task_name_env] if task_name_env else ["easy_clean", "medium_clean", "hard_clean"]
 
     try:
         env_client = await get_client(image_name)

local_smoke.py

@@ -0,0 +1,30 @@
+import asyncio
+
+from models import DataCleanAction
+from client import get_client
+
+
+async def test_env():
+    # Test without docker first
+    client = await get_client(None)
+    
+    try:
+        print("Resetting...")
+        result = await client.reset(task="easy_clean")
+        print("Reset result:", result)
+        
+        print("Sending action...")
+        action = DataCleanAction(action_type="fill_na", column_name="age", value="0")
+        result = await client.step(action)
+        print("Step result:", result)
+        
+        print("Submitting...")
+        action = DataCleanAction(action_type="submit")
+        result = await client.step(action)
+        print("Submit result:", result)
+        print("Success!")
+    finally:
+        await client.close()
+
+if __name__ == "__main__":
+    asyncio.run(test_env())

server/app.py

@@ -35,9 +35,12 @@ except Exception as e:  # pragma: no cover
         "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
     ) from e
 
-# Import from local models.py (PYTHONPATH includes /app/env in Docker)
-from models import DataCleanAction, DataCleanObservation
-from .data_clean_env_environment import DataCleanEnvironment
+try:
+    from ..models import DataCleanAction, DataCleanObservation
+    from .data_clean_env_environment import DataCleanEnvironment
+except ImportError:
+    from models import DataCleanAction, DataCleanObservation
+    from .data_clean_env_environment import DataCleanEnvironment
 
 
 # Create the app with web interface and README integration
@@ -50,7 +53,7 @@ app = create_app(
 )
 
 
-def main(host: str = "0.0.0.0", port: int = 8000):
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
     """
     Entry point for direct execution via uv run or python -m.
 

server/data_clean_env_environment.py

@@ -1,13 +1,15 @@
-import json
 from uuid import uuid4
-from typing import Dict, Any, Optional
+from typing import Any, Optional
 import pandas as pd
 import numpy as np
 
 from openenv.core.env_server.interfaces import Environment
 from openenv.core.env_server.types import State
 
-from models import DataCleanAction, DataCleanObservation
+try:
+    from ..models import DataCleanAction, DataCleanObservation
+except ImportError:
+    from models import DataCleanAction, DataCleanObservation
 
 class DataCleanState(State):
     current_df_json: str
@@ -21,6 +23,29 @@ class DataCleanEnvironment(Environment):
         self._state = DataCleanState(episode_id=str(uuid4()), step_count=0, current_df_json="", task_name="", target_df_json="")
         self._df: pd.DataFrame = pd.DataFrame()
         self._target_df: pd.DataFrame = pd.DataFrame()
+
+    def _columns_match_target(self) -> bool:
+        return list(self._df.columns) == list(self._target_df.columns)
+
+    def _series_matches_target(self, column_name: str) -> bool:
+        if column_name not in self._df.columns or column_name not in self._target_df.columns:
+            return False
+
+        left = self._df[column_name].reset_index(drop=True)
+        right = self._target_df[column_name].reset_index(drop=True)
+        return left.equals(right)
+
+    def _numeric_series_matches_target(self, column_name: str) -> bool:
+        if column_name not in self._df.columns or column_name not in self._target_df.columns:
+            return False
+
+        try:
+            left = pd.to_numeric(self._df[column_name]).reset_index(drop=True)
+            right = pd.to_numeric(self._target_df[column_name]).reset_index(drop=True)
+        except Exception:
+            return False
+
+        return left.equals(right)
         
     def _get_obs(self, feedback: Optional[str] = None, error: Optional[str] = None, done: bool = False, reward: float = 0.0) -> DataCleanObservation:
         schema = str(self._df.dtypes.to_dict())
@@ -146,39 +171,50 @@ class DataCleanEnvironment(Environment):
         score = 0.0
         
         if task == "easy_clean":
+            max_score = 3.0
+            current_score = 0.0
+
+            if self._columns_match_target():
+                current_score += 1.0
             if "age" in self._df.columns and self._df["age"].isna().sum() == 0:
-                try:
-                    if len(self._df["age"]) == len(self._target_df["age"]) and (self._df["age"] == self._target_df["age"]).all():
-                        score = 1.0
-                except Exception:
-                    pass
+                current_score += 1.0
+            if self._series_matches_target("age"):
+                current_score += 1.0
+
+            score = current_score / max_score
         
         elif task == "medium_clean":
-            max_score = 3.0
+            max_score = 4.0
             current_score = 0.0
-            if "name" in self._df.columns and self._df["name"].isna().sum() == 0:
+
+            if self._columns_match_target():
                 current_score += 1.0
-            if "age" in self._df.columns and self._df["age"].isna().sum() == 0:
+            if len(self._df) == len(self._target_df):
+                current_score += 1.0
+            if self._series_matches_target("name"):
                 current_score += 1.0
-            if "ignore_me" not in self._df.columns:
+            if self._numeric_series_matches_target("age"):
                 current_score += 1.0
+
             score = current_score / max_score
             
         elif task == "hard_clean":
             max_score = 4.0
             current_score = 0.0
-            if "emp_id" in self._df.columns:
+
+            if self._columns_match_target():
                 current_score += 1.0
-            if "Dept" not in self._df.columns:
+            if self._series_matches_target("emp_id"):
                 current_score += 1.0
-            if "Salary" in self._df.columns and self._df["Salary"].isna().sum() == 0 and pd.api.types.is_numeric_dtype(self._df["Salary"]):
+            if self._numeric_series_matches_target("Salary"):
                 current_score += 1.0
-            if "JoinDate" in self._df.columns and self._df["JoinDate"].isna().sum() == 0:
+            if self._series_matches_target("JoinDate"):
                 current_score += 1.0
+
             score = current_score / max_score
             
         return max(0.01, min(0.99, float(score)))
 
     @property
-    def state(self) -> State:
+    def state(self) -> DataCleanState:
         return self._state

tests/conftest.py

@@ -0,0 +1,8 @@
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))

tests/test_environment.py

@@ -0,0 +1,54 @@
+from fastapi.testclient import TestClient
+
+from models import DataCleanAction
+from server.app import app
+from server.data_clean_env_environment import DataCleanEnvironment
+
+
+def test_easy_clean_solution_scores_expected_value() -> None:
+    env = DataCleanEnvironment()
+    env.reset(task="easy_clean")
+    env.step(DataCleanAction(action_type="fill_na", column_name="age", value="0"))
+
+    result = env.step(DataCleanAction(action_type="submit"))
+
+    assert result.done is True
+    assert result.reward == 0.99
+
+
+def test_medium_clean_wrong_solution_is_not_near_perfect() -> None:
+    env = DataCleanEnvironment()
+    env.reset(task="medium_clean")
+    env.step(DataCleanAction(action_type="fill_na", column_name="age", value="0"))
+    env.step(DataCleanAction(action_type="drop_na", column_name="name"))
+    env.step(DataCleanAction(action_type="drop_column", column_name="ignore_me"))
+
+    result = env.step(DataCleanAction(action_type="submit"))
+
+    assert result.reward < 0.99
+
+
+def test_hard_clean_wrong_join_date_is_not_near_perfect() -> None:
+    env = DataCleanEnvironment()
+    env.reset(task="hard_clean")
+    env.step(DataCleanAction(action_type="rename_column", column_name="EmployeeID", value="emp_id"))
+    env.step(DataCleanAction(action_type="drop_column", column_name="Dept"))
+    env.step(DataCleanAction(action_type="fill_na", column_name="Salary", value="0"))
+    env.step(DataCleanAction(action_type="change_type", column_name="Salary", value="float"))
+    env.step(DataCleanAction(action_type="fill_na", column_name="JoinDate", value="wrong-date"))
+
+    result = env.step(DataCleanAction(action_type="submit"))
+
+    assert result.reward < 0.99
+
+
+def test_state_endpoint_keeps_core_state_fields() -> None:
+    client = TestClient(app)
+    client.post("/reset", json={"task": "easy_clean"})
+
+    response = client.get("/state")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert "episode_id" in payload
+    assert "step_count" in payload