Upload folder using huggingface_hub

Dockerfile

@@ -10,16 +10,20 @@
 ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
 FROM ghcr.io/meta-pytorch/openenv-base:latest
 
+WORKDIR /app
+
+COPY . /app
+
 # Install dependencies
-COPY src/envs/coding_env/server/requirements.txt /tmp/requirements.txt
+
 RUN pip install --no-cache-dir -r /tmp/requirements.txt && rm /tmp/requirements.txt
 
 # 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 \
@@ -27,5 +31,6 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 
 # Run the FastAPI server
 ENV ENABLE_WEB_INTERFACE=true
+ENV PYTHONPATH=/app
 
-CMD ["uvicorn", "envs.coding_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]

__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 .coding_env_client import CodingEnv
+from .models import CodeAction, CodeObservation, CodeState
+
+__all__ = ["CodeAction", "CodeObservation", "CodeState", "CodingEnv"]

client.py

@@ -0,0 +1,6 @@
+"""Client stub for coding_env environment."""
+
+class coding_envEnv:
+    pass
+
+

coding_env_client.py

@@ -0,0 +1,60 @@
+"""
+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 typing import Optional, TYPE_CHECKING
+
+from core.client_types import StepResult
+
+from core.http_env_client import HTTPEnvClient
+
+from .models import CodeAction, CodeObservation, CodeState
+
+if TYPE_CHECKING:
+    from core.containers.runtime import ContainerProvider
+
+
+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,40 @@
+"""
+envs/coding_env/models.py
+--------------------------------
+Action/Observation types for the Coding environment.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from core.env_server 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,8 @@
+spec_version: 1
+name: coding_env
+type: space
+runtime: fastapi
+app: envs.coding_env.server.app:app
+port: 8000
+
+

server/Dockerfile

@@ -0,0 +1,29 @@
+# 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}
+
+# Install dependencies
+COPY src/envs/coding_env/server/requirements.txt /tmp/requirements.txt
+RUN pip install --no-cache-dir -r /tmp/requirements.txt && rm /tmp/requirements.txt
+
+# 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,2 @@
+
+

server/app.py

@@ -0,0 +1,39 @@
+# 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 core.env_server import create_app
+
+from ..models import CodeAction, CodeObservation
+from .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)

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 core.env_server import Action, Environment, Observation
+from core.tools 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

server/requirements.txt

@@ -0,0 +1 @@
+smolagents

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 core.env_server.base_transforms import CompositeTransform
+from core.env_server.interfaces import Transform
+from core.env_server.types import Observation
+
+from ..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()])