Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,26 @@
+# Base image
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app/env
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy environment files
+COPY . .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -e .
+
+# Expose port
+EXPOSE 8000
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV ENABLE_WEB_INTERFACE=true
+
+# Run the server
+CMD ["python", "-m", "uvicorn", "coding_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,11 +1,133 @@
 ---
-title: Coding Env Test
-emoji: 👁
-colorFrom: green
+title: Coding Environment Server
+emoji: 💻
+colorFrom: blue
 colorTo: blue
 sdk: docker
 pinned: false
-short_description: openenv coding-env-test
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Coding Environment
+
+A Python code execution environment that runs arbitrary Python code and returns results. Perfect for testing code execution infrastructure and demonstrating environment usage patterns.
+
+## Quick Start
+
+The simplest way to use the Coding environment is through the `CodingEnv` class:
+
+```python
+from envs.coding_env import CodeAction, CodingEnv
+
+try:
+    # Create environment from Docker image
+    coding_env = CodingEnv.from_docker_image("coding-env:latest")
+
+    # Reset
+    result = coding_env.reset()
+    print(f"Reset complete: exit_code={result.observation.exit_code}")
+
+    # Execute Python code
+    code_samples = [
+        "print('Hello, World!')",
+        "x = 5 + 3\nprint(f'Result: {x}')",
+        "import math\nprint(math.pi)"
+    ]
+
+    for code in code_samples:
+        result = coding_env.step(CodeAction(code=code))
+        print(f"Code: {code}")
+        print(f"  → stdout: {result.observation.stdout.strip()}")
+        print(f"  → exit_code: {result.observation.exit_code}")
+
+finally:
+    # Always clean up
+    coding_env.close()
+```
+
+That's it! The `CodingEnv.from_docker_image()` method handles:
+- Starting the Docker container
+- Waiting for the server to be ready
+- Connecting to the environment
+- Container cleanup when you call `close()`
+
+## Building the Docker Image
+
+Before using the environment, you need to build the Docker image:
+
+```bash
+# From project root
+docker build -t coding-env:latest -f src/envs/coding_env/server/Dockerfile .
+```
+
+## Environment Details
+
+### Action
+**CodeAction**: Contains a single field
+- `code` (str) - The Python code to execute
+
+### Observation
+**CodeObservation**: Contains the execution results
+- `stdout` (str) - Standard output from code execution
+- `stderr` (str) - Standard error from code execution
+- `exit_code` (int) - Exit code (0 for success, non-zero for errors)
+
+### State
+**CodeState**: Tracks execution state
+- `episode_id` (str) - Unique identifier for the episode
+- `step_count` (int) - Number of steps taken
+- `last_exit_code` (int) - Exit code from the last execution
+
+## Advanced Usage
+
+### Connecting to an Existing Server
+
+If you already have a Coding environment server running, you can connect directly:
+
+```python
+from envs.coding_env import CodingEnv
+
+# Connect to existing server
+coding_env = CodingEnv(base_url="<ENV_HTTP_URL_HERE>")
+
+# Use as normal
+result = coding_env.reset()
+result = coding_env.step(CodeAction(code="print('Hello!')"))
+```
+
+Note: When connecting to an existing server, `coding_env.close()` will NOT stop the server.
+
+## Development & Testing
+
+### Running the Full Example
+
+Run the complete example that demonstrates the full workflow:
+
+```bash
+python3 src/envs/coding_env/client/example_usage.py
+```
+
+This example shows:
+- Creating an environment from a Docker image
+- Resetting and executing code through the environment
+- Automatic cleanup with `close()`
+
+## Project Structure
+
+```
+coding_env/
+├── README.md              # This file
+├── models.py              # Action, Observation, and State models
+├── client/
+│   ├── coding_env_client.py  # CodingEnv client implementation
+│   └── example_usage.py      # Usage examples
+└── server/
+    ├── python_codeact_env.py  # Core environment logic
+    ├── app.py                 # FastAPI application
+    ├── transforms.py          # Observation transforms
+    ├── Dockerfile             # Container image definition
+    └── README.md              # Server-specific documentation
+```

__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"]

client.py

@@ -0,0 +1,55 @@
+"""
+CodingEnv
+---------
+Client-side wrapper for the Coding environment server.
+Talks HTTP to a single base_url exposing: /reset and /step.
+
+- users instantiate CodingEnv with a base_url provided by the higher-level
+  vector/orchestration layer.
+- Environment authors ship the Docker image that serves the HTTP 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.http_env_client import HTTPEnvClient
+
+from coding_env.models import CodeAction, CodeObservation, CodeState
+
+
+class CodingEnv(HTTPEnvClient[CodeAction, CodeObservation]):
+    # --- 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),
+        )

models.py

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

openenv.yaml

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

pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-coding_env"
+version = "0.1.0"
+description = "Coding Environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core>=0.1.0",
+    "fastapi>=0.115.0",
+    "pydantic>=2.0.0",
+    "uvicorn>=0.24.0",
+    "requests>=2.31.0",
+    "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+    "ipykernel>=6.29.5",
+]
+
+[project.scripts]
+server = "coding_env.server.app:main"
+
+
+[tool.setuptools]
+packages = ["coding_env", "coding_env.server"]
+package-dir = { "coding_env" = ".", "coding_env.server" = "server" }
+
+[tool.setuptools.package-data]
+coding_env = ["**/*.yaml", "**/*.yml"]

server/Dockerfile.backup

@@ -0,0 +1,25 @@
+# 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.
+
+# Use the standard openenv base image
+# Built from: docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
+# In GitHub Actions, this is overridden to use the GHCR base image
+ARG BASE_IMAGE=openenv-base:latest
+FROM ${BASE_IMAGE}
+
+# Copy only what's needed for this environment
+COPY src/core/ /app/src/core/
+COPY src/envs/coding_env/ /app/src/envs/coding_env/
+
+# Copy README for web interface documentation
+COPY src/envs/coding_env/README.md /app/README.md
+
+# 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
+CMD ["uvicorn", "envs.coding_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

server/README.md

@@ -0,0 +1,51 @@
+# CodingEnv HTTP Server
+
+This directory contains the HTTP server implementation for the CodingEnvironment.
+
+## Running Locally
+
+### Prerequisites
+```bash
+pip install fastapi uvicorn
+```
+
+### Start the server
+```bash
+# From the project root (/Users/pankit/git/envtorch)
+cd src
+uvicorn envs.coding_env.server.app:app --reload --host 0.0.0.0 --port 8000
+```
+
+The server will be available at `http://localhost:8000`
+
+### API Endpoints
+
+- `POST /reset` - Reset the environment
+- `POST /step` - Execute a code action
+- `GET /state` - Get current environment state
+- `GET /health` - Health check
+
+### Test with curl
+
+```bash
+# Health check
+curl http://localhost:8000/health
+
+# Reset
+curl -X POST http://localhost:8000/reset \
+  -H "Content-Type: application/json" \
+  -d '{}'
+
+# Execute code
+curl -X POST http://localhost:8000/step \
+  -H "Content-Type: application/json" \
+  -d '{
+    "action": {
+      "code": "print(\"Hello from HTTP!\")"
+    },
+    "timeout_s": 15
+  }'
+
+# Get state
+curl http://localhost:8000/state
+```

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"]

server/app.py

@@ -0,0 +1,50 @@
+# 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 endpoints, making it compatible with HTTPEnvClient.
+
+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 environment instance
+env = PythonCodeActEnv()
+
+# Create the app with web interface and README integration
+app = create_app(env, 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()

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 coding_env.server.python_executor import PyExecutor
+
+from coding_env.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

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)

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()])