Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=data_clean_env
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,57 @@
 ---
 title: Data Clean Env
-emoji: 🐠
-colorFrom: pink
+emoji: 🧹
+colorFrom: blue
 colorTo: green
 sdk: docker
 pinned: false
+app_port: 8000
+tags:
+  - openenv
+base_path: /web
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Data Clean Environment for OpenEnv
+
+## Overview and Motivation
+Data cleaning is one of the most time-consuming real-world tasks for data scientists and analysts.
+This OpenEnv simulates a data cleaning scenario where an AI agent must clean a dirty pandas DataFrame.
+The agent interacts with the DataFrame using discrete operations (filling NaNs, dropping columns, etc.)
+and receives a score based on how perfectly it cleans the data according to the task objective.
+
+## Action Space
+The environment expects a `DataCleanAction` which performs one atomic change to the dataframe:
+- `fill_na`: Provide `column_name` and `value` to fill NaNs.
+- `drop_na`: Provide `column_name` to drop rows with NaNs in that column.
+- `drop_column`: Provide `column_name` to drop it.
+- `rename_column`: Provide `column_name` and `value` (new name).
+- `change_type`: Provide `column_name` and `value` ('int', 'float', 'str').
+- `submit`: Commit the final dataframe for grading.
+
+## Observation Space
+The environment returns a `DataCleanObservation` detailing the current dataframe state:
+- `df_schema`: The dictionary representation of column types.
+- `missing_values`: A dictionary representation of NaN counts per column.
+- `head`: The first 5 rows in string format.
+- `feedback`: Text feedback of the last action.
+- `last_error`: Text description of any error encountered.
+
+## Tasks and Difficulty
+- **easy_clean (Easy)**: Fill missing values in a single column ('age').
+- **medium_clean (Medium)**: Handle multiple missing value types and drop an unnecessary column.
+- **hard_clean (Hard)**: Handle missing values, rename columns, and change column data types.
+
+## Setup and Usage
+1. Build the Docker image:
+   `docker build -t openenv_data_clean:latest -f server/Dockerfile .`
+2. Run the server locally:
+   `docker run -p 8000:8000 openenv_data_clean:latest`
+3. Run inference baseline:
+   `export HF_TOKEN="your_token"`
+   `export IMAGE_NAME="openenv_data_clean:latest"`
+   `python inference.py`
+
+## Baseline Scores
+- easy_clean: 1.00
+- medium_clean: 1.00
+- hard_clean: 1.00

__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Data Clean Env Environment."""
+
+from .client import DataCleanEnv
+from .models import DataCleanAction, DataCleanObservation
+
+__all__ = [
+    "DataCleanAction",
+    "DataCleanObservation",
+    "DataCleanEnv",
+]

client.py

@@ -0,0 +1,49 @@
+from typing import 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
+
+class DataCleanEnv(
+    EnvClient[DataCleanAction, DataCleanObservation]
+):
+    def _step_payload(self, action: DataCleanAction) -> Dict:
+        return action.model_dump()
+
+    def _parse_result(self, payload: Dict) -> StepResult[DataCleanObservation]:
+        obs_data = payload.get("observation", {})
+        observation = DataCleanObservation(
+            df_schema=obs_data.get("df_schema", ""),
+            missing_values=obs_data.get("missing_values", ""),
+            head=obs_data.get("head", ""),
+            last_error=obs_data.get("last_error"),
+            feedback=obs_data.get("feedback"),
+            metadata=obs_data.get("metadata", {}),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> DataCleanState:
+        return DataCleanState(
+            episode_id=payload.get("episode_id", ""),
+            step_count=payload.get("step_count", 0),
+            current_df_json=payload.get("current_df_json", ""),
+            task_name=payload.get("task_name", ""),
+            target_df_json=payload.get("target_df_json", ""),
+        )
+
+async def get_client(image_name: Optional[str] = None):
+    if image_name:
+        client = await DataCleanEnv.from_docker_image(image_name)
+    else:
+        client = DataCleanEnv(base_url="http://localhost:8000")
+    return client

inference.py

@@ -0,0 +1,145 @@
+import asyncio
+import os
+import textwrap
+from typing import List, Optional
+import json
+
+from openai import OpenAI
+
+from client import get_client
+from models import DataCleanAction
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1-mini")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+BENCHMARK = "data_clean_env"
+MAX_STEPS = 10
+TEMPERATURE = 0.7
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are an AI agent tasked with cleaning a pandas DataFrame.
+    You will be given the current DataFrame schema, missing values count per column, and the first 5 rows.
+    You must output a JSON string representing exactly one action to take.
+    
+    Allowed actions:
+    {"action_type": "fill_na", "column_name": "col", "value": "0"}
+    {"action_type": "drop_na", "column_name": "col"}
+    {"action_type": "drop_column", "column_name": "col"}
+    {"action_type": "rename_column", "column_name": "old_col", "value": "new_col"}
+    {"action_type": "change_type", "column_name": "col", "value": "int"}  (value can be int, float, or str)
+    {"action_type": "submit"}
+    
+    Your goal:
+    - easy_clean: Fill missing values in 'age' with '0'.
+    - medium_clean: Drop rows with missing values in 'name' and 'age'. Drop column 'ignore_me'.
+    - hard_clean: Rename 'EmployeeID' to 'emp_id'. Drop 'Dept' column. Make 'Salary' valid (fill NaN with '0' and convert to float/int). Fill NaN in 'JoinDate' with '2000-01-01'.
+    
+    When you are done cleaning according to the goal, output {"action_type": "submit"}.
+    Reply ONLY with valid JSON.
+    """
+).strip()
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error if error else "null"
+    done_val = str(done).lower()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+
+def get_model_action(client: OpenAI, obs_dict: dict) -> dict:
+    user_prompt = f"Observation:\n{json.dumps(obs_dict, indent=2)}\nWhat is your next action?"
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=TEMPERATURE,
+            stream=False,
+        )
+        text = completion.choices[0].message.content.strip()
+        if text.startswith("```json"):
+            text = text[7:]
+        if text.endswith("```"):
+            text = text[:-3]
+        return json.loads(text.strip())
+    except Exception as exc:
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        return {"action_type": "submit"}
+
+async def run_task(task_name: str, client: OpenAI, env_client) -> None:
+    log_start(task=task_name, env=BENCHMARK, model=MODEL_NAME)
+    
+    try:
+        result = await env_client.reset(task=task_name)
+        
+        rewards = []
+        steps_taken = 0
+        score = 0.0
+        success = False
+        
+        for step in range(1, MAX_STEPS + 1):
+            if result.done:
+                break
+                
+            obs = result.observation
+            obs_dict = {
+                "schema": obs.df_schema,
+                "missing": obs.missing_values,
+                "head": obs.head,
+                "feedback": obs.feedback,
+                "error": obs.last_error
+            }
+            
+            action_dict = get_model_action(client, obs_dict)
+            action_str = json.dumps(action_dict)
+            action = DataCleanAction(**action_dict)
+            
+            result = await env_client.step(action)
+            reward = result.reward or 0.0
+            done = result.done
+            error = result.observation.last_error
+            
+            rewards.append(reward)
+            steps_taken = step
+            
+            if action.action_type == "submit":
+                score = reward # grader sets final reward to score
+            
+            log_step(step=step, action=action_str, reward=reward, done=done, error=error)
+            
+            if done:
+                break
+                
+        success = score >= 0.5
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+        
+    except Exception as e:
+        print(f"[DEBUG] Error running task {task_name}: {e}", flush=True)
+
+async def main() -> None:
+    if HF_TOKEN is None:
+        raise ValueError("HF_TOKEN environment variable is required")
+
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+    image_name = os.getenv("LOCAL_IMAGE_NAME") or os.getenv("IMAGE_NAME")
+    env_client = await get_client(image_name)
+
+    for task in ["easy_clean", "medium_clean", "hard_clean"]:
+        await run_task(task, client, env_client)
+        
+    await env_client.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())

models.py

@@ -0,0 +1,19 @@
+from typing import Literal, Optional, List
+from pydantic import Field
+from openenv.core.env_server.types import Action, Observation
+
+class DataCleanAction(Action):
+    """Action for the Data Clean Env environment to manipulate the dataframe."""
+    action_type: Literal["fill_na", "drop_na", "rename_column", "drop_column", "change_type", "submit"] = Field(
+        ..., description="The type of action to perform."
+    )
+    column_name: Optional[str] = Field(None, description="The target column name.")
+    value: Optional[str] = Field(None, description="The value to use (for fill_na), new name (for rename_column), or new type (for change_type like 'int', 'float', 'str').")
+
+class DataCleanObservation(Observation):
+    """Observation from the Data Clean Env environment showing the dataframe state."""
+    df_schema: str = Field(default="", description="The schema of the dataframe.")
+    missing_values: str = Field(default="", description="A string detailing missing values per column.")
+    head: str = Field(default="", description="The first 5 rows of the dataframe.")
+    last_error: Optional[str] = Field(default=None, description="Any error from the last action.")
+    feedback: Optional[str] = Field(default=None, description="Feedback about the last action.")

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: data_clean_env
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

openenv_data_clean_env.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: openenv-data_clean_env
+Version: 0.1.0
+Summary: Data Clean Env environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.0
+Requires-Dist: pandas>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_data_clean_env.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+./__init__.py
+./client.py
+./inference.py
+./models.py
+openenv_data_clean_env.egg-info/PKG-INFO
+openenv_data_clean_env.egg-info/SOURCES.txt
+openenv_data_clean_env.egg-info/dependency_links.txt
+openenv_data_clean_env.egg-info/entry_points.txt
+openenv_data_clean_env.egg-info/requires.txt
+openenv_data_clean_env.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/data_clean_env_environment.py

openenv_data_clean_env.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_data_clean_env.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = data_clean_env.server.app:main

openenv_data_clean_env.egg-info/requires.txt

@@ -0,0 +1,6 @@
+openenv-core[core]>=0.2.0
+pandas>=2.0.0
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_data_clean_env.egg-info/top_level.txt

@@ -0,0 +1 @@
+data_clean_env

pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-data_clean_env"
+version = "0.1.0"
+description = "Data Clean Env environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core[core]>=0.2.0",
+    "pandas>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+server = "data_clean_env.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["data_clean_env", "data_clean_env.server"]
+package-dir = { "data_clean_env" = ".", "data_clean_env.server" = "server" }

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Data Clean Env environment server components."""
+
+from .data_clean_env_environment import DataCleanEnvironment
+
+__all__ = ["DataCleanEnvironment"]

server/app.py

@@ -0,0 +1,82 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Data Clean Env Environment.
+
+This module creates an HTTP server that exposes the DataCleanEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "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
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    DataCleanEnvironment,
+    DataCleanAction,
+    DataCleanObservation,
+    env_name="data_clean_env",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m data_clean_env.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn data_clean_env.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    # main() is callable here
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

server/data_clean_env_environment.py

@@ -0,0 +1,181 @@
+import json
+from uuid import uuid4
+from typing import Dict, 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
+
+class DataCleanState(State):
+    current_df_json: str
+    task_name: str
+    target_df_json: str
+
+class DataCleanEnvironment(Environment):
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        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 _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())
+        missing = str(self._df.isna().sum().to_dict())
+        head = self._df.head().to_string()
+        return DataCleanObservation(
+            df_schema=schema,
+            missing_values=missing,
+            head=head,
+            last_error=error,
+            feedback=feedback,
+            done=done,
+            reward=reward,
+        )
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, task: str = "easy_clean", **kwargs: Any) -> DataCleanObservation:
+        self._state = DataCleanState(episode_id=str(uuid4()), step_count=0, current_df_json="", task_name=task, target_df_json="")
+        
+        if task == "easy_clean":
+            self._df = pd.DataFrame({"id": [1, 2, 3], "age": [25.0, np.nan, 30.0]})
+            self._target_df = pd.DataFrame({"id": [1, 2, 3], "age": [25.0, 0.0, 30.0]})
+        elif task == "medium_clean":
+            self._df = pd.DataFrame({
+                "name": ["Alice", "Bob", "Charlie", None], 
+                "age": [25.0, np.nan, 30.0, 22.0], 
+                "ignore_me": [1, 2, 3, 4]
+            })
+            self._target_df = pd.DataFrame({
+                "name": ["Alice", "Bob", "Charlie"], 
+                "age": [25.0, np.nan, 30.0], 
+            }).dropna(subset=["name", "age"])
+            self._target_df = self._target_df.reset_index(drop=True)
+        elif task == "hard_clean":
+            self._df = pd.DataFrame({
+                "EmployeeID": ["E1", "E2", "E3"],
+                "Dept": ["IT", "HR", "IT"],
+                "Salary": ["5000", np.nan, "6000"],
+                "JoinDate": [np.nan, "2020-01-01", "2021-01-01"]
+            })
+            self._target_df = pd.DataFrame({
+                "emp_id": ["E1", "E2", "E3"],
+                "Salary": [5000.0, 0.0, 6000.0],
+                "JoinDate": ["2000-01-01", "2020-01-01", "2021-01-01"]
+            })
+        else:
+            self._df = pd.DataFrame({"col": [1, 2]})
+            self._target_df = pd.DataFrame({"col": [1, 2]})
+            
+        self._state.current_df_json = self._df.to_json()
+        self._state.target_df_json = self._target_df.to_json()
+        
+        return self._get_obs(feedback=f"Started task {task}.")
+
+    def step(self, action: DataCleanAction) -> DataCleanObservation:  # type: ignore[override]
+        self._state.step_count += 1
+        reward = 0.0
+        error = None
+        feedback = None
+        done = False
+        
+        if action.action_type == "submit":
+            done = True
+            score = self._grade()
+            reward = score  # Final reward based on grader
+            feedback = f"Submitted. Final score: {score}"
+            return self._get_obs(feedback=feedback, done=done, reward=reward)
+            
+        col = action.column_name
+        val = action.value
+        
+        try:
+            if col and col not in self._df.columns:
+                raise ValueError(f"Column '{col}' not found.")
+                
+            if action.action_type == "fill_na":
+                if not col or val is None: raise ValueError("fill_na requires column_name and value.")
+                # Basic inference of type
+                try:
+                    typed_val = float(val) if '.' in val else int(val)
+                except ValueError:
+                    typed_val = val
+                self._df[col] = self._df[col].fillna(typed_val)
+                feedback = f"Filled NaNs in {col} with {val}."
+                reward = 0.1
+                
+            elif action.action_type == "drop_na":
+                if not col: raise ValueError("drop_na requires column_name.")
+                self._df = self._df.dropna(subset=[col])
+                self._df = self._df.reset_index(drop=True)
+                feedback = f"Dropped rows with NaNs in {col}."
+                reward = 0.1
+                
+            elif action.action_type == "drop_column":
+                if not col: raise ValueError("drop_column requires column_name.")
+                self._df = self._df.drop(columns=[col])
+                feedback = f"Dropped column {col}."
+                reward = 0.1
+                
+            elif action.action_type == "rename_column":
+                if not col or not val: raise ValueError("rename_column requires column_name and value.")
+                self._df = self._df.rename(columns={col: val})
+                feedback = f"Renamed column {col} to {val}."
+                reward = 0.1
+                
+            elif action.action_type == "change_type":
+                if not col or not val: raise ValueError("change_type requires column_name and value.")
+                if val == "int": self._df[col] = self._df[col].astype(int)
+                elif val == "float": self._df[col] = self._df[col].astype(float)
+                elif val == "str": self._df[col] = self._df[col].astype(str)
+                else: raise ValueError("Type must be 'int', 'float', or 'str'.")
+                feedback = f"Changed type of {col} to {val}."
+                reward = 0.1
+                
+        except Exception as e:
+            error = str(e)
+            reward = -0.05
+            
+        self._state.current_df_json = self._df.to_json()
+        return self._get_obs(feedback=feedback, error=error, done=done, reward=reward)
+
+    def _grade(self) -> float:
+        task = self._state.task_name
+        score = 0.0
+        
+        if task == "easy_clean":
+            if "age" in self._df.columns and self._df["age"].isna().sum() == 0:
+                if (self._df["age"] == self._target_df["age"]).all():
+                    score = 1.0
+        
+        elif task == "medium_clean":
+            max_score = 3.0
+            current_score = 0.0
+            if "name" in self._df.columns and self._df["name"].isna().sum() == 0:
+                current_score += 1.0
+            if "age" in self._df.columns and self._df["age"].isna().sum() == 0:
+                current_score += 1.0
+            if "ignore_me" not in self._df.columns:
+                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:
+                current_score += 1.0
+            if "Dept" not in self._df.columns:
+                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"]):
+                current_score += 1.0
+            if "JoinDate" in self._df.columns and self._df["JoinDate"].isna().sum() == 0:
+                current_score += 1.0
+            score = current_score / max_score
+            
+        return score
+
+    @property
+    def state(self) -> State:
+        return self._state

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+