openenv 0.4.0__tar.gz → 0.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openenv
-Version: 0.4.0
+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
@@ -305,6 +305,7 @@ See example scripts in `examples/` directory.
 The OpenEnv CLI provides commands to manage environments:
 
 - **`openenv init <env_name>`** - Initialize a new environment from template
+- **`openenv import <source> --name <env_name> --output-dir <dir>`** - Wrap a supported third-party source environment, including ORS/OpenReward and Verifiers, as OpenEnv
 - **`openenv push [--repo-id <repo>] [--private]`** - Deploy environment to Hugging Face Spaces
 - **`openenv serve`** - Serve an environment locally with optional auto-reload
 - **`openenv build`** - Build the Docker image for an environment
@@ -317,6 +318,9 @@ The OpenEnv CLI provides commands to manage environments:
 # Create a new environment
 openenv init my_game_env
 
+# Or import an ORS/OpenReward or Verifiers source environment
+openenv import path/to/source --name my_game_env --output-dir .
+
 # Deploy to Hugging Face (will prompt for login if needed)
 cd my_game_env
 openenv push

{openenv-0.4.0 → openenv-0.4.2}/README.md

@@ -268,6 +268,7 @@ See example scripts in `examples/` directory.
 The OpenEnv CLI provides commands to manage environments:
 
 - **`openenv init <env_name>`** - Initialize a new environment from template
+- **`openenv import <source> --name <env_name> --output-dir <dir>`** - Wrap a supported third-party source environment, including ORS/OpenReward and Verifiers, as OpenEnv
 - **`openenv push [--repo-id <repo>] [--private]`** - Deploy environment to Hugging Face Spaces
 - **`openenv serve`** - Serve an environment locally with optional auto-reload
 - **`openenv build`** - Build the Docker image for an environment
@@ -280,6 +281,9 @@ The OpenEnv CLI provides commands to manage environments:
 # Create a new environment
 openenv init my_game_env
 
+# Or import an ORS/OpenReward or Verifiers source environment
+openenv import path/to/source --name my_game_env --output-dir .
+
 # Deploy to Hugging Face (will prompt for login if needed)
 cd my_game_env
 openenv push

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openenv"
-version = "0.4.0"
+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",
@@ -65,6 +65,7 @@ include-package-data = true
 
 [tool.setuptools.package-data]
 "openenv.cli" = ["templates/**/*"]
+"openenv.cli.importers" = ["templates/**/*"]
 
 [tool.setuptools.exclude-package-data]
 "*" = ["*.pyc", "*.pyo", "__pycache__/*"]

{openenv-0.4.0 → openenv-0.4.2}/src/openenv/cli/__main__.py

@@ -14,6 +14,7 @@ from openenv.cli.commands import (
     build,
     collect,
     fork,
+    import_env,
     init,
     push,
     serve,
@@ -30,6 +31,9 @@ app = typer.Typer(
 
 # Register commands
 app.command(name="init", help="Initialize a new OpenEnv environment")(init.init)
+app.command(name="import", help="Import a third-party environment into OpenEnv")(
+    import_env.import_env
+)
 app.command(name="build", help="Build Docker images for OpenEnv environments")(
     build.build
 )

openenv-0.4.2/src/openenv/cli/commands/__init__.py

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""OpenEnv CLI commands."""
+
+from . import build, fork, import_env, init, push, serve, skills, validate
+
+__all__ = [
+    "build",
+    "fork",
+    "import_env",
+    "init",
+    "push",
+    "serve",
+    "skills",
+    "validate",
+]

{openenv-0.4.0 → 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.0 → 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.2/src/openenv/cli/commands/import_env.py

@@ -0,0 +1,145 @@
+"""Import third-party environments into OpenEnv wrappers."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from openenv.cli.importers import DEFAULT_IMPORTERS, ImporterRegistry
+
+from .._cli_utils import console
+from .init import _generate_uv_lock, _validate_env_name
+
+
+def _select_match(
+    registry: ImporterRegistry,
+    source: Path,
+    source_type: str | None,
+    env_class: str | None,
+):
+    try:
+        matches = registry.detect(source, source_type=source_type)
+    except ValueError as e:
+        raise typer.BadParameter(str(e)) from e
+    if not matches:
+        supported = ", ".join(registry.supported_types)
+        raise typer.BadParameter(
+            f"No supported environment found in {source}. Supported source types: {supported}."
+        )
+
+    if env_class:
+        matches = [
+            match
+            for match in matches
+            if match[1].class_name == env_class or match[1].qualified_name == env_class
+        ]
+        if not matches:
+            raise typer.BadParameter(f"No detected environment matched {env_class!r}.")
+
+    detected_types = {importer.source_type for importer, _ in matches}
+    if source_type is None and len(detected_types) > 1:
+        raise typer.BadParameter(
+            "Multiple source formats were detected. Re-run with --type "
+            f"({'/'.join(sorted(detected_types))})."
+        )
+
+    if len(matches) > 1:
+        choices = ", ".join(detected.qualified_name for _, detected in matches)
+        raise typer.BadParameter(
+            f"Multiple environment entrypoints were detected ({choices}). "
+            "Re-run with --env-class."
+        )
+
+    return matches[0]
+
+
+def import_env(
+    source: Annotated[
+        str,
+        typer.Argument(help="Local source repository or directory to import"),
+    ],
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name for the generated OpenEnv package"),
+    ],
+    output_dir: Annotated[
+        str,
+        typer.Option(
+            "--output-dir",
+            "-o",
+            help="Directory where the generated package will be created",
+        ),
+    ],
+    env_class: Annotated[
+        str | None,
+        typer.Option(
+            "--env-class",
+            help="Environment class name or module:Class when detection is ambiguous",
+        ),
+    ] = None,
+    source_type: Annotated[
+        str | None,
+        typer.Option(
+            "--type",
+            help="Optional source type override, such as 'ors'",
+        ),
+    ] = None,
+) -> None:
+    """Deterministically import a third-party environment into OpenEnv."""
+    env_name = _validate_env_name(name)
+    source_path = Path(source).expanduser().resolve()
+    if not source_path.exists() or not source_path.is_dir():
+        raise typer.BadParameter(f"Source must be an existing directory: {source_path}")
+
+    base_dir = Path(output_dir).expanduser().resolve()
+    env_dir = base_dir / env_name
+    try:
+        env_dir.relative_to(source_path)
+    except ValueError:
+        pass
+    else:
+        raise typer.BadParameter("Output directory must not be inside the source tree")
+
+    if env_dir.exists():
+        if env_dir.is_file():
+            raise typer.BadParameter(f"Path '{env_dir}' exists and is a file")
+        if any(env_dir.iterdir()):
+            raise typer.BadParameter(
+                f"Directory '{env_dir}' already exists and is not empty."
+            )
+
+    registry = ImporterRegistry(DEFAULT_IMPORTERS)
+    importer, detected = _select_match(
+        registry,
+        source_path,
+        source_type=source_type,
+        env_class=env_class,
+    )
+
+    try:
+        env_dir.mkdir(parents=True, exist_ok=True)
+        console.print(
+            "[bold cyan]Importing environment[/bold cyan] "
+            f"{detected.qualified_name} as '{env_name}' ({importer.source_type})"
+        )
+        importer.generate(
+            source=source_path,
+            destination=env_dir,
+            env_name=env_name,
+            detected=detected,
+        )
+
+        console.print("[bold green]OK[/bold green] Generated OpenEnv wrapper")
+        if _generate_uv_lock(env_dir):
+            console.print("[green]OK[/green] Generated uv.lock")
+        else:
+            console.print("[yellow]Warning:[/yellow] Could not generate uv.lock")
+
+        console.print(f"[bold green]Environment created at: {env_dir}[/bold green]")
+    except Exception as e:
+        if env_dir.exists() and env_dir.is_dir():
+            shutil.rmtree(env_dir, ignore_errors=True)
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(1) from e

{openenv-0.4.0 → 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.0 → 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.0 → openenv-0.4.2}/src/openenv/cli/commands/serve.py

@@ -87,4 +87,4 @@ def serve(
         console.print("  From an environment directory with pyproject.toml:")
         console.print(f"     [dim]$ uv run --project . server --port {port}[/dim]\n")
 
-    raise typer.Exit(0)
+    raise typer.Exit(1)

openenv-0.4.2/src/openenv/cli/importers/__init__.py

@@ -0,0 +1,16 @@
+"""Deterministic source importers for OpenEnv environments."""
+
+from .base import DetectedEnvironment, EnvironmentImporter, ImporterRegistry
+from .ors import ORSImporter
+from .verifiers import VerifiersImporter
+
+DEFAULT_IMPORTERS = [ORSImporter(), VerifiersImporter()]
+
+__all__ = [
+    "DEFAULT_IMPORTERS",
+    "DetectedEnvironment",
+    "EnvironmentImporter",
+    "ImporterRegistry",
+    "ORSImporter",
+    "VerifiersImporter",
+]