Upload folder using huggingface_hub

Dockerfile

@@ -1,26 +1,78 @@
-# Base image
+# 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.
+
+# Self-contained Dockerfile for coding_env
+# Works with the flattened temp directory structure created by `openenv build`:
+#   temp/coding_env/
+#   ├── openenv/          # The openenv package (copied from src/openenv)
+#   ├── pyproject.toml    # Updated to reference local openenv
+#   ├── server/
+#   └── ...
+
 FROM python:3.11-slim
 
-# Set working directory
-WORKDIR /app/env
+# Build arguments
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=coding
+
+WORKDIR /app
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
     git \
+    curl \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy environment files
-COPY . .
+# Install uv for fast dependency management
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
 
-# Install Python dependencies
-RUN pip install --no-cache-dir -e .
+# Copy entire build context (the prepared coding_env directory)
+COPY . /app/env
 
-# Expose port
-EXPOSE 8000
+WORKDIR /app/env
+
+# Install dependencies using uv
+# The pyproject.toml has been updated to reference openenv @ file:///app/env/openenv
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --no-install-project --no-editable || \
+    uv pip install --system -e .
+
+# Install the project itself (openenv-core from repo root)
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --no-editable || \
+    uv pip install --system -e .
+
+# Install the coding_env package from envs/coding_env/
+# This is needed when building from repo root (not via openenv build)
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -d "/app/env/envs/coding_env" ]; then \
+        cd /app/env/envs/coding_env && \
+        uv pip install -e . ; \
+    fi
+
+# Set PATH to include uv's venv if created
+ENV PATH="/app/env/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+# When building from repo root, coding_env is under /app/env/envs/coding_env
+# When building via openenv build (flattened), it's directly under /app/env
+ENV PYTHONPATH="/app/env:/app/env/envs/coding_env"
 
 # Set environment variables
 ENV PYTHONUNBUFFERED=1
 ENV ENABLE_WEB_INTERFACE=true
 
-# Run the server
+# Expose port
+EXPOSE 8000
+
+# 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
+# Use the installed package path (coding_env.server.app) instead of the raw directory path (server.app)
+# This ensures relative imports like "from ..models" work correctly
 CMD ["python", "-m", "uvicorn", "coding_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

build/lib/coding_env/__init__.py

@@ -0,0 +1,12 @@
+# 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.
+
+"""Coding Environment - A Python code execution environment."""
+
+from .client import CodingEnv
+from .models import CodeAction, CodeObservation, CodeState
+
+__all__ = ["CodingEnv", "CodeAction", "CodeObservation", "CodeState"]

build/lib/coding_env/client.py

@@ -0,0 +1,56 @@
+"""
+CodingEnv
+---------
+Client-side wrapper for the Coding environment server.
+
+This client maintains a persistent WebSocket connection to the environment
+server, enabling efficient multi-step interactions with lower latency.
+
+- users instantiate CodingEnv with a base_url provided by the higher-level
+  vector/orchestration layer.
+- Environment authors ship the Docker image that serves the API.
+
+(Seeds, episode IDs, request IDs, capabilities can be added later in the payloads.)
+"""
+
+from __future__ import annotations
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_client import EnvClient
+
+from .models import CodeAction, CodeObservation, CodeState
+
+
+class CodingEnv(EnvClient[CodeAction, CodeObservation, CodeState]):
+    # --- HTTPEnvClient abstract hooks ---
+
+    def _step_payload(self, action: CodeAction) -> dict:
+        # Shape expected by the server's /step endpoint under "action"
+        return {
+            "code": action.code,
+        }
+
+    def _parse_result(self, payload: dict) -> StepResult[CodeObservation]:
+        # Expecting: { "observation": {...}, "reward": <float|null>, "done": <bool>, "info": {...} }
+        obs = CodeObservation(**payload["observation"])
+        return StepResult(
+            observation=obs,
+            reward=payload.get("reward"),
+            done=bool(payload.get("done", False)),
+        )
+
+    def _parse_state(self, payload: dict) -> CodeState:
+        """
+        Parse server response into CodeState object.
+
+        Args:
+            payload: JSON response from /state endpoint
+
+        Returns:
+            CodeState object with episode_id, step_count, and last_exit_code
+        """
+        return CodeState(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+            last_exit_code=payload.get("last_exit_code", 0),
+        )

build/lib/coding_env/models.py

@@ -0,0 +1,34 @@
+"""
+envs/coding_env/models.py
+--------------------------------
+Action/Observation types for the Coding environment.
+"""
+
+from __future__ import annotations
+
+from openenv.core.env_server.types import Action, Observation, State
+
+
+class CodeAction(Action):
+    """
+    Represents a single code execution request.
+    """
+
+    code: str
+    # Optional: future fields like 'lint': bool, 'timeout_s': float, etc.
+
+
+class CodeObservation(Observation):
+    """
+    Result of executing code in the environment.
+    """
+
+    stdout: str = ""
+    stderr: str = ""
+    exit_code: int = 0
+
+
+class CodeState(State):
+    """State for CodeAct environment with persistent execution context."""
+
+    last_exit_code: int = 0

build/lib/coding_env/openenv.yaml

@@ -0,0 +1,5 @@
+name: coding_env
+version: "0.1.0"
+description: "Coding environment for OpenEnv"
+action: CodeAction
+observation: CodeObservation

build/lib/coding_env/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.
+
+"""Coding environment server components."""
+
+from .python_codeact_env import PythonCodeActEnv
+
+__all__ = ["PythonCodeActEnv"]

build/lib/coding_env/server/app.py

@@ -0,0 +1,48 @@
+# 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 Coding Environment.
+
+This module creates an HTTP server that exposes the PythonCodeActEnv
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn envs.coding_env.server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn envs.coding_env.server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m envs.coding_env.server.app
+"""
+
+from openenv.core.env_server import create_app
+
+from coding_env.models import CodeAction, CodeObservation
+from coding_env.server.python_codeact_env import PythonCodeActEnv
+
+# Create the app with web interface and README integration
+# Pass the class (factory) instead of an instance for WebSocket session support
+app = create_app(PythonCodeActEnv, CodeAction, CodeObservation, env_name="coding_env")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+def main():
+    """Main entry point for running the server."""
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

build/lib/coding_env/server/python_codeact_env.py

@@ -0,0 +1,115 @@
+# 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.
+
+"""
+Python Code Action Environment.
+
+This module provides a server-side environment implementation for executing
+Python code actions using PyExecutor.
+"""
+
+import uuid
+
+from openenv.core.env_server.interfaces import Action, Environment, Observation
+from .python_executor import PyExecutor
+
+from ..models import CodeAction, CodeObservation, CodeState
+from .transforms import create_safe_coding_transform
+
+
+class PythonCodeActEnv(Environment):
+    """
+    Python Code Action Environment for executing code and tracking state.
+
+    This environment executes Python code submitted as CodeAction during step,
+    maintains the last exit code in its state, and returns results wrapped
+    in CodeObservation.
+
+    Args:
+        transform: Optional transform to apply to observations
+        additional_imports: List of additional module imports to authorize
+                          (e.g., ["numpy", "pandas", "matplotlib"])
+
+    Example:
+        >>> env = PythonCodeActEnv()
+        >>> obs = env.reset()
+        >>> action = CodeAction(code="print('Hello, World!')")
+        >>> obs = env.step(action)
+        >>> print(obs.stdout)  # "Hello, World!\n"
+        >>> print(obs.exit_code)  # 0
+        >>> print(env.state.last_exit_code)  # 0
+    """
+
+    def __init__(
+        self,
+    ):
+        self.transform = create_safe_coding_transform()
+        self._executor = PyExecutor()
+        self._state = CodeState()
+
+    def reset(self) -> Observation:
+        """
+        Reset environment and start fresh execution session.
+
+        Returns:
+            Initial observation with empty stdout/stderr and exit_code=0
+        """
+        # Initialize fresh state
+        self._state = CodeState(episode_id=str(uuid.uuid4()), step_count=0)
+        # Add last_exit_code to state
+        self._state.last_exit_code = 0
+
+        # Reset executor to clear any previously defined variables/functions
+        self._executor = PyExecutor()
+
+        # Reset transform to clear any accumulated state
+        self.transform = create_safe_coding_transform()
+
+        # Return initial observation
+        observation = CodeObservation(
+            stdout="",
+            stderr="",
+            exit_code=0,
+        )
+
+        return self._apply_transform(observation)
+
+    def step(self, action: Action) -> Observation:
+        """
+        Execute code action and return observation.
+
+        Args:
+            action: CodeAction containing the code to execute
+
+        Returns:
+            CodeObservation with execution results (stdout, stderr, exit_code)
+
+        Raises:
+            ValueError: If action is not a CodeAction instance
+        """
+        if not isinstance(action, CodeAction):
+            raise ValueError(f"Expected CodeAction, got {type(action)}")
+
+        # Execute the code using PyExecutor
+        result = self._executor.run(action.code)
+
+        # Update state
+        self._state.step_count += 1
+        self._state.last_exit_code = result.exit_code
+
+        # Create observation from execution result
+        observation = CodeObservation(
+            stdout=result.stdout,
+            stderr=result.stderr,
+            exit_code=result.exit_code,
+        )
+
+        return self._apply_transform(observation)
+
+    @property
+    def state(self) -> CodeState:
+        """Get current environment state including last exit code."""
+        return self._state

build/lib/coding_env/server/python_executor.py

@@ -0,0 +1,149 @@
+# 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.
+
+"""Local Python Executor (enhanced).
+
+This module provides a safer wrapper around smolagents.LocalPythonExecutor
+with improved exception handling and a few helpful tools registered with
+the executor to make debugging executed code easier.
+
+Key improvements:
+- Register a few helper utilities via send_tools so user code can use
+  them for reporting (e.g. `format_exc`).
+- More robust extraction of stdout/stderr/exit codes from the executor
+  result object, tolerant to different versions of smolagents.
+- Detailed stderr on unexpected exceptions including full traceback.
+- Structured logging for operational visibility.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import traceback
+
+from smolagents import LocalPythonExecutor
+
+from openenv.core.env_server.types import CodeExecResult
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class PyExecutor:
+    """Wrapper around smolagents LocalPythonExecutor.
+
+    The wrapper registers a few non-privileged helper tools to the
+    LocalPythonExecutor that can be used by the executed code to
+    format exceptions and to safely stringify results for improved
+    error reporting.
+    """
+
+    def __init__(self, additional_imports: list[str] | None = None):
+        if additional_imports is None:
+            additional_imports = []
+
+        self._executor = LocalPythonExecutor(additional_authorized_imports=additional_imports)
+
+        # Register helpful utilities exposed to the execution environment.
+        # These are intentionally small, read-only helpers.
+        tools = {
+            # Provide a small helper to format the current exception in the
+            # executed context. This is a *string formatting* helper only.
+            "format_exc": traceback.format_exc,
+            # Safe JSON dumps with a fallback for non-serializable objects.
+            "safe_json_dumps": lambda obj: json.dumps(obj, default=lambda o: repr(o)),
+        }
+
+        # `send_tools` is the public API on LocalPythonExecutor to make
+        # helper callables available to the sandboxed runtime. We don't
+        # provide any builtins that could change the environment.
+        try:
+            self._executor.send_tools(tools)
+        except Exception:
+            # If the LocalPythonExecutor implementation doesn't support
+            # send_tools or fails, log and continue — the executor is still usable.
+            logger.debug("LocalPythonExecutor.send_tools failed; continuing without extra tools", exc_info=True)
+
+    def run(self, code: str) -> CodeExecResult:
+        """Execute Python code and return a CodeExecResult.
+
+        This method is intentionally defensive: it attempts to extract
+        meaningful stdout/stderr/exit_code information from a variety of
+        possible return shapes that different versions of smolagents
+        may provide.
+        """
+        try:
+            exec_result = self._executor(code)
+
+            # Default values
+            stdout_parts: list[str] = []
+            stderr_parts: list[str] = []
+            exit_code = 0
+
+            # Extract logs/prints
+            try:
+                logs = getattr(exec_result, "logs", None)
+                if logs:
+                    stdout_parts.append(str(logs))
+            except Exception:
+                logger.debug("Failed to read exec_result.logs", exc_info=True)
+
+            # Extract the result / output value
+            try:
+                if hasattr(exec_result, "output"):
+                    out_val = exec_result.output
+                    # If the output is not None, stringify it in a safe way
+                    if out_val is not None:
+                        # Prefer JSON if possible, otherwise repr
+                        try:
+                            stdout_parts.append(json.dumps(out_val))
+                        except Exception:
+                            stdout_parts.append(repr(out_val))
+            except Exception:
+                logger.debug("Failed to read exec_result.output", exc_info=True)
+
+            # Some runtime implementations may put errors on `error` or `exception`
+            try:
+                err = getattr(exec_result, "error", None)
+                if err:
+                    stderr_parts.append(str(err))
+            except Exception:
+                logger.debug("Failed to read exec_result.error", exc_info=True)
+
+            try:
+                ex = getattr(exec_result, "exception", None)
+                if ex:
+                    stderr_parts.append(str(ex))
+            except Exception:
+                logger.debug("Failed to read exec_result.exception", exc_info=True)
+
+            # Determine exit code if provided
+            try:
+                if hasattr(exec_result, "exit_code"):
+                    exit_code = int(exec_result.exit_code) if exec_result.exit_code is not None else 0
+                elif hasattr(exec_result, "success"):
+                    # Some versions use `success` boolean
+                    exit_code = 0 if exec_result.success else 1
+                else:
+                    # Fallback: if there were any stderr parts, treat as non-zero
+                    exit_code = 1 if stderr_parts else 0
+            except Exception:
+                logger.debug("Failed to determine exec_result exit code", exc_info=True)
+                exit_code = 1 if stderr_parts else 0
+
+            # Compose the final stdout/stderr strings
+            stdout = "\n".join(part for part in stdout_parts if part is not None)
+            stderr = "\n".join(part for part in stderr_parts if part is not None)
+
+            return CodeExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
+
+        except Exception as e:
+            # Any unexpected exception from the LocalPythonExecutor is
+            # returned with a full traceback to make debugging easier.
+            tb = traceback.format_exc()
+            logger.exception("LocalPythonExecutor raised an exception during run")
+            return CodeExecResult(stdout="", stderr=tb, exit_code=1)

build/lib/coding_env/server/transforms.py

@@ -0,0 +1,94 @@
+# 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.
+
+"""Transforms specific to coding environments."""
+
+import ast
+import re
+
+from openenv.core.env_server.base_transforms import CompositeTransform
+from openenv.core.env_server.interfaces import Transform
+from openenv.core.env_server.types import Observation
+
+from coding_env.models import CodeObservation
+
+
+class CodeSafetyTransform(Transform):
+    """Evaluates code safety and assigns penalties for dangerous patterns."""
+
+    def __init__(self, penalty: float = -1.0):
+        self.penalty = penalty
+        self.dangerous_patterns = [
+            r"import\s+os",
+            r"import\s+subprocess",
+            r"eval\(",
+            r"exec\(",
+            r"__import__",
+            r"open\(",
+        ]
+
+    def __call__(self, observation: Observation) -> Observation:
+        if not isinstance(observation, CodeObservation):
+            return observation
+
+        if "last_code" in observation.metadata:
+            code = observation.metadata["last_code"]
+            for pattern in self.dangerous_patterns:
+                if re.search(pattern, code):
+                    observation.reward = self.penalty
+                    observation.metadata["safety_violation"] = pattern
+                    break
+            else:
+                if observation.reward is None:
+                    observation.reward = 0.0
+
+        return observation
+
+
+class CodeQualityTransform(Transform):
+    """Evaluates and rewards code quality metrics."""
+
+    def __init__(
+        self,
+        concise_bonus: float = 0.1,
+        max_length_threshold: int = 100,
+        syntax_penalty: float = -0.2,
+    ):
+        self.concise_bonus = concise_bonus
+        self.max_length_threshold = max_length_threshold
+        self.syntax_penalty = syntax_penalty
+
+    def __call__(self, observation: Observation) -> Observation:
+        if not isinstance(observation, CodeObservation):
+            return observation
+
+        quality_score = 0.0
+
+        if "last_code" in observation.metadata:
+            code = observation.metadata["last_code"]
+
+            # Reward concise code
+            if len(code.strip()) <= self.max_length_threshold:
+                quality_score += self.concise_bonus
+
+            # Check syntax (redundant but useful for quality assessment)
+            try:
+                ast.parse(code)
+            except SyntaxError:
+                quality_score += self.syntax_penalty
+
+        # Add to existing reward
+        if observation.reward is None:
+            observation.reward = quality_score
+        else:
+            observation.reward += quality_score
+
+        return observation
+
+
+def create_safe_coding_transform() -> CompositeTransform:
+    """Create a transform focused on safe coding practices and quality."""
+    return CompositeTransform([CodeSafetyTransform(), CodeQualityTransform()])

models.py

@@ -6,12 +6,9 @@ Action/Observation types for the Coding environment.
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from openenv.core.env_server.types import Action, Observation, State
 
-from openenv.core.env_server.interfaces import Action, Observation, State
 
-
-@dataclass
 class CodeAction(Action):
     """
     Represents a single code execution request.
@@ -21,7 +18,6 @@ class CodeAction(Action):
     # Optional: future fields like 'lint': bool, 'timeout_s': float, etc.
 
 
-@dataclass
 class CodeObservation(Observation):
     """
     Result of executing code in the environment.
@@ -32,7 +28,6 @@ class CodeObservation(Observation):
     exit_code: int = 0
 
 
-@dataclass
 class CodeState(State):
     """State for CodeAct environment with persistent execution context."""
 

openenv_coding_env.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: openenv-coding_env
+Version: 0.1.0
+Summary: Coding Environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.24.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: smolagents<2,>=1.22.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: ipykernel>=6.29.5; extra == "dev"

openenv_coding_env.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+__init__.py
+client.py
+models.py
+openenv.yaml
+pyproject.toml
+./__init__.py
+./client.py
+./models.py
+./openenv.yaml
+./build/lib/coding_env/openenv.yaml
+openenv_coding_env.egg-info/PKG-INFO
+openenv_coding_env.egg-info/SOURCES.txt
+openenv_coding_env.egg-info/dependency_links.txt
+openenv_coding_env.egg-info/entry_points.txt
+openenv_coding_env.egg-info/requires.txt
+openenv_coding_env.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/python_codeact_env.py
+server/python_executor.py
+server/transforms.py

openenv_coding_env.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_coding_env.egg-info/entry_points.txt

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

openenv_coding_env.egg-info/requires.txt

@@ -0,0 +1,11 @@
+openenv-core[core]>=0.2.0
+fastapi>=0.115.0
+pydantic>=2.0.0
+uvicorn[standard]>=0.24.0
+requests>=2.31.0
+smolagents<2,>=1.22.0
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0
+ipykernel>=6.29.5

openenv_coding_env.egg-info/top_level.txt

@@ -0,0 +1 @@
+coding_env

pyproject.toml

@@ -8,7 +8,7 @@ version = "0.1.0"
 description = "Coding Environment for OpenEnv"
 requires-python = ">=3.10"
 dependencies = [
-    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@fix_load_environment_metadata",
+    "openenv-core[core]>=0.2.0",
     "fastapi>=0.115.0",
     "pydantic>=2.0.0",
     "uvicorn[standard]>=0.24.0",