cogames 0.3.68__py3-none-any.whl → 0.3.69__py3-none-any.whl

cogames/cli/submit.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import shutil
 import subprocess
+import sys
 import tempfile
 import uuid
 import zipfile
@@ -13,24 +14,19 @@ from pathlib import Path
 
 import httpx
 import typer
-from rich.console import Console
 
 from cogames.cli.base import console
 from cogames.cli.client import TournamentServerClient
 from cogames.cli.login import DEFAULT_COGAMES_SERVER
-from cogames.cli.mission import get_mission
-from cogames.cli.policy import PolicySpec, get_policy_spec, parse_policy_spec
+from cogames.cli.policy import PolicySpec, get_policy_spec
 from mettagrid.config.mettagrid_config import MettaGridConfig
-from mettagrid.policy.prepare_policy_spec import download_policy_spec_from_s3_as_zip
 from mettagrid.policy.submission import POLICY_SPEC_FILENAME, SubmissionPolicySpec
-from mettagrid.runner.rollout import run_episode_local
-from mettagrid.util.uri_resolvers.schemes import parse_uri, resolve_uri
+from mettagrid.runner.episode_runner import run_episode_isolated
+from mettagrid.runner.types import EpisodeSpec
+from mettagrid.util.uri_resolvers.schemes import localize_uri, parse_uri
 
 DEFAULT_SUBMIT_SERVER = "https://api.observatory.softmax-research.net"
-
-
-def results_url_for_season(_server: str, _season: str) -> str:
-    return "https://www.softmax.com/alignmentleague"
+RESULTS_URL = "https://www.softmax.com/alignmentleague"
 
 
 @dataclass
@@ -41,303 +37,35 @@ class UploadResult:
     pools: list[str] | None = None
 
 
-def validate_paths(paths: list[str], console: Console) -> list[Path]:
-    """Validate paths are within CWD and return them as relative paths."""
+def _resolve_path_within_cwd(path_str: str, cwd: Path) -> Path:
+    """Resolve a path and return it relative to CWD. Raises if path escapes CWD."""
+    raw_path = Path(path_str).expanduser()
+    resolved = raw_path.resolve() if raw_path.is_absolute() else (cwd / raw_path).resolve()
+    if not resolved.is_relative_to(cwd):
+        console.print(f"[red]Error:[/red] Path must be within the current directory: {path_str}")
+        raise ValueError(f"Path escapes CWD: {path_str}")
+    return resolved.relative_to(cwd)
+
+
+def validate_paths(paths: list[str]) -> list[Path]:
+    """Validate paths exist and are within CWD, return them as relative paths."""
     cwd = Path.cwd().resolve()
     validated_paths = []
-
     for path_str in paths:
-        raw_path = Path(path_str).expanduser()
-
-        # Resolve the path and check it's within CWD
-        resolved = raw_path.resolve() if raw_path.is_absolute() else (cwd / raw_path).resolve()
-        if not resolved.is_relative_to(cwd):
-            console.print(f"[red]Error:[/red] Path must be within the current directory: {path_str}")
-            raise ValueError(f"Path escapes CWD: {path_str}")
-        relative = resolved.relative_to(cwd)
-
-        # Check if path exists
+        relative = _resolve_path_within_cwd(path_str, cwd)
+        resolved = cwd / relative
         if not resolved.exists():
             console.print(f"[red]Error:[/red] Path does not exist: {path_str}")
             raise FileNotFoundError(f"Path not found: {path_str}")
-
         validated_paths.append(relative)
-
     return validated_paths
 
 
-def _maybe_resolve_checkpoint_bundle_uri(policy: str) -> tuple[Path, bool] | None:
-    """Return (local_zip_path, cleanup) if policy points to a checkpoint bundle URI."""
-    first = policy.split(",", 1)[0].strip()
-    parsed = parse_uri(first, allow_none=True, default_scheme=None)
-    if parsed is None or parsed.scheme not in {"file", "s3"}:
-        return None
-
-    resolved = resolve_uri(first)
-    if resolved.scheme == "s3":
-        if not resolved.canonical.endswith(".zip"):
-            raise ValueError("S3 policy specs must be .zip bundles.")
-        return download_policy_spec_from_s3_as_zip(resolved.canonical), False
-
-    local_path = resolved.local_path
-    if local_path is None:
-        raise ValueError(f"Cannot resolve local path for URI: {policy}")
-    if not local_path.exists():
-        raise FileNotFoundError(f"Bundle path not found: {local_path}")
-    if local_path.is_dir():
-        return _zip_directory_bundle(local_path), True
-    if local_path.suffix == ".zip":
-        return local_path, False
-    raise ValueError("Checkpoint bundle must be a directory or .zip file.")
-
-
-def _zip_directory_bundle(bundle_dir: Path) -> Path:
-    zip_fd, zip_path = tempfile.mkstemp(suffix=".zip", prefix="cogames_bundle_")
-    os.close(zip_fd)
-
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
-        for file_path in bundle_dir.rglob("*"):
+def _zip_directory_to(src: Path, dest: Path) -> None:
+    with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as zipf:
+        for file_path in src.rglob("*"):
             if file_path.is_file():
-                zipf.write(file_path, arcname=file_path.relative_to(bundle_dir))
-
-    return Path(zip_path)
-
-
-def validate_bundle_in_isolation(policy_zip: Path, console: Console, *, season: str, server: str) -> bool:
-    console.print("[dim]Testing policy bundle can run 10 steps...[/dim]")
-
-    temp_dir = create_temp_validation_env()
-    try:
-        bundle_name = policy_zip.name
-        shutil.copy2(policy_zip, temp_dir / bundle_name)
-
-        env = os.environ.copy()
-        env["UV_NO_CACHE"] = "1"
-
-        res = subprocess.run(
-            [
-                "uv",
-                "run",
-                "cogames",
-                "validate-policy",
-                "--season",
-                season,
-                "--server",
-                server,
-                "--policy",
-                f"file://./{bundle_name}",
-            ],
-            cwd=temp_dir,
-            capture_output=True,
-            text=True,
-            timeout=300,
-            env=env,
-        )
-        if res.returncode != 0:
-            console.print("[red]Validation failed[/red]")
-            console.print(f"\n[red]Error:[/red]\n{res.stderr}")
-            if res.stdout:
-                console.print(f"\n[dim]Output:[/dim]\n{res.stdout}")
-            return False
-
-        console.print("[green]Validation passed[/green]")
-        return True
-    finally:
-        if temp_dir.exists():
-            shutil.rmtree(temp_dir)
-
-
-def get_latest_pypi_version(package: str) -> str:
-    """Get the latest published version of a package from PyPI."""
-    response = httpx.get(f"https://pypi.org/pypi/{package}/json")
-    response.raise_for_status()
-    return response.json()["info"]["version"]
-
-
-def get_pypi_requires_python(package: str) -> str:
-    """Get the requires_python constraint from PyPI."""
-    response = httpx.get(f"https://pypi.org/pypi/{package}/json")
-    response.raise_for_status()
-    return response.json()["info"]["requires_python"]
-
-
-def create_temp_validation_env() -> Path:
-    """Create a temporary directory with a minimal pyproject.toml.
-
-    The pyproject.toml depends on the latest published cogames and cogames-agents packages.
-    Python version is constrained to match mettagrid's published wheels.
-    """
-    temp_dir = Path(tempfile.mkdtemp(prefix="cogames_submit_"))
-
-    latest_cogames_version = get_latest_pypi_version("cogames")
-    latest_agents_version = get_latest_pypi_version("cogames-agents")
-    mettagrid_requires_python = get_pypi_requires_python("mettagrid")
-
-    pyproject_content = f"""[project]
-name = "cogames-submission-validator"
-version = "0.1.0"
-requires-python = "{mettagrid_requires_python}"
-dependencies = ["cogames=={latest_cogames_version}", "cogames-agents=={latest_agents_version}"]
-
-[build-system]
-requires = ["setuptools>=42"]
-build-backend = "setuptools.build_meta"
-"""
-
-    pyproject_path = temp_dir / "pyproject.toml"
-    pyproject_path.write_text(pyproject_content)
-
-    return temp_dir
-
-
-def copy_files_maintaining_structure(files: list[Path], dest_dir: Path) -> None:
-    """Copy files to destination, maintaining directory structure.
-
-    If a file is 'train_dir/model.pt', it will be copied to 'dest_dir/train_dir/model.pt'.
-    """
-    for file_path in files:
-        dest_path = dest_dir / file_path
-
-        if file_path.is_dir():
-            shutil.copytree(file_path, dest_path, dirs_exist_ok=True)
-        else:
-            dest_path.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(file_path, dest_path)
-
-
-_SEASON_VALIDATION_MISSIONS: dict[str, str] = {
-    "beta": "training_facility.harvest",
-    "beta-cogsguard": "cogsguard_arena.basic",
-}
-_DEFAULT_VALIDATION_MISSION = "cogsguard_arena.basic"
-
-
-def get_validation_mission_for_season(season: str | None = None) -> str:
-    """Get the appropriate mission for validating policies in a given season."""
-    if season is None:
-        return _DEFAULT_VALIDATION_MISSION
-    return _SEASON_VALIDATION_MISSIONS.get(season, _DEFAULT_VALIDATION_MISSION)
-
-
-def validate_policy_spec(
-    policy_spec: PolicySpec,
-    env_cfg: MettaGridConfig | None = None,
-    *,
-    device: str = "cpu",
-    season: str | None = None,
-) -> None:
-    """Validate policy works.
-
-    Runs a single episode (up to 10 steps) using the same alo rollout flow as `cogames eval`.
-
-    Args:
-        policy_spec: The policy to validate.
-        env_cfg: Optional environment config to validate against.
-        device: Target device for policy evaluation (cpu/cuda/auto).
-        season: Optional season name to determine which game to validate against.
-    """
-    if env_cfg is None:
-        mission_name = get_validation_mission_for_season(season)
-        # Legacy seasons (e.g., "beta") use legacy missions that require include_legacy=True
-        include_legacy = season in _SEASON_VALIDATION_MISSIONS
-        _, env_cfg, _ = get_mission(mission_name, include_legacy=include_legacy)
-    else:
-        env_cfg = env_cfg.model_copy()
-
-    # Run 1 episode for up to 10 steps to validate the policy works
-    env_cfg.game.max_steps = 10
-    n = env_cfg.game.num_agents
-    n_submitted = min(2, n)
-    noop_spec = PolicySpec(class_path="mettagrid.policy.noop.NoopPolicy")
-    if n_submitted < n:
-        policy_specs = [policy_spec, noop_spec]
-        assignments = [0] * n_submitted + [1] * (n - n_submitted)
-    else:
-        policy_specs = [policy_spec]
-        assignments = [0] * n
-    run_episode_local(
-        policy_specs=policy_specs,
-        assignments=assignments,
-        env=env_cfg,
-        seed=42,
-        max_action_time_ms=10000,
-        device=device,
-    )
-
-
-def validate_policy_uri(policy_uri: str, env_cfg: MettaGridConfig, *, device: str = "cpu") -> None:
-    policy_spec = parse_policy_spec(policy_uri, device=device).to_policy_spec()
-    validate_policy_spec(policy_spec, env_cfg, device=device)
-
-
-def validate_policy_in_isolation(
-    policy_spec: PolicySpec,
-    include_files: list[Path],
-    console: Console,
-    setup_script: str | None = None,
-    *,
-    season: str,
-    server: str,
-) -> bool:
-    def _format_policy_arg(spec: PolicySpec) -> str:
-        parts = [f"class={spec.class_path}"]
-        if spec.data_path:
-            parts.append(f"data={spec.data_path}")
-        for key, value in spec.init_kwargs.items():
-            parts.append(f"kw.{key}={value}")
-        return ",".join(parts)
-
-    console.print("[dim]Testing policy can run 10 steps...[/dim]")
-
-    temp_dir = create_temp_validation_env()
-    try:
-        copy_files_maintaining_structure(include_files, temp_dir)
-
-        policy_arg = _format_policy_arg(policy_spec)
-
-        def _run_from_tmp_dir(cmd: list[str]) -> subprocess.CompletedProcess[str]:
-            env = os.environ.copy()
-            env["UV_NO_CACHE"] = "1"
-            res = subprocess.run(
-                cmd,
-                cwd=temp_dir,
-                capture_output=True,
-                text=True,
-                timeout=300,
-                env=env,
-            )
-            if not res.returncode == 0:
-                console.print("[red]Validation failed[/red]")
-                console.print(f"\n[red]Error:[/red]\n{res.stderr}")
-                if res.stdout:
-                    console.print(f"\n[dim]Output:[/dim]\n{res.stdout}")
-                raise Exception("Validation failed")
-            return res
-
-        _run_from_tmp_dir(["uv", "run", "cogames", "version"])
-
-        validate_cmd = [
-            "uv",
-            "run",
-            "cogames",
-            "validate-policy",
-            "--policy",
-            policy_arg,
-            "--season",
-            season,
-            "--server",
-            server,
-        ]
-        if setup_script:
-            validate_cmd.extend(["--setup-script", setup_script])
-
-        _run_from_tmp_dir(validate_cmd)
-
-        console.print("[green]Validation passed[/green]")
-        return True
-    finally:
-        if temp_dir.exists():
-            shutil.rmtree(temp_dir)
+                zipf.write(file_path, arcname=file_path.relative_to(src))
 
 
 def _collect_ancestor_init_files(include_files: list[Path]) -> list[Path]:
@@ -392,11 +120,105 @@ def create_submission_zip(
     return Path(zip_path)
 
 
+def create_bundle(
+    ctx: typer.Context,
+    policy: str,
+    output: Path,
+    include_files: list[str] | None = None,
+    init_kwargs: dict[str, str] | None = None,
+    setup_script: str | None = None,
+) -> Path:
+    # TODO: Unify the two paths below. For URI inputs, extract the PolicySpec from the
+    # bundle so we can apply init_kwargs/include_files/setup_script, then re-zip.
+    local = localize_uri(policy) if parse_uri(policy, allow_none=True, default_scheme=None) else None
+    if local is not None:
+        if init_kwargs or include_files or setup_script:
+            console.print("[red]Error:[/red] Extra files/kwargs are not supported with bundle URIs.")
+            raise typer.Exit(1)
+        console.print(f"[dim]Packaging existing bundle: {local}[/dim]")
+        if local.is_dir():
+            _zip_directory_to(local, output)
+        else:
+            shutil.copy2(local, output)
+        console.print(f"[dim]Bundle size: {output.stat().st_size / 1024:.0f} KB[/dim]")
+        return output
+
+    policy_spec = get_policy_spec(ctx, policy)
+    console.print(f"[dim]Policy class: {policy_spec.class_path}[/dim]")
+
+    if init_kwargs:
+        merged_kwargs = {**policy_spec.init_kwargs, **init_kwargs}
+        policy_spec = PolicySpec(
+            class_path=policy_spec.class_path,
+            data_path=policy_spec.data_path,
+            init_kwargs=merged_kwargs,
+        )
+
+    if policy_spec.init_kwargs:
+        console.print(f"[dim]Init kwargs: {policy_spec.init_kwargs}[/dim]")
+
+    cwd = Path.cwd().resolve()
+    if policy_spec.data_path:
+        data_rel = str(_resolve_path_within_cwd(policy_spec.data_path, cwd))
+        policy_spec = PolicySpec(
+            class_path=policy_spec.class_path,
+            data_path=data_rel,
+            init_kwargs=policy_spec.init_kwargs,
+        )
+        console.print(f"[dim]Data path: {data_rel}[/dim]")
+
+    setup_script_rel: str | None = None
+    if setup_script:
+        setup_script_rel = str(_resolve_path_within_cwd(setup_script, cwd))
+        console.print(f"[dim]Setup script: {setup_script_rel}[/dim]")
+
+    files_to_include = []
+    if policy_spec.data_path:
+        files_to_include.append(policy_spec.data_path)
+    if setup_script_rel:
+        files_to_include.append(setup_script_rel)
+    if include_files:
+        files_to_include.extend(include_files)
+
+    validated_paths: list[Path] = []
+    if files_to_include:
+        validated_paths = validate_paths(files_to_include)
+        console.print(f"[dim]Including {len(validated_paths)} file(s)[/dim]")
+
+    tmp_zip = create_submission_zip(validated_paths, policy_spec, setup_script=setup_script_rel)
+    shutil.move(str(tmp_zip), str(output))
+    console.print(f"[dim]Bundle size: {output.stat().st_size / 1024:.0f} KB[/dim]")
+    return output
+
+
+def validate_bundle(policy_uri: str, env_cfg: MettaGridConfig) -> None:
+    """Validate a policy bundle by running a short episode in process isolation."""
+    env_cfg.game.max_steps = 10
+
+    spec = EpisodeSpec(
+        policy_uris=[policy_uri],
+        assignments=[0] * env_cfg.game.num_agents,
+        env=env_cfg,
+        seed=42,
+        max_action_time_ms=10000,
+    )
+
+    with tempfile.NamedTemporaryFile(suffix=".json", delete=True) as results_file:
+        res = run_episode_isolated(spec, Path(results_file.name))
+        console.print(f"[dim]Ran for {res.steps} steps[/dim]")
+
+        non_noop_actions = sum(
+            v for k, v in res.stats["agent"][0].items() if k.startswith("action.") and ".noop." not in k
+        )
+        if non_noop_actions == 0:
+            console.print("[yellow]Warning: Policy took no actions (all no-ops)[/yellow]")
+            raise typer.Exit(1)
+
+
 def upload_submission(
     client: TournamentServerClient,
     zip_path: Path,
     submission_name: str,
-    console: Console,
     season: str | None = None,
 ) -> UploadResult | None:
     """Upload submission to CoGames backend using a presigned S3 URL."""
@@ -443,55 +265,6 @@ def upload_submission(
         raise ValueError(f"Invalid submission ID returned: {submission_id}") from exc
 
 
-def _upload_policy_bundle(
-    bundle_result: tuple[Path, bool],
-    *,
-    client: TournamentServerClient,
-    name: str,
-    console: Console,
-    init_kwargs: dict[str, str] | None,
-    include_files: list[str] | None,
-    setup_script: str | None,
-    skip_validation: bool,
-    dry_run: bool,
-    validation_season: str,
-    server: str,
-    season: str | None = None,
-) -> UploadResult | None:
-    bundle_zip, cleanup_bundle_zip = bundle_result
-
-    try:
-        if init_kwargs or include_files or setup_script:
-            console.print("[red]Error:[/red] Extra files/kwargs are not supported when uploading a bundle URI.")
-            console.print(
-                "Upload the bundle as-is, or use a short policy name or URI with local files to "
-                "build a new submission zip."
-            )
-            return None
-
-        if not skip_validation:
-            if not validate_bundle_in_isolation(bundle_zip, console, season=validation_season, server=server):
-                console.print("\n[red]Upload aborted due to validation failure.[/red]")
-                return None
-        else:
-            console.print("[dim]Skipping validation[/dim]")
-
-        if dry_run:
-            console.print("[green]Dry run complete[/green]")
-            return None
-
-        with client:
-            result = upload_submission(client, bundle_zip, name, console, season=season)
-        if not result:
-            console.print("\n[red]Upload failed.[/red]")
-            return None
-
-        return result
-    finally:
-        if cleanup_bundle_zip and bundle_zip.exists():
-            bundle_zip.unlink()
-
-
 def upload_policy(
     ctx: typer.Context,
     policy: str,
@@ -503,7 +276,6 @@ def upload_policy(
     dry_run: bool = False,
     skip_validation: bool = False,
     setup_script: str | None = None,
-    validation_season: str = "",
     season: str | None = None,
 ) -> UploadResult | None:
     if dry_run:
@@ -513,99 +285,47 @@ def upload_policy(
     if not client:
         return None
 
-    bundle_result = _maybe_resolve_checkpoint_bundle_uri(policy)
+    with tempfile.TemporaryDirectory(prefix="cogames_bundle_") as tmp_dir:
+        zip_path = Path(tmp_dir) / "bundle.zip"
 
-    if bundle_result is not None:
-        return _upload_policy_bundle(
-            bundle_result,
-            client=client,
-            name=name,
-            console=console,
-            init_kwargs=init_kwargs,
+        create_bundle(
+            ctx=ctx,
+            policy=policy,
+            output=zip_path,
             include_files=include_files,
+            init_kwargs=init_kwargs,
             setup_script=setup_script,
-            skip_validation=skip_validation,
-            dry_run=dry_run,
-            validation_season=validation_season,
-            server=server,
-            season=season,
-        )
-
-    policy_spec = get_policy_spec(ctx, policy)
-
-    if init_kwargs:
-        merged_kwargs = {**policy_spec.init_kwargs, **init_kwargs}
-        policy_spec = PolicySpec(
-            class_path=policy_spec.class_path,
-            data_path=policy_spec.data_path,
-            init_kwargs=merged_kwargs,
         )
 
-    cwd = Path.cwd().resolve()
-    if policy_spec.data_path:
-        resolved = Path(policy_spec.data_path).expanduser().resolve()
-        if not resolved.is_relative_to(cwd):
-            console.print("[red]Error:[/red] Policy weights path must be within the current directory.")
-            console.print(f"[dim]{policy_spec.data_path}[/dim]")
-            raise ValueError("Policy weights path must be within the current directory.")
-        data_rel = str(resolved.relative_to(cwd))
-        policy_spec = PolicySpec(
-            class_path=policy_spec.class_path,
-            data_path=data_rel,
-            init_kwargs=policy_spec.init_kwargs,
-        )
-
-    setup_script_rel: str | None = None
-    if setup_script:
-        resolved = Path(setup_script).expanduser().resolve()
-        if not resolved.is_relative_to(cwd):
-            console.print("[red]Error:[/red] Setup script path must be within the current directory.")
-            console.print(f"[dim]{setup_script}[/dim]")
-            raise ValueError("Setup script path must be within the current directory.")
-        setup_script_rel = str(resolved.relative_to(cwd))
-
-    files_to_include = []
-    if policy_spec.data_path:
-        files_to_include.append(policy_spec.data_path)
-    if setup_script_rel:
-        files_to_include.append(setup_script_rel)
-    if include_files:
-        files_to_include.extend(include_files)
+        if not skip_validation:
+            cmd = [
+                sys.executable,
+                "-m",
+                "cogames",
+                "validate-bundle",
+                "--policy",
+                zip_path.as_uri(),
+                "--server",
+                server,
+            ]
+            if season:
+                cmd.extend(["--season", season])
+            result = subprocess.run(cmd, text=True, timeout=300)
+            if result.returncode != 0:
+                console.print("[red]Validation failed[/red]")
+                return None
+            console.print("[green]Validation passed[/green]")
+        else:
+            console.print("[dim]Skipping validation[/dim]")
 
-    validated_paths: list[Path] = []
-    if files_to_include:
-        validated_paths = validate_paths(files_to_include, console)
-
-    if not skip_validation:
-        if not validate_policy_in_isolation(
-            policy_spec,
-            validated_paths,
-            console,
-            setup_script=setup_script_rel,
-            season=validation_season,
-            server=server,
-        ):
-            console.print("\n[red]Upload aborted due to validation failure.[/red]")
+        if dry_run:
+            console.print("[green]Dry run complete[/green]")
             return None
-    else:
-        console.print("[dim]Skipping validation[/dim]")
-
-    zip_path = create_submission_zip(validated_paths, policy_spec, setup_script=setup_script_rel)
-
-    if dry_run:
-        console.print("[green]Dry run complete[/green]")
-        if zip_path.exists():
-            zip_path.unlink()
-        return None
 
-    try:
         with client:
-            result = upload_submission(client, zip_path, name, console, season=season)
+            result = upload_submission(client, zip_path, name, season=season)
         if not result:
             console.print("\n[red]Upload failed.[/red]")
             return None
 
         return result
-    finally:
-        if zip_path.exists():
-            zip_path.unlink()

cogames/main.py

@@ -63,7 +63,13 @@ from cogames.cli.policy import (
     policy_arg_example,
     policy_arg_w_proportion_example,
 )
-from cogames.cli.submit import DEFAULT_SUBMIT_SERVER, results_url_for_season, upload_policy, validate_policy_spec
+from cogames.cli.submit import (
+    DEFAULT_SUBMIT_SERVER,
+    RESULTS_URL,
+    create_bundle,
+    upload_policy,
+    validate_bundle,
+)
 from cogames.cogs_vs_clips.mission import CvCMission, NumCogsVariant
 from cogames.curricula import make_rotation
 from cogames.device import resolve_training_device
@@ -2228,12 +2234,12 @@ def _resolve_season(server: str, season_name: str | None = None) -> SeasonInfo:
 
 
 @app.command(
-    name="validate-policy",
-    help="Validate the policy loads and runs for at least a single step",
+    name="create-bundle",
+    help="Create a submission bundle zip from a policy",
     rich_help_panel="Policies",
     add_help_option=False,
 )
-def validate_policy_cmd(
+def create_bundle_cmd(
     ctx: typer.Context,
     policy: str = typer.Option(
         ...,
@@ -2243,18 +2249,77 @@ def validate_policy_cmd(
         help=f"Policy specification: {policy_arg_example}",
         rich_help_panel="Policy",
     ),
-    device: str = typer.Option(
-        "auto",
-        "--device",
-        metavar="DEVICE",
-        help="Policy device (auto, cpu, cuda, cuda:0, etc.)",
+    output: Path = typer.Option(  # noqa: B008
+        Path("submission.zip"),
+        "--output",
+        "-o",
+        metavar="PATH",
+        help="Output path for the bundle zip",
+        rich_help_panel="Output",
+    ),
+    init_kwarg: Optional[list[str]] = typer.Option(  # noqa: B008
+        None,
+        "--init-kwarg",
+        "-k",
+        metavar="KEY=VAL",
+        help="Policy init kwargs (can be repeated)",
         rich_help_panel="Policy",
     ),
+    include_files: Optional[list[str]] = typer.Option(  # noqa: B008
+        None,
+        "--include-files",
+        "-f",
+        metavar="PATH",
+        help="Files or directories to include (can be repeated)",
+        rich_help_panel="Files",
+    ),
     setup_script: Optional[str] = typer.Option(
         None,
         "--setup-script",
-        help="Path to a Python setup script to run before loading the policy",
-        rich_help_panel="Policy",
+        metavar="PATH",
+        help="Python setup script to include in the bundle",
+        rich_help_panel="Files",
+    ),
+    _help: bool = typer.Option(
+        False,
+        "--help",
+        "-h",
+        help="Show this message and exit",
+        is_eager=True,
+        callback=_help_callback,
+        rich_help_panel="Other",
+    ),
+) -> None:
+    init_kwargs: dict[str, str] = {}
+    if init_kwarg:
+        for kv in init_kwarg:
+            key, val = _parse_init_kwarg(kv)
+            init_kwargs[key] = val
+
+    result_path = create_bundle(
+        ctx=ctx,
+        policy=policy,
+        output=output.resolve(),
+        include_files=include_files,
+        init_kwargs=init_kwargs if init_kwargs else None,
+        setup_script=setup_script,
+    )
+    console.print(f"[green]Bundle created:[/green] {result_path}")
+
+
+@app.command(
+    name="validate-bundle",
+    help="Validate a policy bundle runs correctly in process isolation",
+    rich_help_panel="Policies",
+    add_help_option=False,
+)
+def validate_bundle_cmd(
+    policy: str = typer.Option(
+        ...,
+        "--policy",
+        "-p",
+        metavar="URI",
+        help="Bundle URI (file://, s3://, or local path to .zip or directory)",
     ),
     season: Optional[str] = typer.Option(
         None,
@@ -2289,37 +2354,8 @@ def validate_policy_cmd(
     with TournamentServerClient(server_url=server) as client:
         config_data = client.get_config(entry_pool_info.config_id)
     env_cfg = MettaGridConfig.model_validate(config_data)
+    validate_bundle(policy, env_cfg)
 
-    if setup_script:
-        import subprocess  # noqa: PLC0415
-        import sys  # noqa: PLC0415
-        from pathlib import Path  # noqa: PLC0415
-
-        script_path = Path(setup_script)
-        if not script_path.exists():
-            console.print(f"[red]Setup script not found: {setup_script}[/red]")
-            raise typer.Exit(1)
-        console.print(f"[yellow]Running setup script: {setup_script}[/yellow]")
-        result = subprocess.run(
-            [sys.executable, str(script_path)],
-            cwd=Path.cwd(),
-            capture_output=True,
-            text=True,
-            timeout=300,
-        )
-        if result.returncode != 0:
-            console.print(f"[red]Setup script failed:[/red]\n{result.stderr}")
-            raise typer.Exit(1)
-        console.print("[green]Setup script completed[/green]")
-
-    resolved_device = resolve_training_device(console, device)
-    policy_spec = get_policy_spec(ctx, policy, device=str(resolved_device))
-    validate_policy_spec(
-        policy_spec,
-        env_cfg,
-        device=str(resolved_device),
-        season=season_info.name,
-    )
     console.print("[green]Policy validated successfully[/green]")
     raise typer.Exit(0)
 
@@ -2446,11 +2482,6 @@ def upload_cmd(
 ) -> None:
     season_info = _resolve_season(server, season)
 
-    has_entry_config = any(p.config_id for p in season_info.pools if p.name == season_info.entry_pool)
-    if not has_entry_config and not skip_validation:
-        console.print("[yellow]Warning: No entry config found for season. Skipping validation.[/yellow]")
-        skip_validation = True
-
     init_kwargs: dict[str, str] = {}
     if init_kwarg:
         for kv in init_kwarg:
@@ -2468,7 +2499,6 @@ def upload_cmd(
         skip_validation=skip_validation,
         init_kwargs=init_kwargs if init_kwargs else None,
         setup_script=setup_script,
-        validation_season=season_info.name,
         season=season_info.name if not no_submit else None,
     )
 
@@ -2476,7 +2506,7 @@ def upload_cmd(
         console.print(f"[green]Upload complete: {result.name}:v{result.version}[/green]")
         if result.pools:
             console.print(f"[dim]Added to pools: {', '.join(result.pools)}[/dim]")
-            console.print(f"[dim]Results:[/dim] {results_url_for_season(server, season_info.name)}")
+            console.print(f"[dim]Results:[/dim] {RESULTS_URL}")
         elif no_submit:
             console.print(f"\nTo submit to a tournament: cogames submit {result.name}:v{result.version}")
 
@@ -2574,7 +2604,7 @@ def submit_cmd(
     console.print(f"\n[bold green]Submitted to season '{season_name}'[/bold green]")
     if result.pools:
         console.print(f"[dim]Added to pools: {', '.join(result.pools)}[/dim]")
-    console.print(f"[dim]Results:[/dim] {results_url_for_season(server, season_name)}")
+    console.print(f"[dim]Results:[/dim] {RESULTS_URL}")
     console.print(f"[dim]CLI:[/dim] cogames leaderboard --season {season_name}")
 
 

{cogames-0.3.68.dist-info → cogames-0.3.69.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: cogames
-Version: 0.3.68
+Version: 0.3.69
 Summary: Multi-agent cooperative games
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: <3.13,>=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mettagrid==0.2.0.82
+Requires-Dist: mettagrid==0.2.0.83
 Requires-Dist: packaging>=24.0.0
 Requires-Dist: pufferlib-core
 Requires-Dist: pydantic>=2.11.5

{cogames-0.3.68.dist-info → cogames-0.3.69.dist-info}/RECORD

@@ -5,7 +5,7 @@ cogames/curricula.py,sha256=a7Nd-av4epAjmoqlefyU4q5eAitpYjCEGDCF_tS_iaY,825
 cogames/device.py,sha256=GVC7g4tNVySn_rSbHJB0jGKvpYBL8-VmeYEQXWXtvy0,1680
 cogames/evaluate.py,sha256=Qc3KopiDJs4iF2qpBajQYh2-7HnFWpOk1enexVhEZPo,9358
 cogames/game.py,sha256=Qpyd4UOv97S-PCcEb422XFVbuXk46qhEx7_FlAr8ayA,3331
-cogames/main.py,sha256=yBhcgEl8__0ogMybctDwY4tVGy5lXy8WYJqzLN11pu4,90307
+cogames/main.py,sha256=Z3xRk6JCPzVLFUr1SxiNIU4oLk1V16vVLkQi4ea7_D8,90453
 cogames/pickup.py,sha256=kZUR19_2HzUK3ltc3GyglEv0kgUCPvm8feeCzC9EKDI,6578
 cogames/play.py,sha256=waSx8523tOWX8_KrcjlgV50USU90wGhYmpSCPchdJkg,7882
 cogames/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,7 +17,7 @@ cogames/cli/leaderboard.py,sha256=eIbiSBOkvoi5IL2weiKBOJAjWGHquDk1PWoHKA8uu3g,13
 cogames/cli/login.py,sha256=_i1Hdbp_wAMsX0NLbCTSr7GmOFbzSqwyNP79OqLOg40,1237
 cogames/cli/mission.py,sha256=X8vAdWz2qBKdrB4gh9xuqoRb_L39bYzdXUf9l-eGc28,22624
 cogames/cli/policy.py,sha256=v9MyddJ56lkTHJ195HyWswVqVXLyxuCI064QSerOCWg,9513
-cogames/cli/submit.py,sha256=xEGeJA00eber_SHlAB2b21VaVPwvcLCbjDABPbkAKFM,20665
+cogames/cli/submit.py,sha256=xJyBH0LS-y2q9V8l-iupnVei7CvXo4gW43VFIEu_ldk,11536
 cogames/cli/utils.py,sha256=VLTFNIAVNFPL_dUtJqLT7umE_0rrJSFdbo0kntmGmKE,1266
 cogames/cli/docsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cogames/cli/docsync/_nb_md_directive_processing.py,sha256=A920oS21mw9ZU2vp-cILzq5Sa-AMtmwMSayZKcQwX9M,6365
@@ -149,12 +149,12 @@ cogames/policy/trainable_policy_template.py,sha256=GbB4vi0wsIiuh_APtfjnavvh9ZVUx
 cogames/policy/nim_agents/__init__.py,sha256=ZMJgUljlvBoa3swAupfOyS6jF2jIwGPX-nL_T9vFmAw,1181
 cogames/policy/nim_agents/agents.py,sha256=Do9WIgeodBi99H5UfCN0MlCjosb8gxaSl2cojIbiK9o,4528
 cogames/policy/nim_agents/thinky_eval.py,sha256=NqIZng30MpyZD5hF03uoje4potd873hWyHOb3AZdeZk,1154
-cogames-0.3.68.dist-info/licenses/LICENSE,sha256=NG4hf0NHdGZhkabVCK1MKX8RAJmWaEm4eaGcUsONZ_E,1065
+cogames-0.3.69.dist-info/licenses/LICENSE,sha256=NG4hf0NHdGZhkabVCK1MKX8RAJmWaEm4eaGcUsONZ_E,1065
 metta_alo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metta_alo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metta_alo/scoring.py,sha256=PcGVUXmxh4H4BoEnkMQaxrwxf06BGTqRZVSnOTPzG9M,5875
-cogames-0.3.68.dist-info/METADATA,sha256=RD6b9CR38DP0EhBiI7TQNkncvgrqJlpASQlO04h2nO8,242101
-cogames-0.3.68.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cogames-0.3.68.dist-info/entry_points.txt,sha256=GTHdgj-RC2hQYmjUMSp9RHX8kbru19k0LS2lAj8DnLE,45
-cogames-0.3.68.dist-info/top_level.txt,sha256=YErBkYWJd3-eksLpbgbMrETni1MPBNL4mqEyhZUa0UE,18
-cogames-0.3.68.dist-info/RECORD,,
+cogames-0.3.69.dist-info/METADATA,sha256=mIF-Ot6rJWtbI39HxTGlFqG7J74EUxOh9pYQJYKsGJo,242101
+cogames-0.3.69.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cogames-0.3.69.dist-info/entry_points.txt,sha256=GTHdgj-RC2hQYmjUMSp9RHX8kbru19k0LS2lAj8DnLE,45
+cogames-0.3.69.dist-info/top_level.txt,sha256=YErBkYWJd3-eksLpbgbMrETni1MPBNL4mqEyhZUa0UE,18
+cogames-0.3.69.dist-info/RECORD,,