openenv 0.4.1__tar.gz → 0.4.2__tar.gz

{openenv-0.4.1/src/openenv.egg-info → openenv-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openenv
-Version: 0.4.1
+Version: 0.4.2
 Summary: A unified framework for reinforcement learning environments
 License-Expression: BSD-3-Clause
 Requires-Python: >=3.10
@@ -19,7 +19,7 @@ Requires-Dist: openai>=2.7.2
 Requires-Dist: tomli>=2.3.0
 Requires-Dist: tomli-w>=1.2.0
 Requires-Dist: websockets>=15.0.1
-Requires-Dist: fastmcp>=3.0.0
+Requires-Dist: fastmcp<4.0.0,>=3.0.0
 Requires-Dist: gradio>=4.0.0
 Requires-Dist: httpx>=0.28.1
 Provides-Extra: daytona

{openenv-0.4.1 → openenv-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openenv"
-version = "0.4.1"
+version = "0.4.2"
 description = "A unified framework for reinforcement learning environments"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -29,7 +29,7 @@ dependencies = [
     "tomli-w>=1.2.0",
     "websockets>=15.0.1",
     # MCP support
-    "fastmcp>=3.0.0",
+    "fastmcp>=3.0.0,<4.0.0",
     # Web UI dependencies
     "gradio>=4.0.0",
     "httpx>=0.28.1",

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/commands/build.py

@@ -293,19 +293,36 @@ def _build_docker_image(
         build_args["BUILD_MODE"] = build_mode
         build_args["ENV_NAME"] = env_path.name.replace("_env", "")
 
-        # Build Docker command
-        cmd = ["docker", "build", "-t", tag, "-f", str(dockerfile)]
+        cmd = _docker_build_command(
+            tag=tag,
+            dockerfile=dockerfile,
+            build_dir=build_dir,
+            build_args=build_args,
+            no_cache=no_cache,
+        )
 
-        if no_cache:
-            cmd.append("--no-cache")
+        result = _run_command(cmd, check=False)
+        return result.returncode == 0
 
-        for key, value in build_args.items():
-            cmd.extend(["--build-arg", f"{key}={value}"])
 
-        cmd.append(str(build_dir))
+def _docker_build_command(
+    tag: str,
+    dockerfile: Path,
+    build_dir: Path,
+    build_args: dict[str, str],
+    no_cache: bool,
+) -> list[str]:
+    """Build the docker build command for an OpenEnv environment."""
+    cmd = ["docker", "build", "-t", tag, "-f", str(dockerfile)]
 
-        result = _run_command(cmd, check=False)
-        return result.returncode == 0
+    if no_cache:
+        cmd.append("--no-cache")
+
+    for key, value in build_args.items():
+        cmd.extend(["--build-arg", f"{key}={value}"])
+
+    cmd.append(str(build_dir))
+    return cmd
 
 
 def _push_docker_image(tag: str, registry: str | None = None) -> bool:

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/commands/collect.py

@@ -86,6 +86,28 @@ def _resolve_api_key(provider: str) -> str:
     )
 
 
+def _extract_legal_actions(messages: list[dict[str, Any]]) -> list[int]:
+    for message in reversed(messages):
+        content = message.get("content") or ""
+        if not isinstance(content, str):
+            continue
+        try:
+            payload = json.loads(content)
+        except (json.JSONDecodeError, ValueError):
+            payload = None
+        if isinstance(payload, dict) and "legal_actions" in payload:
+            legal = payload["legal_actions"]
+            if isinstance(legal, list):
+                return [int(a) for a in legal]
+        match = re.search(r"Legal actions:\s*\[([^\]]*)\]", content)
+        if match:
+            raw = match.group(1).strip()
+            if not raw:
+                return []
+            return [int(x) for x in raw.split(",")]
+    return []
+
+
 def _build_scripted_model_step():
     """Default teacher: pick the first legal action from the latest observation.
 
@@ -93,27 +115,6 @@ def _build_scripted_model_step():
     users smoke-test the CLI without any API key configured.
     """
 
-    def _extract_legal_actions(messages: list[dict[str, Any]]) -> list[int]:
-        for message in reversed(messages):
-            content = message.get("content") or ""
-            if not isinstance(content, str):
-                continue
-            try:
-                payload = json.loads(content)
-            except (json.JSONDecodeError, ValueError):
-                payload = None
-            if isinstance(payload, dict) and "legal_actions" in payload:
-                legal = payload["legal_actions"]
-                if isinstance(legal, list):
-                    return [int(a) for a in legal]
-            match = re.search(r"Legal actions:\s*\[([^\]]*)\]", content)
-            if match:
-                raw = match.group(1).strip()
-                if not raw:
-                    return []
-                return [int(x) for x in raw.split(",")]
-        return []
-
     def model_step(messages, tools, sampling):
         del sampling
         legal = _extract_legal_actions(messages)

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/commands/init.py

@@ -298,16 +298,8 @@ def _copy_and_template_file(
         ) from e
 
 
-def _copy_template_directory(
-    template_pkg: str,
-    template_dir: str,
-    dest_dir: Path,
-    replacements: Dict[str, str],
-    env_name: str,
-) -> List[Path]:
-    """Recursively copy template directory and apply replacements."""
-    created_files: List[Path] = []
-
+def _resolve_template_path(template_pkg: str, template_dir: str) -> Path:
+    """Resolve the template package directory used by `openenv init`."""
     # Get the package path using importlib.resources but avoid importing the template package
     # We'll use the package's __file__ to get the directory path
     import importlib
@@ -341,6 +333,20 @@ def _copy_template_directory(
             f"Template directory not found: {template_pkg}.{template_dir}"
         )
 
+    return template_path
+
+
+def _copy_template_directory(
+    template_pkg: str,
+    template_dir: str,
+    dest_dir: Path,
+    replacements: Dict[str, str],
+    env_name: str,
+) -> List[Path]:
+    """Recursively copy template directory and apply replacements."""
+    created_files: List[Path] = []
+    template_path = _resolve_template_path(template_pkg, template_dir)
+
     # Walk through all files in template directory using Path
     for item in template_path.rglob("*"):
         if item.is_file():

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/commands/push.py

@@ -239,6 +239,64 @@ def _validate_openenv_directory(directory: Path) -> tuple[str, dict]:
     return env_name, manifest
 
 
+def _rewrite_dockerfile_for_space(
+    dockerfile_content: str,
+    *,
+    base_image: str | None,
+    enable_interface: bool,
+) -> tuple[str, list[str]]:
+    """Rewrite deployment Dockerfile content and return printed change labels."""
+    lines = dockerfile_content.split("\n")
+    new_lines = []
+    cmd_found = False
+    base_image_updated = False
+    web_interface_env_exists = "ENABLE_WEB_INTERFACE" in dockerfile_content
+    last_instruction = None
+
+    for line in lines:
+        stripped = line.strip()
+        token = stripped.split(maxsplit=1)[0] if stripped else ""
+        current_instruction = token.upper()
+
+        is_healthcheck_continuation = last_instruction == "HEALTHCHECK"
+
+        # Update base image if specified
+        if base_image and stripped.startswith("FROM") and not base_image_updated:
+            new_lines.append(f"FROM {base_image}")
+            base_image_updated = True
+            last_instruction = "FROM"
+            continue
+
+        if (
+            stripped.startswith("CMD")
+            and not cmd_found
+            and not web_interface_env_exists
+            and enable_interface
+            and not is_healthcheck_continuation
+        ):
+            new_lines.append("ENV ENABLE_WEB_INTERFACE=true")
+            cmd_found = True
+
+        new_lines.append(line)
+
+        if current_instruction:
+            last_instruction = current_instruction
+
+    if not cmd_found and not web_interface_env_exists and enable_interface:
+        new_lines.append("ENV ENABLE_WEB_INTERFACE=true")
+
+    if base_image and not base_image_updated:
+        new_lines.insert(0, f"FROM {base_image}")
+
+    changes = []
+    if base_image and base_image_updated:
+        changes.append("updated base image")
+    if enable_interface and not web_interface_env_exists:
+        changes.append("enabled web interface")
+
+    return "\n".join(new_lines), changes
+
+
 def _get_hf_username() -> str:
     """Return the authenticated Hugging Face username from whoami()."""
     username = _extract_hf_username(whoami())
@@ -323,55 +381,12 @@ def _prepare_staging_directory(
     # Modify Dockerfile to optionally enable web interface and update base image
     if dockerfile_path and dockerfile_path.exists():
         dockerfile_content = dockerfile_path.read_text()
-        lines = dockerfile_content.split("\n")
-        new_lines = []
-        cmd_found = False
-        base_image_updated = False
-        web_interface_env_exists = "ENABLE_WEB_INTERFACE" in dockerfile_content
-        last_instruction = None
-
-        for line in lines:
-            stripped = line.strip()
-            token = stripped.split(maxsplit=1)[0] if stripped else ""
-            current_instruction = token.upper()
-
-            is_healthcheck_continuation = last_instruction == "HEALTHCHECK"
-
-            # Update base image if specified
-            if base_image and stripped.startswith("FROM") and not base_image_updated:
-                new_lines.append(f"FROM {base_image}")
-                base_image_updated = True
-                last_instruction = "FROM"
-                continue
-
-            if (
-                stripped.startswith("CMD")
-                and not cmd_found
-                and not web_interface_env_exists
-                and enable_interface
-                and not is_healthcheck_continuation
-            ):
-                new_lines.append("ENV ENABLE_WEB_INTERFACE=true")
-                cmd_found = True
-
-            new_lines.append(line)
-
-            if current_instruction:
-                last_instruction = current_instruction
-
-        if not cmd_found and not web_interface_env_exists and enable_interface:
-            new_lines.append("ENV ENABLE_WEB_INTERFACE=true")
-
-        if base_image and not base_image_updated:
-            new_lines.insert(0, f"FROM {base_image}")
-
-        dockerfile_path.write_text("\n".join(new_lines))
-
-        changes = []
-        if base_image and base_image_updated:
-            changes.append("updated base image")
-        if enable_interface and not web_interface_env_exists:
-            changes.append("enabled web interface")
+        dockerfile_content, changes = _rewrite_dockerfile_for_space(
+            dockerfile_content,
+            base_image=base_image,
+            enable_interface=enable_interface,
+        )
+        dockerfile_path.write_text(dockerfile_content)
         if changes:
             console.print(
                 f"[bold green]✓[/bold green] Updated Dockerfile: {', '.join(changes)}"
@@ -406,8 +421,8 @@ def _prepare_staging_directory(
                     frontmatter = f"""---
 title: {env_name.replace("_", " ").title()} Environment Server
 emoji: 🔊
-colorFrom: '#00C9FF'
-colorTo: '#1B2845'
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
 app_port: 8000

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/importers/base.py

@@ -257,6 +257,42 @@ class DetectedEnvironment:
         return f"{self.module_path}:{self.class_name}"
 
 
+@dataclass(frozen=True)
+class ImportPackageContext:
+    """Shared details produced while scaffolding an imported environment package."""
+
+    class_name_prefix: str
+    vendor_dir: str
+
+
+def prepare_import_package(
+    source: Path, destination: Path, env_name: str
+) -> ImportPackageContext:
+    from openenv.cli.commands.init import (
+        _copy_template_directory,
+        _create_template_replacements,
+    )
+
+    replacements = _create_template_replacements(env_name)
+    _copy_template_directory(
+        "openenv.cli.templates.openenv_env",
+        "",
+        destination,
+        replacements,
+        env_name,
+    )
+
+    vendor_dir = safe_vendor_dir_name(source)
+    vendor_path = destination / "vendor" / vendor_dir
+    copy_source_tree(source, vendor_path)
+    ensure_vendor_package(vendor_path)
+
+    return ImportPackageContext(
+        class_name_prefix=replacements["__ENV_CLASS_NAME__"],
+        vendor_dir=vendor_dir,
+    )
+
+
 class EnvironmentImporter(Protocol):
     source_type: str
 

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/importers/ors.py

@@ -8,13 +8,11 @@ from pathlib import Path
 from .base import (
     append_dependency_files,
     collect_source_dependencies,
-    copy_source_tree,
     DetectedEnvironment,
-    ensure_vendor_package,
     iter_python_files,
     module_path,
+    prepare_import_package,
     render_importer_template,
-    safe_vendor_dir_name,
     write_text,
 )
 
@@ -209,39 +207,20 @@ class ORSImporter:
         env_name: str,
         detected: DetectedEnvironment,
     ) -> None:
-        from openenv.cli.commands.init import (
-            _copy_template_directory,
-            _create_template_replacements,
-        )
-
-        replacements = _create_template_replacements(env_name)
-        _copy_template_directory(
-            "openenv.cli.templates.openenv_env",
-            "",
-            destination,
-            replacements,
-            env_name,
-        )
-
-        vendor_dir = safe_vendor_dir_name(source)
-        vendor_path = destination / "vendor" / vendor_dir
-        copy_source_tree(source, vendor_path)
-        ensure_vendor_package(vendor_path)
-
-        prefix = replacements["__ENV_CLASS_NAME__"]
+        package = prepare_import_package(source, destination, env_name)
         write_text(
             destination / "server" / f"{env_name}_environment.py",
             _wrapper_source(
                 env_name=env_name,
-                class_name_prefix=prefix,
+                class_name_prefix=package.class_name_prefix,
                 source_module=detected.module_path,
                 source_class=detected.class_name,
-                vendor_dir=vendor_dir,
+                vendor_dir=package.vendor_dir,
             ),
         )
         write_text(
             destination / "server" / "app.py",
-            _app_source(env_name=env_name, class_name_prefix=prefix),
+            _app_source(env_name=env_name, class_name_prefix=package.class_name_prefix),
         )
         dependencies = collect_source_dependencies(source)
         for dependency in detect_ors_dependencies(source):

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/importers/verifiers.py

@@ -8,13 +8,11 @@ from pathlib import Path
 from .base import (
     append_dependency_files,
     collect_source_dependencies,
-    copy_source_tree,
     DetectedEnvironment,
-    ensure_vendor_package,
     iter_python_files,
     module_path,
+    prepare_import_package,
     render_importer_template,
-    safe_vendor_dir_name,
     write_text,
 )
 
@@ -110,38 +108,19 @@ class VerifiersImporter:
         env_name: str,
         detected: DetectedEnvironment,
     ) -> None:
-        from openenv.cli.commands.init import (
-            _copy_template_directory,
-            _create_template_replacements,
-        )
-
-        replacements = _create_template_replacements(env_name)
-        _copy_template_directory(
-            "openenv.cli.templates.openenv_env",
-            "",
-            destination,
-            replacements,
-            env_name,
-        )
-
-        vendor_dir = safe_vendor_dir_name(source)
-        vendor_path = destination / "vendor" / vendor_dir
-        copy_source_tree(source, vendor_path)
-        ensure_vendor_package(vendor_path)
-
-        prefix = replacements["__ENV_CLASS_NAME__"]
+        package = prepare_import_package(source, destination, env_name)
         write_text(
             destination / "server" / f"{env_name}_environment.py",
             _wrapper_source(
                 env_name=env_name,
-                class_name_prefix=prefix,
+                class_name_prefix=package.class_name_prefix,
                 source_module=detected.module_path,
-                vendor_dir=vendor_dir,
+                vendor_dir=package.vendor_dir,
             ),
         )
         write_text(
             destination / "server" / "app.py",
-            _app_source(env_name=env_name, class_name_prefix=prefix),
+            _app_source(env_name=env_name, class_name_prefix=package.class_name_prefix),
         )
         dependencies = collect_source_dependencies(source)
         if "verifiers>=0.1.14" not in dependencies:

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/templates/openenv_env/README.md

@@ -23,8 +23,8 @@ The simplest way to use the __ENV_TITLE_NAME__ environment is through the `__ENV
 from __ENV_NAME__ import __ENV_CLASS_NAME__Action, __ENV_CLASS_NAME__Env
 
 try:
-    # Create environment from Docker image
-    __ENV_NAME__env = __ENV_CLASS_NAME__Env.from_docker_image("__ENV_NAME__-env:latest")
+    # Create environment from Docker image (.sync() for synchronous use)
+    __ENV_NAME__env = __ENV_CLASS_NAME__Env.from_docker_image("__ENV_NAME__-env:latest").sync()
 
     # Reset
     result = __ENV_NAME__env.reset()

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/cli/templates/openenv_env/client.py

@@ -31,8 +31,8 @@ class __ENV_CLASS_NAME__Env(
         ...     print(result.observation.echoed_message)
 
     Example with Docker:
-        >>> # Automatically start container and connect
-        >>> client = __ENV_CLASS_NAME__Env.from_docker_image("__ENV_NAME__-env:latest")
+        >>> # Automatically start container and connect (.sync() for sync use)
+        >>> client = __ENV_CLASS_NAME__Env.from_docker_image("__ENV_NAME__-env:latest").sync()
         >>> try:
         ...     result = client.reset()
         ...     result = client.step(__ENV_CLASS_NAME__Action(message="Test"))

openenv-0.4.2/src/openenv/core/containers/runtime/_server_config.py

@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Shared helpers for reading environment server configuration."""
+
+from __future__ import annotations
+
+import json
+import re
+
+import yaml
+
+
+def parse_openenv_app_field(yaml_content: str) -> str | None:
+    """Extract the top-level ``app`` value from raw ``openenv.yaml`` content."""
+    try:
+        data = yaml.safe_load(yaml_content) or {}
+    except Exception:
+        return None
+
+    if not isinstance(data, dict):
+        return None
+
+    value = data.get("app")
+    if isinstance(value, str):
+        value = value.strip()
+        return value if value else None
+    return None
+
+
+def parse_dockerfile_cmd(dockerfile_content: str) -> str | None:
+    """Extract the server command from the last Dockerfile ``CMD``."""
+    last_cmd: str | None = None
+    for line in dockerfile_content.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("#"):
+            continue
+        match = re.match(r"CMD\s+(.+)", stripped, flags=re.IGNORECASE)
+        if match:
+            last_cmd = match.group(1).strip()
+
+    if last_cmd is None:
+        return None
+
+    if last_cmd.startswith("["):
+        try:
+            parts = json.loads(last_cmd)
+            if isinstance(parts, list) and all(isinstance(p, str) for p in parts):
+                return " ".join(parts)
+        except (json.JSONDecodeError, TypeError):
+            # Invalid exec-form JSON falls back to the raw CMD below.
+            pass
+
+    return last_cmd if last_cmd else None

{openenv-0.4.1 → openenv-0.4.2}/src/openenv/core/containers/runtime/daytona_provider.py

@@ -8,14 +8,12 @@ Requires the ``daytona`` SDK: ``pip install daytona>=0.10``
 
 from __future__ import annotations
 
-import json
 import os
 import shlex
 import time
 from typing import Any, Callable, Dict, Optional
 
-import yaml
-
+from ._server_config import parse_dockerfile_cmd, parse_openenv_app_field
 from .providers import ContainerProvider
 
 
@@ -149,19 +147,7 @@ class DaytonaProvider(ContainerProvider):
 
         Uses PyYAML to handle comments, quotes, and nested keys correctly.
         """
-        try:
-            data = yaml.safe_load(yaml_content) or {}
-        except Exception:
-            return None
-
-        if not isinstance(data, dict):
-            return None
-
-        value = data.get("app")
-        if isinstance(value, str):
-            value = value.strip()
-            return value if value else None
-        return None
+        return parse_openenv_app_field(yaml_content)
 
     @staticmethod
     def _parse_dockerfile_cmd(dockerfile_content: str) -> Optional[str]:
@@ -176,32 +162,7 @@ class DaytonaProvider(ContainerProvider):
         Returns:
             The command as a single string, or ``None`` if no ``CMD`` found.
         """
-        import re
-
-        last_cmd: Optional[str] = None
-        for line in dockerfile_content.splitlines():
-            stripped = line.strip()
-            # Skip comments
-            if stripped.startswith("#"):
-                continue
-            match = re.match(r"CMD\s+(.+)", stripped, flags=re.IGNORECASE)
-            if match:
-                last_cmd = match.group(1).strip()
-
-        if last_cmd is None:
-            return None
-
-        # Exec form: CMD ["executable", "param1", ...]
-        if last_cmd.startswith("["):
-            try:
-                parts = json.loads(last_cmd)
-                if isinstance(parts, list) and all(isinstance(p, str) for p in parts):
-                    return " ".join(parts)
-            except (json.JSONDecodeError, TypeError):
-                pass
-
-        # Shell form: CMD executable param1 ...
-        return last_cmd if last_cmd else None
+        return parse_dockerfile_cmd(dockerfile_content)
 
     @staticmethod
     def strip_buildkit_syntax(dockerfile_content: str) -> str: