Upload folder using huggingface_hub

Dockerfile

@@ -1,33 +1,25 @@
-FROM python:3.11-slim
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    HOST=0.0.0.0 \
+    PORT=8000 \
+    WORKERS=1 \
+    MAX_CONCURRENT_ENVS=16
 
 WORKDIR /app
 
-# Install system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    gcc \
-    git \
     curl \
     && rm -rf /var/lib/apt/lists/*
 
-# Install Python dependencies
-COPY requirements.txt /app/server/requirements.txt
-RUN pip install --no-cache-dir -r /app/server/requirements.txt
-
-# Copy the self-contained server package
-COPY . /app/server
+COPY requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 
-# Set environment variables
-ENV PYTHONUNBUFFERED=1
-ENV HOST=0.0.0.0
-ENV PORT=8000
-ENV WORKERS=1
-ENV MAX_CONCURRENT_ENVS=16
+COPY . .
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
-    CMD curl -f http://localhost:${PORT}/health || exit 1
+EXPOSE 8000
 
-# Run FastAPI app
-EXPOSE ${PORT}
 ENV ENABLE_WEB_INTERFACE=true
 CMD ["python", "-m", "server.app"]

client.py

@@ -1,15 +1,31 @@
-"""Client for the Python code review environment."""
-
+"""Client for the Python code review environment."""
+
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Dict
 
 from compat import install_openenv_fastmcp_compat
 
 install_openenv_fastmcp_compat()
 
-from openenv.core import EnvClient
-from openenv.core.client_types import StepResult
+try:
+    from openenv.core import EnvClient
+    from openenv.core.client_types import StepResult
+except Exception:  # pragma: no cover
+    class EnvClient:  # type: ignore[override]
+        """Lightweight fallback placeholder when openenv-core is unavailable."""
+
+        def __class_getitem__(cls, item):  # type: ignore[no-untyped-def]
+            return cls
+
+    @dataclass
+    class StepResult:  # type: ignore[override]
+        """Fallback step result used for import safety."""
+
+        observation: object
+        reward: object = None
+        done: bool = False
 
 from models import (
     HistoryEntry,

compat.py

@@ -1,92 +1,128 @@
-"""Compatibility helpers for OpenEnv and FastMCP runtime drift."""
+"""Lightweight OpenEnv-compatible helpers for local and container builds."""
 
 from __future__ import annotations
 
-import sys
-import types
-from typing import Any, Optional
+from abc import ABC, abstractmethod
+from typing import Any, Generic, Optional, TypeVar
 
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, ConfigDict, Field
 
-def install_openenv_fastmcp_compat() -> None:
-    """Patch FastMCP API differences so older OpenEnv builds keep importing."""
-    try:
-        import fastmcp  # type: ignore
-    except Exception:
-        return
-
-    try:
-        if not hasattr(fastmcp, "Client"):
-            class CompatClient:
-                """Minimal async MCP client used for legacy OpenEnv imports."""
-
-                def __init__(self, *args: Any, **kwargs: Any) -> None:
-                    self.args = args
-                    self.kwargs = kwargs
-
-                async def __aenter__(self) -> "CompatClient":
-                    return self
-
-                async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> bool:
-                    return False
-
-                async def list_tools(self) -> list[Any]:
-                    return []
-
-                async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> Any:
-                    raise RuntimeError(
-                        f"MCP client compatibility mode cannot call tool: {tool_name}"
-                    )
-
-            fastmcp.Client = CompatClient  # type: ignore[attr-defined]
-    except Exception:
-        pass
-
-    try:
-        client_pkg = sys.modules.get("fastmcp.client")
-        if client_pkg is None:
-            client_pkg = types.ModuleType("fastmcp.client")
-            sys.modules["fastmcp.client"] = client_pkg
-
-        client_mod = sys.modules.get("fastmcp.client.client")
-        if client_mod is None:
-            client_mod = types.ModuleType("fastmcp.client.client")
-            sys.modules["fastmcp.client.client"] = client_mod
 
-        if not hasattr(client_mod, "CallToolResult"):
-            class CallToolResult:
-                """Compatibility container for legacy OpenEnv response handling."""
+ActT = TypeVar("ActT", bound="Action")
+ObsT = TypeVar("ObsT", bound="Observation")
+StateT = TypeVar("StateT", bound="State")
 
-                def __init__(
-                    self,
-                    content: Any = None,
-                    structured_content: Any = None,
-                    meta: Any = None,
-                    data: Any = None,
-                    is_error: bool = False,
-                ) -> None:
-                    self.content = content
-                    self.structured_content = structured_content
-                    self.meta = meta
-                    self.data = data
-                    self.is_error = is_error
-
-            client_mod.CallToolResult = CallToolResult
-
-        client_pkg.client = client_mod  # type: ignore[attr-defined]
-    except Exception:
-        pass
-
-
-install_openenv_fastmcp_compat()
-
-
-try:
-    from openenv.core.env_server.http_server import create_app as openenv_create_app
-    from openenv.core.env_server.interfaces import Environment
-    from openenv.core.env_server.types import Action, Observation, State
-except Exception as exc:  # pragma: no cover
-    raise RuntimeError(f"OpenEnv runtime import failed after compatibility patch: {exc}") from exc
-
-
-create_app = openenv_create_app
 
+def install_openenv_fastmcp_compat() -> None:
+    """Compatibility hook retained for callers; no-op in the local shim."""
+    return None
+
+
+class Action(BaseModel):
+    """Minimal action base model."""
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True, arbitrary_types_allowed=True)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class Observation(BaseModel):
+    """Minimal observation base model."""
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True, arbitrary_types_allowed=True)
+    done: bool = False
+    reward: bool | int | float | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class State(BaseModel):
+    """Minimal state base model."""
+
+    model_config = ConfigDict(extra="allow", validate_assignment=True, arbitrary_types_allowed=True)
+    episode_id: Optional[str] = None
+    step_count: int = Field(default=0, ge=0)
+
+
+class Environment(ABC, Generic[ActT, ObsT, StateT]):
+    """Minimal environment interface compatible with this project."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = False
+
+    def __init__(self, transform: Any = None, rubric: Any = None) -> None:
+        self.transform = transform
+        self.rubric = rubric
+
+    @abstractmethod
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, **kwargs: Any) -> ObsT:
+        """Reset the environment."""
+
+    @abstractmethod
+    def step(self, action: ActT, timeout_s: Optional[float] = None, **kwargs: Any) -> ObsT:
+        """Execute one step."""
+
+    @property
+    @abstractmethod
+    def state(self) -> StateT:
+        """Return current state."""
+
+    def _reset_rubric(self) -> None:
+        """Compatibility no-op."""
+        return None
+
+
+def create_app(
+    env_cls: type[Environment[Any, Any, Any]],
+    action_model: type[BaseModel],
+    observation_model: type[BaseModel],
+    max_concurrent_envs: int = 1,
+) -> FastAPI:
+    """Create a minimal FastAPI app exposing reset/step/state/schema endpoints."""
+    app = FastAPI(title="python_code_review_env")
+    env = env_cls()
+    del observation_model, max_concurrent_envs
+
+    @app.post("/reset")
+    def reset(payload: dict[str, Any] | None = None) -> dict[str, Any]:
+        try:
+            observation = env.reset(**(payload or {}))
+            dumped = observation.model_dump()
+            return {
+                "observation": dumped,
+                "reward": dumped.get("reward"),
+                "done": dumped.get("done", False),
+            }
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @app.post("/step")
+    def step(payload: dict[str, Any]) -> dict[str, Any]:
+        try:
+            action_payload = payload.get("action", payload)
+            timeout_s = payload.get("timeout_s")
+            action = action_model(**action_payload)
+            observation = env.step(action, timeout_s=timeout_s)
+            dumped = observation.model_dump()
+            return {
+                "observation": dumped,
+                "reward": dumped.get("reward"),
+                "done": dumped.get("done", False),
+            }
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @app.get("/state")
+    def state() -> dict[str, Any]:
+        try:
+            return env.state.model_dump()
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    @app.get("/schema")
+    def schema() -> dict[str, Any]:
+        return {
+            "action": action_model.model_json_schema(),
+            "observation": observation_model.model_json_schema(),
+            "state": env.state.__class__.model_json_schema(),
+        }
+
+    return app

openenv_python_env.egg-info/PKG-INFO

@@ -3,10 +3,10 @@ Name: openenv-python_env
 Version: 0.2.0
 Summary: Deterministic Python code review and repair benchmark environment for OpenEnv
 Requires-Python: >=3.10
-Requires-Dist: openenv-core[core]>=0.2.2
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: uvicorn>=0.30.0
 Requires-Dist: openai>=1.40.0
+Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pytest>=8.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"

openenv_python_env.egg-info/SOURCES.txt

@@ -1,10 +1,10 @@
 README.md
+__init__.py
+client.py
+compat.py
+inference.py
+models.py
 pyproject.toml
-./__init__.py
-./client.py
-./compat.py
-./inference.py
-./models.py
 openenv_python_env.egg-info/PKG-INFO
 openenv_python_env.egg-info/SOURCES.txt
 openenv_python_env.egg-info/dependency_links.txt
@@ -15,12 +15,21 @@ server/__init__.py
 server/app.py
 server/code_review_env_environment.py
 server/code_review_environment.py
+server/compat.py
 server/env.py
 server/env_safe.py
 server/grading.py
+server/models.py
 server/python_env_environment.py
 server/static_review.py
 server/task_bank.py
+server/graders/__init__.py
+server/graders/common.py
+server/graders/optimization.py
+server/graders/pytest_runner.py
+server/graders/syntax.py
+server/tasks/__init__.py
+server/tasks/task_bank.py
 tests/test_api.py
 tests/test_environment.py
 tests/test_examples.py

openenv_python_env.egg-info/entry_points.txt

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

openenv_python_env.egg-info/requires.txt

@@ -1,7 +1,7 @@
-openenv-core[core]>=0.2.2
 fastapi>=0.115.0
 uvicorn>=0.30.0
 openai>=1.40.0
+pydantic>=2.0.0
 pytest>=8.0.0
 
 [dev]

openenv_python_env.egg-info/top_level.txt

@@ -1 +1 @@
-python_env
+server

pyproject.toml

@@ -2,18 +2,18 @@
 requires = ["setuptools>=45", "wheel"]
 build-backend = "setuptools.build_meta"
 
-[project]
-name = "openenv-python_env"
-version = "0.2.0"
-description = "Deterministic Python code review and repair benchmark environment for OpenEnv"
-requires-python = ">=3.10"
-dependencies = [
-    "openenv-core[core]>=0.2.2",
-    "fastapi>=0.115.0",
-    "uvicorn>=0.30.0",
-    "openai>=1.40.0",
-    "pytest>=8.0.0",
-]
+[project]
+name = "openenv-python_env"
+version = "0.2.0"
+description = "Deterministic Python code review and repair benchmark environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn>=0.30.0",
+    "openai>=1.40.0",
+    "pydantic>=2.0.0",
+    "pytest>=8.0.0",
+]
 
 [project.optional-dependencies]
 dev = [
@@ -21,13 +21,12 @@ dev = [
     "pytest-cov>=4.0.0",
 ]
 
-[project.scripts]
-server = "python_env.server.app:main"
-
-[tool.setuptools]
-include-package-data = true
-packages = ["python_env", "python_env.server"]
-package-dir = { "python_env" = ".", "python_env.server" = "server" }
+[project.scripts]
+server = "server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["server", "server.graders", "server.tasks"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.115,<1.0
+uvicorn[standard]>=0.30,<1.0
+pydantic>=2.0,<3.0
+openai>=1.0,<3.0
+pytest>=8.0,<9.0

server/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    HOST=0.0.0.0 \
+    PORT=8000 \
+    WORKERS=1 \
+    MAX_CONCURRENT_ENVS=16
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy the self-contained server package
+COPY . /app/server
+
+# Run FastAPI app
+EXPOSE ${PORT}
+CMD ["python", "-m", "server.app"]