envloop-cli 1.27.0__tar.gz → 1.29.0__tar.gz

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: envloop-cli
-Version: 1.27.0
+Version: 1.29.0
 Summary: EnvLoop CLI and Python SDK for jobs, training, checkpoints and inference
 Project-URL: Homepage, https://envloop.ai
 Project-URL: Documentation, https://docs.envloop.ai
@@ -226,8 +226,8 @@ Choose a published Runner readable in your project. Save this request as `gpu-ru
 {
   "request_id": "gpu-run-001",
   "trials": [
-    {"name": "first", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_sec": 600}},
-    {"name": "second", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_sec": 600}}
+    {"name": "first", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_seconds": 600}},
+    {"name": "second", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_seconds": 600}}
   ]
 }
 ```
@@ -272,7 +272,7 @@ with Client.remote() as client:
 ```
 
 Use the exact model returned by the Job. The SDK forwards the payload to the
-Job's `/Inference/decision` API; the approved plugin validates its business fields.
+Job's `/inference/decision` API; the approved plugin validates its business fields.
 Availability requires matching platform support and approved content in your project.
 
 ## ANS data and verified downloads

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/README.pypi.md

@@ -209,8 +209,8 @@ Choose a published Runner readable in your project. Save this request as `gpu-ru
 {
   "request_id": "gpu-run-001",
   "trials": [
-    {"name": "first", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_sec": 600}},
-    {"name": "second", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_sec": 600}}
+    {"name": "first", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_seconds": 600}},
+    {"name": "second", "spec": {"runner": "envloop/bash@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_seconds": 600}}
   ]
 }
 ```
@@ -255,7 +255,7 @@ with Client.remote() as client:
 ```
 
 Use the exact model returned by the Job. The SDK forwards the payload to the
-Job's `/Inference/decision` API; the approved plugin validates its business fields.
+Job's `/inference/decision` API; the approved plugin validates its business fields.
 Availability requires matching platform support and approved content in your project.
 
 ## ANS data and verified downloads

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/envloop/_optional.py

@@ -16,11 +16,11 @@ from typing import Any, override
 FEATURES = {'data': 'envloop_data', 'experiment': 'envloop_experiment', 'rsi-loop': 'envloop_rsi_loop'}
 FEATURE_COMMANDS = {
     'data': {
-        'dataset': 'Discover datasets, revisions and tasks',
+        'dataset': 'Discover Datasets, revisions and tasks',
         'data': 'Manage versioned Data resources and verified file downloads',
         'runner': 'Discover available Runner revisions',
-        'checkpoint': 'List and download saved training checkpoints',
-        'profile': 'Manage platform runtime profiles',
+        'checkpoint': 'List and download saved training Checkpoints',
+        'profile': 'Manage platform runtime Profiles',
     },
     'experiment': {
         'job': 'Submit and manage Agent, Sandbox, Train and Inference Jobs',
@@ -30,7 +30,7 @@ FEATURE_COMMANDS = {
 
 MODULES: dict[str, str] = {
     **dict.fromkeys('data data_publications data_upload data_cli profile_updates recipes'.split(), 'data'),
-    **dict.fromkeys('train train_progress train_runner_cli train_log_cli job_logs job_cost inference decision sandbox runtime_params job_spec_cli training'.split(), 'experiment'),
+    **dict.fromkeys('train train_progress train_metrics_cli train_runner_cli train_log_cli job_logs job_cost inference decision sandbox runtime_params job_spec_cli training'.split(), 'experiment'),
     **dict.fromkeys('agent_runs rsi_cli'.split(), 'rsi-loop'),
 }
 CLIENTS = {

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/envloop/auth_cli.py

@@ -8,6 +8,8 @@ from typing import Any, cast
 from .config import ConfigError, ConfigStore, normalize_url, validate_key
 
 DEFAULT_BASE_URL = "https://api.envloop.ai"
+CONFIG_FIELDS = ["base-url", "api-key", "workspace-id", "project-id"]
+FIELD_HELP = "One of " + ", ".join(CONFIG_FIELDS)
 
 
 def add_auth_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
@@ -23,29 +25,29 @@ def add_auth_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParse
     actions = configure.add_subparsers(dest="config_action")
     init = actions.add_parser("init", help="Configure interactively with masked API key input")
     init.add_argument("--no-check", action="store_true", default=argparse.SUPPRESS, help="Save without API verification (offline)")
-    project = actions.add_parser("project", help="Select and verify a project with its own API key")
-    project.add_argument("project_id", nargs="?", help="Project ID; omit for an interactive list with names and IDs")
-    project.add_argument("--stdin", action="store_true", help="Read the selected project's API key from stdin")
+    project = actions.add_parser("project", help="Select and verify a Project with its own API key")
+    project.add_argument("project_id", metavar="PROJECT_ID", nargs="?", help="Project ID; omit for an interactive list with names and IDs")
+    project.add_argument("--stdin", action="store_true", help="Read the selected Project's API key from stdin")
     setting = actions.add_parser("set", help="Save one field (API key is masked or read from stdin)")
-    setting.add_argument("field", choices=["base-url", "api-key", "workspace-id", "project-id"])
-    setting.add_argument("value", nargs="?", help=f"Base URL (default: {DEFAULT_BASE_URL}) or workspace ID; API keys use masked input or --stdin")
+    setting.add_argument("field", metavar="FIELD", choices=CONFIG_FIELDS, help=FIELD_HELP)
+    setting.add_argument("value", metavar="VALUE", nargs="?", help=f"Base URL (default: {DEFAULT_BASE_URL}) or Workspace ID; API keys use masked input or --stdin")
     setting.add_argument("--stdin", action="store_true", help="Read a single API key from stdin")
     setting.add_argument("--no-check", action="store_true", default=argparse.SUPPRESS, help="Save API key without verification (offline)")
     getting = actions.add_parser("get", help="Read saved configuration; never export an API key")
-    getting.add_argument("field", choices=["base-url", "api-key", "workspace-id", "project-id"])
+    getting.add_argument("field", metavar="FIELD", choices=CONFIG_FIELDS, help=FIELD_HELP)
     actions.add_parser("path", help="Print configuration and credential file paths")
     show = actions.add_parser("show", help="Show saved and effective settings without revealing keys")
     show.add_argument("--json", action="store_true")
     remove = actions.add_parser("unset", help="Delete a saved field; does not revoke the server key")
-    remove.add_argument("field", choices=["base-url", "api-key", "workspace-id", "project-id"])
+    remove.add_argument("field", metavar="FIELD", choices=CONFIG_FIELDS, help=FIELD_HELP)
     status = commands.add_parser("status", help="Inspect local credentials; --check verifies read access")
     status.add_argument("--check", action="store_true", help="Make a read-only request to the effective Base URL")
     status.add_argument("--json", action="store_true")
     commands.add_parser("logout", help="Remove the saved key for the stored default Base URL (local only)")
-    workspace = commands.add_parser("workspace", help="Select and verify the active workspace")
-    workspace.add_argument("workspace_id", nargs="?", help="Workspace ID; omit for an interactive list")
-    workspace.add_argument("--project-id", help="Project within the workspace; its own API key is required")
-    workspace.add_argument("--stdin", action="store_true", help="Read the selected workspace's API key from stdin")
+    workspace = commands.add_parser("workspace", help="Select and verify the active Workspace")
+    workspace.add_argument("workspace_id", metavar="WORKSPACE_ID", nargs="?", help="Workspace ID; omit for an interactive list")
+    workspace.add_argument("--project-id", help="Project within the Workspace; its own API key is required")
+    workspace.add_argument("--stdin", action="store_true", help="Read the selected Workspace's API key from stdin")
 
 
 def _key_from_input(stdin: bool = False) -> str:

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/envloop/cli_errors.py

@@ -182,7 +182,7 @@ TASK_REQUEST_CONFLICT TEMPORARY_DEPENDENCY_REQUIRES_RETAIN TEMPORARY_RESOURCE_RE
 TEMPORARY_SCOPE_CONFLICT TEMPORARY_SCOPE_EXPIRED TRIAL_IDEMPOTENCY_CONFLICT TRIAL_VERSION_CONFLICT USAGE_EVENT_CONFLICT
 PROFILE_CORRUPT ADAPTER_STORAGE_UNAVAILABLE INSUFFICIENT_BALANCE METHOD_NOT_ALLOWED REQUEST_TOO_LARGE
 BATCH_POLICY_NOT_APPROVED BATCH_PROVIDER_UNAVAILABLE CHECKPOINT_ACCESS_DENIED CHECKPOINT_DOWNLOAD_UNAVAILABLE
-CHECKPOINT_MANAGEMENT_UNAVAILABLE CHECKPOINT_MANAGEMENT_UNSUPPORTED CHECKPOINT_NOT_DURABLE CHECKPOINT_RUN_REQUIRED
+CHECKPOINT_MANAGEMENT_UNAVAILABLE CHECKPOINT_MANAGEMENT_UNSUPPORTED CHECKPOINT_NOT_DURABLE CHECKPOINT_TRIAL_REQUIRED
 CHECKPOINT_SIGNER_UNAVAILABLE INVALID_CHECKPOINT_CURSOR INVALID_CHECKPOINT_TTL INVALID_CHECKPOINT_VISIBILITY
 INVALID_EXECUTION_CONFIG INVALID_METRICS_RANGE INVALID_TRAIN_JOB_CURSOR INVALID_TRAIN_JOB_LIST_LIMIT
 INVALID_TRAIN_JOB_METADATA INVALID_TRAIN_JOB_SPEC INVALID_TRAIN_JOB_STATUS LOG_RETENTION_EXPIRED

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/envloop/cli_output.py

@@ -38,7 +38,8 @@ def table(headers: Sequence[object], rows: Sequence[Sequence[object]]) -> str:
 
 
 def timestamp(value: object) -> str:
-    return compact_time(value, local=True)
+    """Table and summary times: UTC to seconds, labelled; --json keeps the original value."""
+    return compact_time(value, utc=True)
 
 
 def next_page(args: argparse.Namespace, cursor: object, program: str) -> str:

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/envloop/lifecycle_cli.py

@@ -6,7 +6,7 @@ from typing import Any
 
 
 def wait_options(parser: argparse.ArgumentParser):
-    parser.add_argument('--wait', action='store_true', help='Wait for the persisted cleanup operation')
+    parser.add_argument('--wait', action='store_true', help='Wait for the persisted cleanup Operation')
     parser.add_argument('--timeout-seconds', type=float, default=600)
 
 
@@ -14,10 +14,10 @@ def add_management_commands(settings: "argparse._SubParsersAction[argparse.Argum
     operations = settings.add_parser('operation', help='Inspect or retry persisted cleanup').add_subparsers(dest='operation_action', required=True)
     for action in ('get', 'retry', 'wait'):
         command = operations.add_parser(action)
-        command.add_argument('identifier')
+        command.add_argument('identifier', metavar='OPERATION_ID')
         if action == 'wait':
             command.add_argument('--timeout-seconds', type=float, default=600)
-    cleanup = settings.add_parser('cleanup', help='Clean an explicit set of project resource IDs')
+    cleanup = settings.add_parser('cleanup', help='Clean an explicit set of Project resource IDs')
     cleanup.add_argument('--file', type=Path, required=True, help='JSON array of resource kind and ID objects')
     cleanup.add_argument('--request-id', required=True)
     wait_options(cleanup)
@@ -27,7 +27,7 @@ def add_management_commands(settings: "argparse._SubParsersAction[argparse.Argum
     create.add_argument('--request-id', required=True)
     for action in ('get', 'cleanup', 'retain'):
         command = scopes.add_parser(action)
-        command.add_argument('identifier')
+        command.add_argument('identifier', metavar='RESOURCE_SCOPE_ID')
         if action == 'cleanup':
             wait_options(command)
         if action == 'retain':

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/envloop/resource_cli.py

@@ -17,10 +17,10 @@ def listing(commands: "argparse._SubParsersAction[argparse.ArgumentParser]", *,
 
 
 def add_resource_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
-    dashboard = groups.add_parser('dashboard', help='Inspect the current project overview').add_subparsers(dest='action', required=True)
-    dashboard.add_parser('get', help='Show project details and recent experiment pages')
+    dashboard = groups.add_parser('dashboard', help='Inspect the current Project overview').add_subparsers(dest='action', required=True)
+    dashboard.add_parser('get', help='Show Project details and recent experiment pages')
 
-    billing = groups.add_parser('billing', help='Inspect project billing and recorded usage').add_subparsers(dest='resource', required=True)
+    billing = groups.add_parser('billing', help='Inspect Project billing and recorded usage').add_subparsers(dest='resource', required=True)
     for resource in ('account', 'usage', 'ledger', 'price'):
         commands = billing.add_parser(resource, help=f'Inspect billing {resource}').add_subparsers(dest='action', required=True)
         command = commands.add_parser('get', help='Show the billing account') if resource == 'account' else listing(commands, paged=False)
@@ -31,27 +31,27 @@ def add_resource_commands(groups: "argparse._SubParsersAction[argparse.ArgumentP
         if resource == 'ledger':
             command.add_argument('--limit', type=int, default=25)
 
-    limits = groups.add_parser('limit', help='Inspect project resource limits').add_subparsers(dest='action', required=True)
+    limits = groups.add_parser('limit', help='Inspect Project resource limits').add_subparsers(dest='action', required=True)
     limits.add_parser('get', help='Read effective execution limits, compose Runner state and the registry credential '
                       'count (read-only)')
-    members = groups.add_parser('member', help='Manage project members subject to server authorization').add_subparsers(dest='action', required=True)
+    members = groups.add_parser('member', help='Manage Project members subject to server authorization').add_subparsers(dest='action', required=True)
     listing(members, paged=False)
-    candidates = members.add_parser('candidate', help='Find eligible project members').add_subparsers(dest='candidate_action', required=True)
-    listing(candidates, paged=False, help='List eligible project members matching a query').add_argument('--query', required=True)
+    candidates = members.add_parser('candidate', help='Find eligible Project members').add_subparsers(dest='candidate_action', required=True)
+    listing(candidates, paged=False, help='List eligible Project members matching a query').add_argument('--query', required=True)
     for action in ('add', 'update', 'remove'):
-        command = members.add_parser(action, help=f'{action.capitalize()} a project membership (human-session authorization required)')
-        command.add_argument('user_id')
+        command = members.add_parser(action, help=f'{action.capitalize()} a Project membership (human-session authorization required)')
+        command.add_argument('user_id', metavar='USER_ID')
         if action != 'remove':
             command.add_argument('--role', choices=['viewer', 'developer', 'admin'], default='developer')
         command.add_argument('--expected-version', required=True, type=int, help='Current membership version; use 0 for a new grant')
 
-    settings = groups.add_parser('setting', help='Inspect and update the current project settings').add_subparsers(dest='action', required=True)
-    settings.add_parser('get', help='Show current project settings')
-    update = settings.add_parser('update', help='Change project fields (human-session authorization required)')
+    settings = groups.add_parser('setting', help='Inspect and update the current Project settings').add_subparsers(dest='action', required=True)
+    settings.add_parser('get', help='Show current Project settings')
+    update = settings.add_parser('update', help='Change Project fields (human-session authorization required)')
     for field in ('name', 'slug', 'region'):
         update.add_argument('--' + field)
     update.add_argument('--expected-version', required=True, type=int)
-    archive = settings.add_parser('archive', help='Archive the project (human-session authorization required)')
+    archive = settings.add_parser('archive', help='Archive the Project (human-session authorization required)')
     archive.add_argument('--expected-version', required=True, type=int)
     from .lifecycle_cli import add_management_commands
     add_management_commands(settings)
@@ -89,40 +89,40 @@ def _revision(value: str) -> str:
 
 def add_self_service_commands(settings: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
     """Project Admin settings that also work with an API key whose ceiling includes them."""
-    registry = settings.add_parser('registry', help='Manage private registry credentials for this project\'s images'
+    registry = settings.add_parser('registry', help='Manage private registry credentials for this Project\'s images'
                                    ).add_subparsers(dest='registry_action', required=True)
     listing(registry, paged=False, help='List registry credentials (metadata only; secrets are write-only)')
-    add = registry.add_parser('add', help='Register a write-only registry credential (project Admin)')
+    add = registry.add_parser('add', help='Register a write-only registry credential (Project Admin)')
     add.add_argument('--registry', required=True, help='Registry host, for example ghcr.io')
     add.add_argument('--repository-prefix', required=True, help='Repository prefix the credential covers, for example my-org')
     add.add_argument('--username', required=True)
     add.add_argument('--password-stdin', action='store_true',
                      help='Read the token or password from stdin; without it you are prompted (no echo)')
     add.add_argument('--password', '--token', nargs='?', action=_RejectSecretArgument, help=argparse.SUPPRESS)
-    remove = registry.add_parser('remove', help='Remove a credential; later image pulls no longer receive it (project Admin)')
-    remove.add_argument('credential_id')
-    compose = settings.add_parser('compose', help='Compose Runner (multi-container Task) access for this project'
+    remove = registry.add_parser('remove', help='Remove a credential; later image pulls no longer receive it (Project Admin)')
+    remove.add_argument('credential_id', metavar='CREDENTIAL_ID')
+    compose = settings.add_parser('compose', help='Compose Runner (multi-container Task) access for this Project'
                                   ).add_subparsers(dest='compose_action', required=True)
     compose.add_parser('get', help='Show the effective state, the reason and the platform bounds')
-    compose.add_parser('enable', help='Request compose Runners; the platform policy may need operator approval (project Admin)')
-    compose.add_parser('disable', help='Withdraw this project\'s compose Runner request (project Admin)')
-    concurrency = settings.add_parser('concurrency', help='Concurrent Trial limit of this project'
+    compose.add_parser('enable', help='Request compose Runners; the platform policy may need operator approval (Project Admin)')
+    compose.add_parser('disable', help='Withdraw this Project\'s compose Runner request (Project Admin)')
+    concurrency = settings.add_parser('concurrency', help='Concurrent Trial limit of this Project'
                                       ).add_subparsers(dest='concurrency_action', required=True)
-    command = concurrency.add_parser('set', help='Lower the project limit below the operator ceiling, or none to clear it '
-                                     '(project Admin)')
+    command = concurrency.add_parser('set', help='Lower the Project limit below the operator ceiling, or none to clear it '
+                                     '(Project Admin)')
     command.add_argument('value', type=_concurrency, metavar='VALUE', help='1..10000 or none')
-    model = settings.add_parser('model-access', help='Metered model access for published Runners of this project'
+    model = settings.add_parser('model-access', help='Metered model access for published Runners of this Project'
                                 ).add_subparsers(dest='model_access_action', required=True)
     listing(model, paged=False, help='List grants and whether the platform can deliver them now')
-    grant = model.add_parser('grant', help='Let one published Runner receive the project\'s metered model key on Fly '
-                             'Trials (project Admin)')
+    grant = model.add_parser('grant', help='Let one published Runner receive the Project\'s metered model key on Fly '
+                             'Trials (Project Admin)')
     grant.add_argument('runner', type=_runner_name, metavar='NAMESPACE/NAME', help='Published Runner name')
     grant.add_argument('--protocol', dest='protocols', action='append', choices=['anthropic', 'openai'], required=True,
                        help='Model protocol to grant; repeat for both')
     grant.add_argument('--revision', type=_revision, help='Limit the grant to one full commit Revision')
     revoke = model.add_parser('revoke', help='Revoke a grant; Trials that have not started no longer get the key '
-                              '(project Admin)')
-    revoke.add_argument('grant_id')
+                              '(Project Admin)')
+    revoke.add_argument('grant_id', metavar='GRANT_ID')
 
 
 def _read_secret(args: argparse.Namespace) -> str:

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/envloop/terminal.py

@@ -6,7 +6,7 @@ import sys
 import unicodedata
 from contextlib import contextmanager
 from contextvars import ContextVar
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, TextIO
 
 _NO_COLOR = ContextVar("envloop_cli_no_color", default=False)
@@ -47,15 +47,18 @@ def status_text(text: str) -> str:
     return style(text, code) if code else text
 
 
-def compact_time(value: Any, *, local: bool = False) -> Any:
-    """Render aware times to seconds; preserve unknown or timezone-free values."""
+def compact_time(value: Any, *, utc: bool = False) -> Any:
+    """Render aware times to seconds; preserve unknown or timezone-free values.
+
+    ``utc`` converts to UTC and labels it, so a table read on any machine means the same instant.
+    """
     if not isinstance(value, str):
         return value
     try:
         parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
         if parsed.tzinfo is not None:
-            if local:
-                parsed = parsed.astimezone()
+            if utc:
+                return parsed.astimezone(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
             return parsed.strftime("%Y-%m-%d %H:%M:%S")
     except ValueError:
         pass

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/packages/data/envloop_data/cli.py

@@ -79,10 +79,10 @@ def secret_option(command: argparse.ArgumentParser) -> None:
 
 
 def add_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
-    profiles = groups.add_parser("profile", help="Manage platform runtime profiles").add_subparsers(dest="action", required=True)
+    profiles = groups.add_parser("profile", help="Manage platform runtime Profiles").add_subparsers(dest="action", required=True)
     put = profiles.add_parser("create", help="Create an immutable Profile version from TOML or JSON")
-    put.add_argument("name")
-    put.add_argument("version")
+    put.add_argument("name", metavar="NAME")
+    put.add_argument("version", metavar="VERSION")
     put.add_argument("--file", type=Path, required=True, help="Profile TOML or JSON file")
     put.add_argument("--runner", metavar="RUNNER", help="Bind a Runner revision to this version")
     secret_input = put.add_mutually_exclusive_group()
@@ -90,8 +90,8 @@ def add_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParser]")
     secret_input.add_argument("--model-api-key-stdin", action="store_true", help="Read the model API key from one line of standard input")
     secret_option(put)
     update = profiles.add_parser("update", help="Edit an existing Profile by publishing a new immutable version")
-    update.add_argument("name")
-    update.add_argument("version", help="New version; existing versions cannot be overwritten")
+    update.add_argument("name", metavar="NAME")
+    update.add_argument("version", metavar="VERSION", help="New version; existing versions cannot be overwritten")
     update.add_argument("--from-version", help="Source version; omit to use default, then newest unarchived creation")
     update.add_argument("--file", type=Path, required=True, help="TOML or JSON patch: merge params keys, replace supplied metadata; preserve omitted fields")
     update.add_argument("--runner", metavar="RUNNER", help="Bind a Runner revision; v1 requires a full commit; omit to preserve the source binding")
@@ -100,13 +100,13 @@ def add_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParser]")
     update_secret.add_argument("--model-api-key-stdin", action="store_true", help="Read an encrypted model connection key from one line of standard input")
     secret_option(update)
     fork = profiles.add_parser('fork', help='Fork an existing Profile into a new immutable identity')
-    fork.add_argument('source_name')
-    fork.add_argument('source_version')
-    fork.add_argument('name')
-    fork.add_argument('version')
+    fork.add_argument('source_name', metavar='SOURCE_NAME')
+    fork.add_argument('source_version', metavar='SOURCE_VERSION')
+    fork.add_argument('name', metavar='NAME')
+    fork.add_argument('version', metavar='VERSION')
     secret_option(fork)
     get = profiles.add_parser("get")
-    get.add_argument("name")
+    get.add_argument("name", metavar="NAME")
     get.add_argument("--version")
     listing = profiles.add_parser("list")
     listing.add_argument("--name")
@@ -115,13 +115,13 @@ def add_commands(groups: "argparse._SubParsersAction[argparse.ArgumentParser]")
     listing.add_argument("--cursor")
     listing.add_argument("--json", action="store_true", help="Output the complete response as JSON (default: table)")
     default = profiles.add_parser("set-default")
-    default.add_argument("name")
-    default.add_argument("version")
+    default.add_argument("name", metavar="NAME")
+    default.add_argument("version", metavar="VERSION")
     default.add_argument("--expected-version", help="Omit only when no default exists")
     for command in ("archive", "export"):
         item = profiles.add_parser(command)
-        item.add_argument("name")
-        item.add_argument("version")
+        item.add_argument("name", metavar="NAME")
+        item.add_argument("version", metavar="VERSION")
     from envloop_data.resource_cli import add_resource_commands
     add_resource_commands(groups)
 

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/packages/data/envloop_data/cli_output.py

@@ -38,9 +38,10 @@ def list_layout(items: list[dict[str, Any]], args: argparse.Namespace) -> tuple[
         render = dataset_row
         empty = 'No datasets found.'
     elif args.group == 'checkpoint':
-        headers = ('CHECKPOINT ID', 'TYPE', 'MODEL', 'TRAIN JOB ID', 'URI')
-        render = lambda item: (item.get('checkpoint_id'), item.get('checkpoint_type'), item.get('base_model'),
-                               item.get('job_id') or item.get('train_job_id'), item.get('uri'))
+        # The checkpoint ID is the resource_id (cp_…); the save name (adapter-final) repeats across Jobs.
+        headers = ('CHECKPOINT ID', 'NAME', 'TYPE', 'MODEL', 'JOB ID', 'URI')
+        render = lambda item: (item.get('resource_id'), item.get('checkpoint_id'), item.get('checkpoint_type'),
+                               item.get('base_model'), item.get('job_id'), item.get('uri'))
         empty = 'No checkpoints found.'
     elif args.group == "profile" and args.name is None:
         headers = ("NAME", "VERSIONS", "DEFAULT", "UPDATED AT")
@@ -64,7 +65,7 @@ def pagination(command: list[str], args: argparse.Namespace, cursor: object) ->
     command.extend(['--limit', str(args.limit), '--cursor=' + str(cursor)])
     fields = {'dataset': ('type', 'query'),
               'data': ('type', 'ref', 'job_id', 'trial_id'),
-              'checkpoint': ('job_id', 'run_id'), 'profile': ('name',)}
+              'checkpoint': ('job_id', 'trial_id'), 'profile': ('name',)}
     for field in fields.get(args.group, ()):
         if getattr(args, field, None) is not None:
             if field == 'query':

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/packages/data/envloop_data/client.py

@@ -194,7 +194,7 @@ class Runners:
                  source_ref_kind: str = 'branch', dry_run: bool = False):
         """Publish a Runner package directory as the immutable revision NAME@REVISION.
 
-        This is `client.data.create(kind='runner', ...)` with the native manifest built
+        This is `client.data.create(type='runner', ...)` with the native manifest built
         from `directory` (runner.toml plus its main.py or main.sh entrypoint): the
         platform stores the bytes, derives the package and index SHA-256, creates the
         Runner asset on first use and registers the revision. `revision` is the full
@@ -219,7 +219,7 @@ class Runners:
             raise RemoteError('RUNNER_SOURCE_REF_INVALID')
         name, manifest, files, executables = runner_package(directory, name=name, executables=executables)
         ref = f'envloop://runners/{name}@{revision}'
-        publication = Data(self._server).create(kind='runner', ref=ref, manifest=manifest, files=files,
+        publication = Data(self._server).create(type='runner', ref=ref, manifest=manifest, files=files,
                                                 executables=executables, dry_run=dry_run)
         if dry_run:
             return publication

{envloop_cli-1.27.0 → envloop_cli-1.29.0}/packages/data/envloop_data/data.py

@@ -114,10 +114,10 @@ class Data:
             raise ValueError('limit must be between 1 and 100')
         return path + '?' + urlencode({key: value for key, value in params.items() if value is not None})
 
-    def list(self, *, kind: Literal['dataset', 'artifact', 'checkpoint', 'runner', 'recipe'], ref: str | None = None, job_id: str | None = None, trial_id: str | None = None, limit: int = 25, cursor: str | None = None) -> dict[str, Any]:
-        if kind not in ('dataset', 'artifact', 'checkpoint', 'runner', 'recipe') or (kind != 'artifact' and (job_id or trial_id)):
-            raise ValueError('select a Data kind and appropriate owner filters')
-        return self.transport.request('GET', self._query(self._path(), kind=kind, ref=ref, job_id=job_id, trial_id=trial_id, limit=limit, cursor=cursor))
+    def list(self, *, type: Literal['dataset', 'artifact', 'checkpoint', 'runner', 'recipe'], ref: str | None = None, job_id: str | None = None, trial_id: str | None = None, limit: int = 25, cursor: str | None = None) -> dict[str, Any]:
+        if type not in ('dataset', 'artifact', 'checkpoint', 'runner', 'recipe') or (type != 'artifact' and (job_id or trial_id)):
+            raise ValueError('select a Data type and appropriate owner filters')
+        return self.transport.request('GET', self._query(self._path(), type=type, ref=ref, job_id=job_id, trial_id=trial_id, limit=limit, cursor=cursor))
 
     def get(self, data_id: str) -> dict[str, Any]:
         return self.transport.request('GET', self._path(data_id))
@@ -131,16 +131,16 @@ class Data:
         from envhub.ans.proto import ANSError, DatasetRef, InvalidManifest, parse_uri
 
         reference = parse_uri(uri)
-        kinds = {'datasets':'dataset', 'artifacts':'artifact', 'model':'checkpoint',
+        data_types = {'datasets':'dataset', 'artifacts':'artifact', 'model':'checkpoint',
                  'runners':'runner', 'recipes':'recipe'}
-        if reference.kind not in kinds or reference.uri != uri:
+        if reference.kind not in data_types or reference.uri != uri:
             raise ValueError('select a complete resource ANS URI')
         if isinstance(reference, DatasetRef) and (not isinstance(split, str) or not split):
             raise ValueError('Dataset download requires a split')
         if not isinstance(reference, DatasetRef) and split is not None:
             raise ValueError('split is only supported for Dataset')
         endpoint = self._path() + '/download'
-        parameters = {'kind': kinds[reference.kind], 'ref': uri, 'split': split}
+        parameters = {'type': data_types[reference.kind], 'ref': uri, 'split': split}
         plan = self.transport.request('GET', self._query(endpoint, **parameters))
         from envhub.ans.client import validate_download_plan
         try:
@@ -179,36 +179,36 @@ class Data:
         return {'ref': uri, 'split': split, 'content_digest': plan['content_digest'],
                 'directory': str(target), 'verified': True}
 
-    def create(self, *, kind: str, ref: str | None = None, manifest: dict[str, Any] | None = None, files: dict[str, Any] | None = None, model: str | None = None, revision: str | None = None,
+    def create(self, *, type: str, ref: str | None = None, manifest: dict[str, Any] | None = None, files: dict[str, Any] | None = None, model: str | None = None, revision: str | None = None,
                executables: Sequence[str] = (), dry_run: bool = False, idempotency_key: str | None = None):
         """Register native content or frozen public-HF metadata in this project."""
         from envloop_data.data_publications import hf_source
 
-        source = hf_source(kind, model, revision, ref=ref, manifest=manifest, files=files,
+        source = hf_source(type, model, revision, ref=ref, manifest=manifest, files=files,
                            executables=executables, dry_run=dry_run)
         if source is not None:
             result = self.transport.request('POST', self._path(), source)
-            return result if dry_run else self._native_result(result, kind)
-        return self._publish(kind, ref, manifest, files, dry_run,
+            return result if dry_run else self._native_result(result, type)
+        return self._publish(type, ref, manifest, files, dry_run,
                              executables=executables, idempotency_key=idempotency_key)
 
     def update(self, data_id: str, *, ref: str | None = None, manifest: dict[str, Any] | None = None, files: dict[str, Any] | None = None, model: str | None = None, revision: str | None = None,
-               executables: Sequence[str] = (), kind: str | None = None, dry_run: bool = False, idempotency_key: str | None = None):
+               executables: Sequence[str] = (), type: str | None = None, dry_run: bool = False, idempotency_key: str | None = None):
         """Publish a new revision of the same asset, preserving its previous revision."""
         from envloop_data.data_publications import hf_source
 
-        source = hf_source('checkpoint' if kind is None else kind, model, revision, ref=ref, manifest=manifest, files=files,
+        source = hf_source('checkpoint' if type is None else type, model, revision, ref=ref, manifest=manifest, files=files,
                            executables=executables, dry_run=dry_run)
         resource = self.get(data_id)
-        if kind is not None and kind != resource['kind']:
-            raise ValueError('update must preserve the publication kind')
+        if type is not None and type != resource['type']:
+            raise ValueError('update must preserve the publication type')
         if source is not None:
-            if (resource['kind'] != 'checkpoint' or resource.get('metadata_only') is not True
+            if (resource['type'] != 'checkpoint' or resource.get('metadata_only') is not True
                     or resource.get('name') != model or not resource.get('model_uri')):
                 raise ValueError('HF update must preserve the native model identity')
             result = self.transport.request('POST', self._path(data_id) + '/revisions', source)
-            return result if dry_run else self._native_result(result, resource['kind'])
-        return self._publish(resource['kind'], ref, manifest, files, dry_run,
+            return result if dry_run else self._native_result(result, resource['type'])
+        return self._publish(resource['type'], ref, manifest, files, dry_run,
                              parent_id=data_id, executables=executables, idempotency_key=idempotency_key)
 
     def delete(self, data_id: str, *, dry_run: bool = False):
@@ -217,9 +217,9 @@ class Data:
         return self.transport.request('DELETE', self._path(data_id) + ('?dry_run=true' if dry_run else ''))
 
     @staticmethod
-    def _native_result(result: Any, kind: str):
+    def _native_result(result: Any, data_type: str):
         resource = result.get('resource', result) if isinstance(result, dict) else None
-        if (isinstance(resource, dict) and resource.get('kind') == kind
+        if (isinstance(resource, dict) and resource.get('type') == data_type
                 and resource.get('native_registered') is True and resource.get('native_ready') is True
                 and isinstance(resource.get('data_id', resource.get('id')), str)
                 and re.fullmatch(r'ans_[A-Za-z0-9_-]+', resource.get('data_id', resource.get('id')))):
@@ -231,37 +231,37 @@ class Data:
                 error.staging_id = staging
         raise error
 
-    def _publish(self, kind: str, ref: str | None, manifest: dict[str, Any] | None, files: dict[str, Any] | None, dry_run: bool, *, parent_id: str | None = None, executables: Sequence[str] = (), idempotency_key: str | None = None):
+    def _publish(self, data_type: str, ref: str | None, manifest: dict[str, Any] | None, files: dict[str, Any] | None, dry_run: bool, *, parent_id: str | None = None, executables: Sequence[str] = (), idempotency_key: str | None = None):
         from envloop_data.data_publications import (
             INLINE_BYTES,
-            KINDS,
+            TYPES,
             executable_files,
             prepare,
         )
 
-        if kind not in KINDS or not isinstance(ref, str) or not ref or type(dry_run) is not bool:
-            raise ValueError('select a publication kind, immutable ANS ref and boolean dry_run')
-        executables = executable_files(kind, manifest, executables)
+        if data_type not in TYPES or not isinstance(ref, str) or not ref or type(dry_run) is not bool:
+            raise ValueError('select a publication type, immutable ANS ref and boolean dry_run')
+        executables = executable_files(data_type, manifest, executables)
         with prepare(manifest, files) as (manifest, entries, payload, total, digest):
             if total <= INLINE_BYTES and len(entries) <= 100:
                 encoded = {entry['path']: base64.b64encode(payload.read(cast(int, entry['size']))).decode() for entry in entries}
-                body: dict[str, Any] = {'kind': kind, 'ref': ref, 'manifest': manifest, 'files': encoded, 'dry_run': dry_run}
+                body: dict[str, Any] = {'type': data_type, 'ref': ref, 'manifest': manifest, 'files': encoded, 'dry_run': dry_run}
                 if executables:
                     body['executables'] = executables
                 path = self._path(parent_id) + '/revisions' if parent_id else self._path()
                 result = self.transport.request('POST', path, body)
-                return result if dry_run else self._native_result(result, kind)
+                return result if dry_run else self._native_result(result, data_type)
             request_key = uuid4().hex if idempotency_key is None else idempotency_key
             identifier = None
             try:
-                upload = self.create_upload(kind=kind, ref=ref, manifest=manifest, payload_sha256=digest,
+                upload = self.create_upload(type=data_type, ref=ref, manifest=manifest, payload_sha256=digest,
                                             idempotency_key=request_key, parent_id=parent_id,
                                             executables=executables, dry_run=dry_run)
                 if dry_run:
                     return upload
                 identifier = upload.get('upload_id')
                 if upload.get('state') == 'committed':
-                    return self._native_result(upload, kind)
+                    return self._native_result(upload, data_type)
                 identifier = upload['upload_id']
                 part_bytes = upload['limits']['part_bytes']
                 if type(part_bytes) is not int or not 0 < part_bytes <= INLINE_BYTES:
@@ -278,7 +278,7 @@ class Data:
                         self.upload_part(identifier, number, chunk)
                 if existing:
                     raise RemoteError('DATA_UPLOAD_CONFLICT')
-                return self._native_result(self.complete_upload(identifier), kind)
+                return self._native_result(self.complete_upload(identifier), data_type)
             except BaseException as error:
                 # Keep server state recoverable; do not silently abort another
                 # process's resumable upload or lose its reservation identifier.
@@ -289,16 +289,16 @@ class Data:
                     cast(Any, error).upload_id = identifier
                 raise
 
-    def create_upload(self, *, kind: str, ref: str | None, manifest: dict[str, Any] | None, payload_sha256: str, idempotency_key: str, parent_id: str | None = None,
+    def create_upload(self, *, type: str, ref: str | None, manifest: dict[str, Any] | None, payload_sha256: str, idempotency_key: str, parent_id: str | None = None,
                       executables: Sequence[str] = (), dry_run: bool = False):
-        from envloop_data.data_publications import KINDS, executable_files
+        from envloop_data.data_publications import TYPES, executable_files
 
-        if (kind not in KINDS or not isinstance(ref, str) or not ref or type(dry_run) is not bool
+        if (type not in TYPES or not isinstance(ref, str) or not ref or not isinstance(dry_run, bool)
                 or not isinstance(payload_sha256, str) or not re.fullmatch(r'[a-f0-9]{64}', payload_sha256)
                 or not isinstance(idempotency_key, str) or not re.fullmatch(r'[A-Za-z0-9_.:-]{1,128}', idempotency_key)):
             raise ValueError('invalid upload metadata or idempotency key')
-        executables = executable_files(kind, manifest, executables)
-        body: dict[str, Any] = dict(kind=kind, ref=ref, manifest=manifest, payload_sha256=payload_sha256, dry_run=dry_run)
+        executables = executable_files(type, manifest, executables)
+        body: dict[str, Any] = dict(type=type, ref=ref, manifest=manifest, payload_sha256=payload_sha256, dry_run=dry_run)
         if executables:
             body['executables'] = executables
         if parent_id is not None: