envloop-cli 1.4.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

envloop/cli.py

@@ -133,11 +133,11 @@ def log_page_size(value):
 
 def runner_arguments(submit):
     submit.add_argument("--runner", metavar="NAME[@REVISION]",
-                        help="Agent: override the Dataset runner with NAME@REVISION; Sandbox: registered Runner name (for example base)")
+                        help="Agent/Train: namespace/name@REVISION; Sandbox: registered Runner name (for example base)")
     submit.add_argument("--job-id", help="caller-selected Job ID")
     submit.add_argument("--tag", help="run label")
     submit.add_argument("--priority", type=int, help="waiting priority; larger values run first (default: 0)")
-    submit.add_argument("--command", help="shell script override executed in the runner directory; preserves multiline text")
+    submit.add_argument("--command", help="Agent/Sandbox: shell override; Train: declared run_command parameter passed to the published Runner entrypoint; preserves multiline text")
 
 
 def parser():
@@ -153,10 +153,20 @@ def parser():
     from .auth_cli import add_auth_commands
 
     jobs = groups.add_parser("job", help="Submit and manage Agent, Sandbox, Train and Inference Jobs").add_subparsers(dest="action", required=True)
-    job_submit = jobs.add_parser("submit", help="Submit an Agent, Sandbox, Train or Inference Job")
+    job_submit = jobs.add_parser("submit", help="Submit an Agent, Sandbox, Train or Inference Job", allow_abbrev=False)
     job_submit.add_argument("--type", choices=("agent", "sandbox", "train", "inference"), default="agent", help="Job type (default: agent)")
-    job_submit.add_argument("--image", metavar="IMAGE", help="Sandbox Docker image override (server default: python:3.11)")
-    job_submit.add_argument("--file", type=Path, help="Train or Inference Job request JSON (spec or Train trials array)")
+    job_submit.add_argument("--image", metavar="IMAGE", help="Sandbox image override (server default: python:3.11); Train Runner: public spelling of --docker")
+    from .train_runner_cli import memory_mebibytes, positive_integer
+
+    job_submit.add_argument("--docker", metavar="IMAGE", help="Train Runner Docker image override; omitted uses the Runner declaration")
+    job_submit.add_argument("--trails", type=positive_integer, metavar="COUNT", help="Train Runner: 1–16 independent Trials (default: 1)")
+    job_submit.add_argument("--gput-type", metavar="MODEL", help="Train Runner: GPU model for each Trial (for example H100)")
+    job_submit.add_argument("--gpu", type=positive_integer, metavar="COUNT", help="Train Runner: positive GPU count per Trial")
+    job_submit.add_argument("--cpu", type=positive_integer, metavar="COUNT", help="Train Runner: positive CPU count per Trial")
+    for option in ('memory', 'disk', 'shm-size'):
+        job_submit.add_argument('--' + option, type=memory_mebibytes, metavar="SIZE",
+                                help="Train Runner: per-Trial size in Mi/Gi/Ti (for example 64Gi)")
+    job_submit.add_argument("--file", type=Path, help="Managed Train or Inference Job JSON (spec or Train trials array; interactive training is unsupported)")
     job_submit.add_argument("--source", type=Path, help="two-file directory for a single-task Job")
     job_submit.add_argument("--task-id", help="select one task within the dataset")
     job_submit.add_argument(
@@ -175,10 +185,11 @@ def parser():
                             help="named runtime Profile; omitted version requires an explicit default")
     job_submit.add_argument("--seed", type=int)
     job_submit.add_argument("--timeout-sec", type=wait_seconds,
-                            help="Agent/Sandbox execution timeout (whole seconds); Train wait timeout (default: 600)")
+                            help="Agent/Sandbox or Train Runner execution timeout (whole seconds); Train --file wait timeout (default: 600)")
     job_submit.add_argument("--delete-delay", type=nonnegative_seconds, metavar="SECONDS",
                             help="keep each sandbox (E2B or Fly) after completion for SECONDS (default: 0); cancellation/timeout delete immediately")
     job_submit.add_argument("--wait", action="store_true")
+    job_submit.add_argument("--json", action="store_true", help="Output the complete response as JSON (the default for submit; accepted for consistency with list commands)")
     for action in ("get", "stop", "result", "pause", "resume", "wake", "event"):
         command = jobs.add_parser(action)
         command.add_argument("job_id")
@@ -394,16 +405,27 @@ def main(argv=None):
             print(format_error(exc, args=args, program=cli.prog), file=sys.stderr)
             return 1
     if args.group == "job" and args.action == "submit":
+        from .train_runner_cli import SHORTCUT_FIELDS, runner_request
+
+        runner_mode = args.type == 'train' and args.file is None
+        if not runner_mode and any(getattr(args, key) is not None for key in SHORTCUT_FIELDS):
+            cli.error('Train Runner shortcuts require --type train --runner and cannot be combined with --file')
         if args.type in {"train", "inference"}:
-            if args.file is None:
+            if args.file is None and not runner_mode:
                 cli.error(f"--type {args.type} requires --file REQUEST.json")
             if args.type == 'inference' and (args.wait or args.timeout_sec is not None):
                 cli.error('Inference is a continuous service; --wait and --timeout-sec do not apply')
             agent_fields = ("dataset", "dataset_option", "source", "task_id", "config", "split", "revision",
-                            "runner", "job_id", "tag", "priority", "command", "attempts", "request_id",
-                            "profile", "seed", "delete_delay", "image")
+                            "job_id", "tag", "priority", "attempts", "profile", "seed", "delete_delay")
+            if not runner_mode:
+                agent_fields += ('runner', 'command', 'request_id', 'image')
             if any(getattr(args, key) is not None for key in agent_fields):
-                cli.error(f"--type {args.type} accepts its request through --file; Agent submission options cannot be combined")
+                cli.error(f"--type {args.type} cannot be combined with Agent submission options or mixed --file/Runner input")
+            if runner_mode:
+                try:
+                    args.train_request = runner_request(args)
+                except ValueError as exc:
+                    cli.error(str(exc))
         elif args.type == 'sandbox':
             from .sandbox import sandbox_runner_selector, validate_image
 
@@ -506,14 +528,15 @@ def main(argv=None):
                     if args.type == 'inference':
                         result = client.jobs.submit_inference(json.loads(args.file.read_text(encoding='utf-8')))
                     elif args.type == "train":
-                        result = client.training_jobs.submit(json.loads(args.file.read_text(encoding="utf-8")))
+                        request = args.train_request if args.file is None else json.loads(args.file.read_text(encoding="utf-8"))
+                        result = client.training_jobs.submit(request)
                     else:
                         result = client.jobs.submit(args.dataset, type=args.type, source=args.source, task_id=args.task_id,
                                                     attempts=args.attempts if args.attempts is not None else 1,
                                                     request_id=args.request_id, config=args.config, split=args.split,
                                                     revision=args.revision, **submission_options(args))
                     if args.wait:
-                        wait_options = {"timeout": args.timeout_sec} if args.type == "train" and args.timeout_sec is not None else {}
+                        wait_options = {"timeout": args.timeout_sec} if args.type == "train" and args.file is not None and args.timeout_sec is not None else {}
                         result = client.jobs.wait(result["job_id"], **wait_options)
                 elif args.action == 'event':
                     result = client.jobs.events(args.job_id)

envloop/cli_errors.py

@@ -90,6 +90,11 @@ _register("RSI_CONTROL_UNCONFIGURED RSI_CONTROL_UNAVAILABLE RSI_CONTROL_TIMEOUT"
 _register("JOB_ACTION_UNSUPPORTED", "This Job type does not support the requested action.", "Check the Job type with '{program} job get JOB_ID' and use its supported actions.")
 _register("INFERENCE_ROUTE_RETIRED", "The global inference route has been retired.", "Use the owning Job's base URL: API_BASE/v1/job/JOB_ID/Inference, and a model deployed by that Job.")
 
+_register("CHECKPOINT_UNAVAILABLE CHECKPOINT_NOT_DURABLE CHECKPOINT_FILES_MISSING", "The fixed inference input is unavailable or not durable.", "Inspect checkpoint publication, expiry, deletion and permissions. Do not retry with different weights under the same request ID.")
+_register("CHECKPOINT_INTEGRITY_FAILED CHECKPOINT_FORMAT_UNSUPPORTED CHECKPOINT_BASE_MISMATCH", "The fixed input failed integrity or compatibility validation.", "Use a verified durable checkpoint matching the serving profile. A different input requires a new Job and request ID.")
+_register("INFERENCE_AUTHORIZATION_DENIED INFERENCE_AUTHORIZATION_UNAVAILABLE", "The platform could not authorize a new inference worker.", "Check current project membership and Runner/input access before waking or resuming the Job.")
+_register("INFERENCE_PROFILE_UNSUPPORTED INFERENCE_RUNNER_INVALID INFERENCE_MODEL_UNPINNED INFERENCE_RUNNER_IMAGE_MISMATCH INFERENCE_RUNNER_IMAGE_UNAVAILABLE INFERENCE_RUNTIME_UNAVAILABLE", "The selected Runner or frozen inference configuration is unavailable or unsupported.", "Discover a published compatible Runner and serving profile. Submit a new Job for changes to weights, base model or Runner.")
+
 # Public service identifiers verified against EnvPlatform. Keep unexpected codes
 # private even when they look uppercase: a server can echo a submitted secret in
 # that field. HTTP status still supplies useful recovery for newer service codes.

envloop/client.py

@@ -548,10 +548,8 @@ class Jobs:
 
     def submit_inference(self, body: dict):
         """Submit a continuous inference deployment, identified by its Job ID."""
-        if not isinstance(body, dict) or set(body) - {'type', 'request_id', 'spec'} or body.get('type', 'inference') != 'inference':
-            raise ValueError('inference submission requires spec and request_id')
-        if not isinstance(body.get('spec'), dict):
-            raise ValueError('inference submission requires a spec object')
+        from .inference import validate_submission
+        validate_submission(body)
         return self._server.submit_job({'request_id': str(uuid4()), **body, 'type': 'inference'})
 
     def pause(self, job_id):
@@ -646,36 +644,11 @@ class Client:
 
         return TemporaryResources(self, **options)
 
-    def training_service(self, *, temporary_scope_id=None, **options):
-        """Use this EnvLoop connection for training without Tinker credentials/env.
+    def training_service(self, *args, **options):
+        """Removed: raise a pointer to managed Jobs."""
+        from .train import INTERACTIVE_TRAINING_REMOVED
 
-        The platform exchanges its Key for the training protocol's short-lived
-        token. Upstream token refresh follows the same platform URL and the
-        gateway rechecks the underlying subject and credential on every request.
-        """
-        from .training import ServiceClient
-        from .training.credentials import TrainingHttpClient
-
-        if 'http_client' in options:
-            raise ValueError('Client.training_service manages its authenticated HTTP client')
-        if any(name in options for name in ('base_url', 'api_key', 'default_headers')):
-            raise ValueError('Client.training_service manages its connection and credential headers')
-        overrides = options.get('default_headers_overrides') or {}
-        protected_headers = {'authorization', 'x-api-key', 'cookie', 'x-workspace-id',
-                             'x-project-id', 'x-envloop-temporary-scope'}
-        if any(name.lower() in protected_headers for name in overrides):
-            raise ValueError('Client.training_service manages authentication, project and temporary scope headers')
-        transport = self._transport
-        project_id = transport.headers.get("X-Project-ID", "")
-        if 'project_id' in options and options.pop('project_id') != project_id:
-            raise ValueError('Select the training project through Client.remote(project_id=...)')
-        token = transport.request("POST", "/v1/job/tinker/api/v1/auth/token", {})["jwt"]
-        headers = {name: value for name, value in transport.headers.items() if name in {"X-Workspace-ID", "X-Project-ID"}}
-        if temporary_scope_id is not None:
-            headers["X-EnvLoop-Temporary-Scope"] = temporary_scope_id
-        base_url = transport.base + "/v1/job/tinker"
-        return ServiceClient(base_url=base_url, api_key=token, project_id=project_id, default_headers=headers,
-                             http_client=TrainingHttpClient(base_url, transport.headers["Authorization"]), **options)
+        raise RuntimeError(INTERACTIVE_TRAINING_REMOVED)
 
     @classmethod
     def remote(cls, api_url=None, *, timeout=30, api_key=None, workspace_id=None, project_id=None, config=True):

envloop/inference.py

@@ -0,0 +1,35 @@
+"""Public inference intent validation; resolution and admission remain server owned."""
+import re
+
+_FIELDS = {'name', 'runner', 'inputs', 'serving_profile', 'hardware', 'weights_format',
+           'scaling', 'temporary_scope_id'}
+
+
+def validate_submission(body):
+    if (not isinstance(body, dict) or set(body) - {'type', 'request_id', 'spec'}
+            or body.get('type', 'inference') != 'inference'):
+        raise ValueError('inference submission requires spec and request_id')
+    spec = body.get('spec')
+    if not isinstance(spec, dict):
+        raise ValueError('inference submission requires a spec object')
+    if 'request_id' in body and (not isinstance(body['request_id'], str)
+            or not body['request_id'].strip() or len(body['request_id']) > 128):
+        raise ValueError('request_id must be a non-empty string of at most 128 characters')
+    if any(key in spec for key in ('provider', 'executor', 'resolved_runner', 'runtime')):
+        raise ValueError('execution configuration and Runner resolution are owned by the server')
+    if 'runner' not in spec:
+        return  # Explicit legacy compatibility: existing adapter specs still reach the API.
+    if set(spec) - _FIELDS:
+        raise ValueError('fixed-input inference cannot mix legacy or runtime fields')
+    runner = spec['runner']
+    if (not isinstance(runner, str)
+            or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*@[^\s@]+', runner)):
+        raise ValueError('runner requires namespace/name@revision')
+    if any(not isinstance(spec.get(key), str) or not spec[key].strip()
+           for key in ('name', 'serving_profile')):
+        raise ValueError('fixed-input inference requires name and serving_profile')
+    inputs = spec.get('inputs', {})
+    if (not isinstance(inputs, dict) or set(inputs) - {'checkpoint'}
+            or 'checkpoint' in inputs and (not isinstance(inputs['checkpoint'], str)
+            or not inputs['checkpoint'].startswith('envloop://') or not inputs['checkpoint'][10:])):
+        raise ValueError('inputs accepts one Checkpoint ANS URI')

envloop/resources.py

@@ -183,10 +183,6 @@ class TemporaryResources:
     def get(self):
         return self.client._transport.request("GET", self.path)
 
-    def training_service(self, **options):
-        self.path  # Fail before any authentication/session if the scope was not entered.
-        return self.client.training_service(temporary_scope_id=self.scope_id, **options)
-
     def retain(self, resources):
         return self.client._transport.request("POST", self.path + "/retain", {"resources": resources})
 

envloop/train.py

@@ -3,19 +3,42 @@ import math
 import time
 from urllib.parse import quote, urlencode
 
+from .http import RemoteError
+
+INTERACTIVE_TRAINING_REMOVED = (
+    "Interactive training (envloop.training, Client.training_service) was removed; training is "
+    "managed Jobs only. Submit with `el job submit --type train --file REQUEST.json` "
+    "(or client.training_jobs.submit(request)) and discover recipes with "
+    "client.training_jobs.models(). See docs/training.md."
+)
+
 
 class TrainJobs:
     def __init__(self, transport):
         self.transport = transport
 
+    def models(self) -> dict:
+        """Discover configured managed recipes; admission and GPU readiness remain separate."""
+        try:
+            return self.transport.request('GET', '/v1/job/training-models')
+        except RemoteError as error:
+            if error.status_code == 404:
+                raise RuntimeError(
+                    "This platform does not serve /v1/job/training-models; upgrade the platform to a "
+                    "version that matches this client (managed training discovery is unavailable).") from error
+            raise
+
     @staticmethod
     def _view(result):
         return {**(result.get('training') or {}), **result}
 
     def submit(self, request: dict) -> dict:
-        """Submit one legacy spec or ``{request_id, trials: [{name?, spec}, ...]}``.
+        """Submit one managed spec or ``{request_id, trials: [{name?, spec}, ...]}``.
 
-        Each Trial spec is independent; validation and execution selection belong
+        Each Trial spec is an independent managed recipe or published Runner
+        (``{runner: "namespace/name@REVISION", resources?: {...}, ...}``).
+        Runner ``command`` is the declared run_command parameter, never an
+        entrypoint override. Validation, defaults and execution selection belong
         to the platform. The training view retains the server's complete response.
         """
         if not isinstance(request, dict) or request.get("type", "train") != "train":

envloop/train_runner_cli.py

@@ -0,0 +1,64 @@
+"""Translate Runner Train CLI shortcuts into the public Job request schema."""
+
+import re
+from uuid import uuid4
+
+SHORTCUT_FIELDS = ('docker', 'trails', 'gput_type', 'gpu', 'cpu', 'memory', 'disk', 'shm_size')
+
+
+def positive_integer(value):
+    count = int(value)
+    if count <= 0:
+        raise ValueError('expected a positive integer')
+    return count
+
+
+def memory_mebibytes(value):
+    """CLI binary units map exactly to the platform's historical *_mb fields."""
+    match = re.fullmatch(r'([1-9][0-9]*)(Mi|Gi|Ti)(?:B)?', value)
+    if not match:
+        raise ValueError('expected a positive integer with Mi, Gi or Ti units (for example 64Gi)')
+    return int(match[1]) * {'Mi': 1, 'Gi': 1024, 'Ti': 1024 * 1024}[match[2]]
+
+
+def runner_request(args):
+    from .client import runner_selector
+    from .sandbox import validate_image
+
+    if not args.runner or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*@[^\s@]+', args.runner):
+        raise ValueError('Train Runner requires --runner namespace/name@REVISION')
+    runner = runner_selector(args.runner)
+    if args.docker is not None and args.image is not None:
+        raise ValueError('--docker and --image cannot be combined')
+    count = args.trails if args.trails is not None else 1
+    if not 1 <= count <= 16:
+        raise ValueError('--trails must be from 1 to 16')
+    spec = {'runner': runner}
+    image = args.docker if args.docker is not None else args.image
+    if image is not None:
+        try:
+            spec['image'] = validate_image(image)
+        except ValueError:
+            raise ValueError('Train image must be a Docker image name, optionally with a tag or sha256 digest') from None
+    if args.command is not None:
+        try:
+            valid_command = bool(args.command.strip()) and '\0' not in args.command and len(args.command.encode('utf-8')) <= 65536
+        except UnicodeEncodeError:
+            valid_command = False
+        if not valid_command:
+            raise ValueError('--command must be non-empty UTF-8, without NUL, at most 65536 bytes')
+        spec['command'] = args.command
+    resources = {field: getattr(args, option) for option, field in (
+        ('gput_type', 'gpu_type'), ('gpu', 'gpus'), ('cpu', 'cpus'),
+        ('memory', 'memory_mb'), ('disk', 'storage_mb'), ('shm_size', 'shm_mb'))
+        if getattr(args, option) is not None}
+    if args.gput_type is not None and not args.gput_type.strip():
+        raise ValueError('--gput-type must be non-empty')
+    if resources:
+        spec['resources'] = resources
+    if args.timeout_sec is not None:
+        if args.timeout_sec <= 0 or not args.timeout_sec.is_integer():
+            raise ValueError('Train Runner --timeout-sec must be positive whole seconds')
+        spec['timeout_sec'] = int(args.timeout_sec)
+    return {'type': 'train', 'request_id': args.request_id if args.request_id is not None else str(uuid4()),
+            'trials': [{'name': f'trial-{index + 1}', 'spec': dict(spec)} for index in range(count)]}

envloop/training/__init__.py

@@ -1,123 +1,4 @@
-"""Tinker public API with EnvLoop checkpoint paths, included with envloop-cli.
+"""Removed: the public interactive training SDK. Training is managed Jobs only."""
+from envloop.train import INTERACTIVE_TRAINING_REMOVED
 
-Methods, futures, exceptions and authentication retain upstream semantics.
-TrainingRun is the upstream data type, not an EnvLoop lifecycle API.
-"""
-
-from tinker import (
-    AdamOptimizerConfig as AdamOptimizerConfig,
-    AdamParams as AdamParams,
-    APIConnectionError as APIConnectionError,
-    APIError as APIError,
-    APIFuture as APIFuture,
-    APIResponseValidationError as APIResponseValidationError,
-    APIStatusError as APIStatusError,
-    APITimeoutError as APITimeoutError,
-    AuthenticationError as AuthenticationError,
-    BadRequestError as BadRequestError,
-    BillingError as BillingError,
-    Checkpoint as Checkpoint,
-    CheckpointType as CheckpointType,
-    ConflictError as ConflictError,
-    Datum as Datum,
-    DimuonOptimizerConfig as DimuonOptimizerConfig,
-    DimuonParams as DimuonParams,
-    DmelChunk as DmelChunk,
-    EncodedTextChunk as EncodedTextChunk,
-    ForwardBackwardOutput as ForwardBackwardOutput,
-    InternalServerError as InternalServerError,
-    LoraConfig as LoraConfig,
-    ModelID as ModelID,
-    ModelInput as ModelInput,
-    ModelInputChunk as ModelInputChunk,
-    NotFoundError as NotFoundError,
-    OptimParams as OptimParams,
-    OptimStepRequest as OptimStepRequest,
-    OptimStepResponse as OptimStepResponse,
-    ParsedCheckpointTinkerPath as ParsedCheckpointTinkerPath,
-    PermissionDeniedError as PermissionDeniedError,
-    PromptProvenanceSpan as PromptProvenanceSpan,
-    RateLimitError as RateLimitError,
-    RequestFailedError as RequestFailedError,
-    RequestOptions as RequestOptions,
-    SampledProvenanceSpan as SampledProvenanceSpan,
-    SampledSequence as SampledSequence,
-    SampleRequest as SampleRequest,
-    SampleResponse as SampleResponse,
-    SamplingParams as SamplingParams,
-    StopReason as StopReason,
-    TensorData as TensorData,
-    TensorDtype as TensorDtype,
-    Timeout as Timeout,
-    TinkerError as TinkerError,
-    TrainingClient as TrainingClient,
-    TrainingRun as TrainingRun,
-    UnprocessableEntityError as UnprocessableEntityError,
-    __title__ as __title__,
-    __version__ as __version__,
-    auth as auth,
-    types as types,
-)
-from tinker.types import ImageChunk as ImageChunk
-
-from .sampling_client import SamplingClient as SamplingClient
-from .service_client import RestClient as RestClient, ServiceClient as ServiceClient
-
-__all__ = [
-    "TrainingClient",
-    "ServiceClient",
-    "RestClient",
-    "SamplingClient",
-    "APIFuture",
-    "auth",
-    "AdamOptimizerConfig",
-    "AdamParams",
-    "DimuonOptimizerConfig",
-    "DimuonParams",
-    "OptimParams",
-    "Checkpoint",
-    "CheckpointType",
-    "Datum",
-    "DmelChunk",
-    "EncodedTextChunk",
-    "ImageChunk",
-    "ForwardBackwardOutput",
-    "SampledProvenanceSpan",
-    "LoraConfig",
-    "ModelID",
-    "ModelInput",
-    "ModelInputChunk",
-    "OptimStepRequest",
-    "OptimStepResponse",
-    "ParsedCheckpointTinkerPath",
-    "PromptProvenanceSpan",
-    "SampledSequence",
-    "SampleRequest",
-    "SampleResponse",
-    "SamplingParams",
-    "StopReason",
-    "TensorData",
-    "TensorDtype",
-    "TrainingRun",
-    "Timeout",
-    "RequestOptions",
-    "TinkerError",
-    "APIError",
-    "APIStatusError",
-    "APITimeoutError",
-    "APIConnectionError",
-    "APIResponseValidationError",
-    "RequestFailedError",
-    "BadRequestError",
-    "AuthenticationError",
-    "BillingError",
-    "PermissionDeniedError",
-    "NotFoundError",
-    "ConflictError",
-    "UnprocessableEntityError",
-    "RateLimitError",
-    "InternalServerError",
-    "types",
-    "__version__",
-    "__title__",
-]
+raise ModuleNotFoundError(INTERACTIVE_TRAINING_REMOVED, name="envloop.training")

envloop_cli-1.7.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.5
+Name: envloop-cli
+Version: 1.7.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
+Project-URL: Repository, https://github.com/EnvLoop/envloop-cli
+Project-URL: Issues, https://github.com/EnvLoop/envloop-cli/issues
+Project-URL: Agent instructions, https://docs.envloop.ai/skill.md
+Requires-Python: >=3.11
+Requires-Dist: tinker==0.34.0
+Description-Content-Type: text/markdown
+
+# envloop-cli: EnvLoop CLI and Python SDK
+
+Install the public client to run agent Jobs, inspect Trials, manage training and
+checkpoints, and deploy or call inference endpoints. The `el` and `envloop`
+commands are equivalent. The Python import package is `envloop`.
+
+## Version 1.7
+
+- Use published Runner resource shortcuts for Train Jobs and fixed Checkpoint inputs for Inference Jobs.
+- Pass `--json` explicitly to `job submit`; failures retain safe error codes and recovery guidance.
+- Submit training through Train Jobs. The retired interactive `envloop.training` interface is removed.
+
+After upgrading, check `el --version` and `el job submit --help`. Execution also
+requires a matching platform, project permissions and published Runners; package
+installation alone does not establish those prerequisites. See the
+[PyPI release history](https://pypi.org/project/envloop-cli/#history) for published versions.
+
+## Install
+
+Use a Python virtual environment:
+
+```bash
+python -m pip install --upgrade envloop-cli
+el --help
+```
+
+The standard installation includes the client dependencies for managed training.
+Check that the SDK can be imported:
+
+```bash
+python -c 'from envloop import Client; print("EnvLoop SDK ready")'
+```
+
+When you see `EnvLoop SDK ready`, continue to Connect. This check imports the
+client without creating a Job. Submit training through `client.training_jobs`;
+follow the [managed training guide](https://docs.envloop.ai/training/cli-hello-world).
+
+Install the client in your Python environment; the platform provides the execution resources.
+
+## Connect
+
+Use an authorized EnvLoop account and project. Browser authorization:
+
+```bash
+el auth login
+el auth status --check
+```
+
+For an existing project API key, use the masked configuration wizard:
+
+```bash
+el auth config
+el auth status --check
+```
+
+CI can read credentials from `ENVLOOP_API_KEY` and connection settings from
+`ENVLOOP_BASE_URL`, `ENVLOOP_WORKSPACE_ID` and `ENVLOOP_PROJECT_ID`. Keep keys in
+your secret manager. Public API access is scoped to the authorized project.
+
+Credentials and settings live in `~/.envloop` (override with an absolute
+`ENVLOOP_HOME`). On POSIX the directory must be private and owned by you. Use the
+default path when the optional environment variable is unset:
+
+```bash
+mkdir -p "${ENVLOOP_HOME:-$HOME/.envloop}"
+chmod 700 "${ENVLOOP_HOME:-$HOME/.envloop}"
+```
+
+An insecure directory causes `el` to fail with `CONFIG_INSECURE_PATH`.
+
+## Explore your project
+
+```bash
+el job list --limit 5
+el job list --type train --limit 5
+el trail list --limit 5
+el trail list --type train --job-id JOB_ID
+el checkpoint list --limit 5
+el job list --type inference
+```
+
+Query a returned Job ID with `el job get JOB_ID` and `el job result JOB_ID`.
+Trial commands use the spelling `trail`, for example
+`el trail artifact list TRIAL_ID`. Use each command's `--help` for options.
+
+For the Python SDK:
+
+```python
+from envloop import Client
+
+with Client.remote() as client:
+    print(client.jobs.list(limit=5))
+    print(client.trials.list(type="train", limit=5))
+```
+
+Submitting work, training a model or starting inference can allocate billable
+resources. Follow the task-specific guide and retain the outputs you need before
+cleaning up temporary resources.
+
+## Sandbox jobs
+
+With a matching platform and a published `envhub/base` ANS Runner, submit a
+Sandbox Job without a Dataset:
+
+```bash
+el job submit --type sandbox --runner base --command 'python --version'
+el job submit --type sandbox --runner base --image python:3.11 --wait
+el job list --type sandbox
+el job log JOB_ID --follow
+```
+
+The platform resolves `base` to the registered `envhub/base@main` source ref and
+freezes its immutable Revision. The Sandbox image defaults to `python:3.11`;
+`--image` accepts an image name, tag or digest. The execution provider is configured
+by the server. Job logs retain the actual captured output and collection metadata.
+Failures include a code, readable explanation, HTTP status when available, and
+recovery guidance without echoing arbitrary response bodies or credentials.
+
+## Existing installations
+
+This distribution provides both the CLI and the `envloop` import package. Use a
+fresh environment if you previously installed the separate source distribution
+named `envloop`, so two distributions do not own the same Python module files.
+Existing client configuration is reused; installing a package does not change
+your account permissions or move remote resources. Check `el --help` when
+upgrading because command groups may differ from your earlier installation.
+
+## Documentation
+
+- [English documentation](https://docs.envloop.ai/)
+- [中文文档](https://docs.envloop.ai/zh-cn/)
+- [Installation](https://docs.envloop.ai/cli-install)
+- [CLI reference](https://docs.envloop.ai/reference/cli)
+- [Training and deployment](https://docs.envloop.ai/training/train-deploy)
+- [Agent entry: skill.md](https://docs.envloop.ai/skill.md)
+
+## Submit managed training
+
+Prepare a recipe-supported `REQUEST.json` using the [SFT quickstart](https://docs.envloop.ai/training/quickstart).
+Training uses billable resources. Check your project permissions, balance and data format, then submit once:
+
+```bash
+el job submit --type train --file REQUEST.json
+el job get JOB_ID
+el job log JOB_ID --follow
+el job result JOB_ID
+el checkpoint list --job-id JOB_ID
+```
+
+Replace `JOB_ID` with the receipt's value. Read the training status and logs, then find the registered checkpoint after success.
+Ctrl-C ends log reading; to stop training, use `el job stop JOB_ID` and check its state and resource cleanup.
+See [Checkpoints](https://docs.envloop.ai/training/checkpoints) to download or delete saved weights.
+
+The built-in SFT recipe does not support custom loss, RL or optimizer-state resume.
+For an older interactive training script, follow the [managed training migration](https://docs.envloop.ai/training/sdk-compatibility).
+
+## Run a GPU Runner
+
+Choose a published Runner readable in your project. Save this request as `gpu-run.json`, replacing `FULL_COMMIT` with the full Revision from `el runner list --json`:
+
+```json
+{
+  "request_id": "gpu-run-001",
+  "trials": [
+    {"name": "first", "spec": {"runner": "envhub/bash-runner@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_sec": 600}},
+    {"name": "second", "spec": {"runner": "envhub/bash-runner@FULL_COMMIT", "resources": {"gpu_type": "H100", "gpus": 4}, "timeout_sec": 600}}
+  ]
+}
+```
+
+```bash
+el job submit --type train --file gpu-run.json
+el job get JOB_ID
+el job log JOB_ID --follow
+el job result JOB_ID
+```
+
+Replace `JOB_ID` with the returned value. The example has two independent Trials, each requesting four H100 GPUs: concurrent execution needs eight GPUs. Capacity and budget determine actual concurrency. Startup and execution are billable; check the Runner requirements, project `training.run` permission and [training prices](https://docs.envloop.ai/pricing) first. Reduce the Trial or GPU count when your program supports a smaller first run.
+
+The request file does not depend on GPU shortcut flags. If `el job submit --help` lists both `--trails` and `--gput-type`, you can instead use the shortcuts in [GPU Runner training](https://docs.envloop.ai/training/runner). Choose one submission method to avoid duplicate runs. The SDK accepts the same dictionary through `client.training_jobs.submit(request)`.
+
+The platform starts the published Revision’s `main.sh` / `main.py` using the Runner image; it does not upload local code. An optional command can only supply a declared `run_command` parameter. If this mode or GPU type is unavailable, contact your project administrator. Use `el job stop JOB_ID` to stop every Trial, then inspect each Trial’s `cleanup_confirmed` and download the uploaded artifacts you need.

{envloop_cli-1.4.0.dist-info → envloop_cli-1.7.0.dist-info}/RECORD

@@ -3,30 +3,29 @@ envloop/agent_runs.py,sha256=ohBuiv6G2DcyItfPcMh68N9NpAmHwDkaZkyEqKwVQM8,10178
 envloop/auth_cli.py,sha256=yTzNaqFFBBZ-rEp7XUW7Yn2K9Uz6IGe3i3Ye61_vccc,14826
 envloop/auth_login.py,sha256=wURCu4HEhRlW3EGWn0MJvgPfe1wXhdplMmeQybNIWwQ,6527
 envloop/auth_workspace.py,sha256=CC1EToAOcKW69Mvb4xZRkVltmXY4OpApfZaUc2ChB-c,14377
-envloop/cli.py,sha256=6RnXTIDigLmlhJxSQwwkRCnU8f02ciaCgk8-dSOHo3w,33123
-envloop/cli_errors.py,sha256=6adjPGRvbA98Cic1E2RUtLk3xCKW4G9b1jWnmfqhCxU,23835
+envloop/cli.py,sha256=2FuP70kr5JpAzKP-4rJ_KKFu070wb6-XGyLkICfrGJk,35123
+envloop/cli_errors.py,sha256=cruj0vydFrLOcy7vsOgxFE8kZDxVf5FxU-eQnvEEu50,25032
 envloop/cli_output.py,sha256=bW2J7aCo9WqPqzIl2WHwVgpuQ7nGaaA2GEz1reMJczs,11151
-envloop/client.py,sha256=wDcO2GrCr60cykpuIdfPJGGoiZ57iKW-ke3--m__MdA,34207
+envloop/client.py,sha256=qznO0YaELy727uM0ogXl4KMG05LbIKUHBOwqpZxUH9k,32038
 envloop/config.py,sha256=aSTztNusGD4JOvwMmTy6GpjlDs4eZrwnntnvzbjO1f8,19699
 envloop/http.py,sha256=8pmCZRc3-Z70dLdE4nmgxbcFICKhxDO1XbfbcU-Bytc,15061
+envloop/inference.py,sha256=L_2sMyM9y3k9d_dl8LXIu2vpMnEvua_a-77G0YZFViM,2095
 envloop/job_logs.py,sha256=n1rOAg4XvRlqhuGl5Z1AazxhjwzgnDT0FGrtJFCI1AY,892
 envloop/lifecycle_cli.py,sha256=Di7zzslJI09CBWJXgi2PrAqzCvvo8UfDh3fcFew7Fng,2966
 envloop/navigation_resources.py,sha256=sTXBdPvSvekW2eQeQHp6nvf5kKqNfE0ZE7mZOkuJacg,15553
 envloop/profile_secrets.py,sha256=jDDmBTO5D8hAUc74zkq7u44QWFTz-J0-brYBrk7zgqU,1107
 envloop/profile_updates.py,sha256=YUQky5SSU7PZrjGFvVSVEcxm8CnayX4hsQljTGyc7zU,2975
 envloop/resource_cli.py,sha256=YHDzA476SSqgarAIi5C61hGYWX0KJ9PWLPhbWmCDNtA,9846
-envloop/resources.py,sha256=SQ5EcFZ7V0mwMe3CFI5lClx6Ccdy9r1z6plhJlvAcx4,9526
+envloop/resources.py,sha256=THh7uMdi8vxFHQklZXZlw4NmdLlInN980R2K96pe5cM,9303
 envloop/rsi_cli.py,sha256=YQIGKqADS1cDIlsBlMTIfMXImOKiN8KOJ9yZRtMtLis,1831
 envloop/sandbox.py,sha256=hqKq3MST89p47PuAtk1lm3lpk3f796I_5T6P_yV9uW4,1208
-envloop/train.py,sha256=_2ULNs9370e8ub5xdYW4bAl18fxvW9WG5dC92_6EawQ,3340
+envloop/train.py,sha256=sW-dzU1QRggW_Gvz3vnBtGwcRRKQBXPye63ROd5zpic,4515
 envloop/train_log_cli.py,sha256=eqHYLLu1ohk4hYeio0qVhanrqBRpGRMRUcqkI-LWIuA,4201
-envloop/training/__init__.py,sha256=NtifOnEHcA1aM5zn4-ZTn2IaCRy6RFAFLY_WEYgO6rY,3643
-envloop/training/credentials.py,sha256=V4uDZxGXn8387aZF6BpUNX1AunwkPxDXivC70FOkiE0,4638
-envloop/training/sampling_client.py,sha256=195ze2IcbV0kcTIXmGiV8r6MJ5tdKyd-g73WJzxRQsY,3226
-envloop/training/service_client.py,sha256=UF0nxQdSCrfas5mPsGKWXyNF5uYzNJGdTfUynDpk2sA,8277
+envloop/train_runner_cli.py,sha256=hwfY0hskgiUMEE9AM3Onh1JC0WTdaiBVuoWVsltO8qI,3014
+envloop/training/__init__.py,sha256=bg491cs_deETTEZ9ddjbLmxUvH3CiGJC7_438IRWto4,220
 envloop/utils/__init__.py,sha256=huB3qPQuKNr3JxfH3Ys09YWFtHiDamCHFsBa4epANgQ,25
 envloop/utils/logging.py,sha256=rXN0qyxhfGEq4vWXxjwfaczPPZf_7atnOkkBTgNNRPc,1017
-envloop_cli-1.4.0.dist-info/METADATA,sha256=3S_8xVBPxjIPRt17qYBiuxLPx9KKKHz0Ol0Y0cplPP8,4197
-envloop_cli-1.4.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-envloop_cli-1.4.0.dist-info/entry_points.txt,sha256=8aXOpgtVk4GndhChA4XNecShkb1w0xGHBHrKla78ofI,67
-envloop_cli-1.4.0.dist-info/RECORD,,
+envloop_cli-1.7.0.dist-info/METADATA,sha256=QQ_GerUhFYvb4O8TOvjW5kPlxXqEGnQj6-0_a1DlFPU,8314
+envloop_cli-1.7.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+envloop_cli-1.7.0.dist-info/entry_points.txt,sha256=8aXOpgtVk4GndhChA4XNecShkb1w0xGHBHrKla78ofI,67
+envloop_cli-1.7.0.dist-info/RECORD,,

envloop/training/credentials.py

@@ -1,107 +0,0 @@
-"""Per-service HTTP auth boundary for the pinned Tinker client's JWT renewals."""
-
-import dataclasses
-import re
-
-import httpx
-from tinker._base_client import DefaultAsyncHttpxClient
-from tinker.lib.internal_client_holder import InternalClientHolder, _ShadowHolderConfig
-
-_SCOPE_HEADERS = {'x-workspace-id', 'x-project-id', 'x-envloop-temporary-scope'}
-
-
-class _ProcessLocalShadowConfig(_ShadowHolderConfig):
-    """Prevent native SamplingClient pickle from exporting the bootstrap JWT.
-
-    Upstream serializes shadow_config rather than the holder itself. Its handle
-    export first calls without_credentials(), which returns the official plain
-    config shape without this process boundary or any authentication headers.
-    """
-
-    def __reduce__(self):
-        raise TypeError('EnvLoop training services are process-local; export a sampler handle instead')
-
-    def without_credentials(self):
-        fields = dataclasses.asdict(self)
-        fields['api_key'] = None
-        fields['default_headers_overrides'] = {
-            name: value for name, value in self.default_headers_overrides.items()
-            if name.lower() in _SCOPE_HEADERS
-        }
-        return _ShadowHolderConfig(**fields)
-
-
-class TrainingClientHolder(InternalClientHolder):
-    """Instance-local transport options for the pinned Tinker 0.34 holder.
-
-    The high-level upstream constructor no longer forwards transport options.
-    Inject them before its first config request, so config, refresh, session and
-    REST pools all retain the same authenticated transport and timeout policy.
-    """
-
-    def __init__(self, *, transport_options, **kwargs):
-        self._envloop_transport_options = transport_options
-        super().__init__(**kwargs)
-
-    async def _fetch_client_config(self, auth):
-        self._constructor_kwargs.update(self._envloop_transport_options)
-        return await super()._fetch_client_config(auth)
-
-    def __reduce__(self):
-        raise TypeError('EnvLoop training services are process-local; create a new training_service in each process')
-
-    @property
-    def shadow_config(self):
-        return _ProcessLocalShadowConfig(**dataclasses.asdict(super().shadow_config))
-
-
-class _PlatformCredential(httpx.Auth):
-    def __init__(self, authorization):
-        self._authorization = authorization
-
-    def auth_flow(self, request):
-        # Never combine the original credential with Tinker's bootstrap JWT.
-        request.headers.pop('X-API-Key', None)
-        request.headers['Authorization'] = self._authorization
-        yield request
-
-
-class TrainingHttpClient(DefaultAsyncHttpxClient):
-    """Keep upstream JWT refresh, but authenticate each exchange with its source.
-
-    Only the exact configured config/exchange URLs receive the original key.
-    TrainingClientHolder forwards this through the pinned low-level client's
-    http_client option without global auth/environment hooks.
-    """
-
-    def __init__(self, base_url, authorization):
-        super().__init__(follow_redirects=False)
-        self._credential_urls = {httpx.URL(base_url + path) for path in
-                                 ('/api/v1/client/config', '/api/v1/auth/token')}
-        self._platform_credential = _PlatformCredential(authorization)
-
-    async def send(self, request, **kwargs):
-        # X-API-Key is not stripped by HTTPX on cross-origin redirects. Both
-        # bootstrap exchanges and ordinary JWT requests must stay on their URL.
-        kwargs['follow_redirects'] = False
-        exchange = request.method == 'POST' and request.url in self._credential_urls
-        if exchange:
-            kwargs['auth'] = self._platform_credential
-        response = await super().send(request, **kwargs)
-        if exchange and not 200 <= response.status_code < 300:
-            # Upstream logs refresh failures. Retain a bounded code/status, never
-            # a provider's arbitrary response body or potentially secret detail.
-            await response.aread()
-            try:
-                code = response.json().get('code')
-            except (ValueError, AttributeError):
-                code = None
-            if not isinstance(code, str) or not re.fullmatch(r'[A-Z][A-Z0-9_]{0,127}', code):
-                code = 'TRAINING_AUTH_FAILED'
-            await response.aclose()
-            return httpx.Response(response.status_code, request=response.request,
-                                  json={'code': code, 'error': 'EnvLoop training authorization failed'})
-        return response
-
-    def __reduce__(self):
-        raise TypeError('EnvLoop training services are process-local; create a new training_service in each process')

envloop/training/sampling_client.py

@@ -1,58 +0,0 @@
-"""Restore official sampler handles using an explicit EnvLoop credential."""
-
-import base64
-import json
-from urllib.parse import urlsplit
-
-from tinker import SamplingClient as TinkerSamplingClient
-from tinker.lib.internal_client_holder import _ShadowHolderConfig
-from tinker.lib.public_interfaces.sampling_client import _SamplingClientPickleState
-
-from .credentials import TrainingClientHolder
-
-
-class SamplingClient(TinkerSamplingClient):
-    @staticmethod
-    def from_sampler_handle(handle, *, api_key=None):
-        fields = json.loads(base64.urlsafe_b64decode(handle))
-        config = _ShadowHolderConfig(**fields.pop('holder'))
-        state = _SamplingClientPickleState(**fields, holder=config)
-        url = urlsplit(config.base_url)
-        if not url.path.rstrip('/').endswith('/v1/job/tinker'):
-            return TinkerSamplingClient.from_sampler_handle(handle, api_key=api_key)
-        if not isinstance(api_key, str) or not api_key.strip():
-            raise ValueError('EnvLoop sampler handles require an explicit original EnvLoop api_key')
-        if url.scheme not in {'http', 'https'} or not url.hostname or url.username or url.password or url.query or url.fragment:
-            raise ValueError('invalid EnvLoop sampler API URL')
-        if config.api_key is not None:
-            raise ValueError('EnvLoop sampler handles must not contain credentials')
-        headers = {name.lower(): value for name, value in config.default_headers_overrides.items()}
-        if set(headers) - {'x-workspace-id', 'x-project-id', 'x-envloop-temporary-scope'}:
-            raise ValueError('EnvLoop sampler handles may contain only workspace, project and temporary scope headers')
-
-        from envloop import Client
-        from envloop.http import HttpService
-
-        base_url = config.base_url.rstrip('/')
-        # A missing scope means key-selected scope, never this worker's ambient
-        # EnvLoop configuration or environment.
-        client = Client(HttpService(base_url.removesuffix('/v1/job/tinker'), api_key=api_key,
-                                    workspace_id=headers.get('x-workspace-id'),
-                                    project_id=headers.get('x-project-id'), config=False, environment=False))
-        try:
-            service = client.training_service(temporary_scope_id=headers.get('x-envloop-temporary-scope'))
-            # Fetch current server flags with the explicit original key. Never
-            # trust cached auth flags from a portable handle or create a new job.
-            holder = TrainingClientHolder(
-                session_id=state.session_id, base_url=service._base_url, api_key=service._api_key,
-                default_headers_overrides=service._default_headers_overrides,
-                transport_options=service._envloop_transport_options,
-            )
-            return SamplingClient(holder, sampling_session_id=state.sampling_session_id,
-                                  shadow=True, record_stability_info=state.record_stability_info)
-        finally:
-            client.close()
-
-    def close(self):
-        """Release this restored client's local resources without finishing its job."""
-        return self.holder.run_coroutine_threadsafe(self.holder.aclose())

envloop/training/service_client.py

@@ -1,165 +0,0 @@
-"""EnvLoop checkpoint path adaptation for the pinned Tinker SDK."""
-
-import re
-import threading
-
-from tinker import ServiceClient as TinkerServiceClient
-from tinker.lib.public_interfaces.rest_client import RestClient as TinkerRestClient
-
-_ENVLOOP_PATH = re.compile(
-    r"envloop://(?P<session>tts-[0-9a-f]{12}|job_[0-7][0-9A-HJKMNP-TV-Z]{25})/(?P<checkpoint>[A-Za-z0-9_-][A-Za-z0-9_.-]*)"
-)
-
-
-def _checked(path):
-    match = _ENVLOOP_PATH.fullmatch(path)
-    if match is None:
-        raise ValueError("invalid envloop checkpoint path")
-    return match
-
-
-def tinker_path(path):
-    """Map ``envloop://<session>/<checkpoint>`` onto Tinker's checkpoint path form.
-
-    The platform resolves ``tinker://<session>/weights/<checkpoint>`` to the same stored
-    checkpoint whatever its type; ``tinker://`` paths (what save_state returns) pass through.
-    """
-    if not isinstance(path, str) or not path.startswith("envloop://"):
-        return path
-    match = _checked(path)
-    return f"tinker://{match['session']}/weights/{match['checkpoint']}"
-
-
-class RestClient(TinkerRestClient):
-    """Tinker RestClient whose ``*_from_tinker_path`` helpers also accept envloop:// paths."""
-
-    def get_training_run_by_tinker_path(self, tinker_path_, *args, **kwargs):
-        return super().get_training_run_by_tinker_path(tinker_path(tinker_path_), *args, **kwargs)
-
-    async def get_training_run_by_tinker_path_async(self, tinker_path_, *args, **kwargs):
-        return await super().get_training_run_by_tinker_path_async(tinker_path(tinker_path_), *args, **kwargs)
-
-    def get_weights_info_by_tinker_path(self, tinker_path_):
-        return super().get_weights_info_by_tinker_path(tinker_path(tinker_path_))
-
-    def delete_checkpoint_from_tinker_path(self, tinker_path_):
-        return super().delete_checkpoint_from_tinker_path(tinker_path(tinker_path_))
-
-    async def delete_checkpoint_from_tinker_path_async(self, tinker_path_):
-        return await super().delete_checkpoint_from_tinker_path_async(tinker_path(tinker_path_))
-
-    def get_checkpoint_archive_url_from_tinker_path(self, tinker_path_):
-        return super().get_checkpoint_archive_url_from_tinker_path(tinker_path(tinker_path_))
-
-    async def get_checkpoint_archive_url_from_tinker_path_async(self, tinker_path_):
-        return await super().get_checkpoint_archive_url_from_tinker_path_async(tinker_path(tinker_path_))
-
-    def publish_checkpoint_from_tinker_path(self, tinker_path_):
-        return super().publish_checkpoint_from_tinker_path(tinker_path(tinker_path_))
-
-    async def publish_checkpoint_from_tinker_path_async(self, tinker_path_):
-        return await super().publish_checkpoint_from_tinker_path_async(tinker_path(tinker_path_))
-
-    def unpublish_checkpoint_from_tinker_path(self, tinker_path_):
-        return super().unpublish_checkpoint_from_tinker_path(tinker_path(tinker_path_))
-
-    async def unpublish_checkpoint_from_tinker_path_async(self, tinker_path_):
-        return await super().unpublish_checkpoint_from_tinker_path_async(tinker_path(tinker_path_))
-
-    def set_checkpoint_ttl_from_tinker_path(self, tinker_path_, ttl_seconds):
-        return super().set_checkpoint_ttl_from_tinker_path(tinker_path(tinker_path_), ttl_seconds)
-
-    async def set_checkpoint_ttl_from_tinker_path_async(self, tinker_path_, ttl_seconds):
-        return await super().set_checkpoint_ttl_from_tinker_path_async(tinker_path(tinker_path_), ttl_seconds)
-
-    def copy_weights(self, path, destination_project_id=None, *, ttl_seconds=None, weights_access_token=None):
-        return super().copy_weights(tinker_path(path), destination_project_id,
-                                    ttl_seconds=ttl_seconds, weights_access_token=weights_access_token)
-
-    async def copy_weights_async(self, path, destination_project_id=None, *, ttl_seconds=None, weights_access_token=None):
-        return await super().copy_weights_async(tinker_path(path), destination_project_id,
-                                               ttl_seconds=ttl_seconds, weights_access_token=weights_access_token)
-
-    def get_external_weights_urls(self, path):
-        return super().get_external_weights_urls(self._external_path(path))
-
-    async def get_external_weights_urls_async(self, path):
-        return await super().get_external_weights_urls_async(self._external_path(path))
-
-    @staticmethod
-    def _external_path(path):
-        if isinstance(path, str) and path.startswith("envloop://"):
-            match = _checked(path)
-            return f"tinker://{match['session']}/external_weights/{match['checkpoint']}"
-        return path
-
-
-class ServiceClient(TinkerServiceClient):
-    """Tinker ServiceClient accepting EnvLoop checkpoint paths.
-
-    Tinker validates sampling paths in its shared session holder, and its
-    RestClient parses paths client-side, before sending HTTP. Adapt those boundaries
-    so ServiceClient, its TrainingClients and RestClients accept envloop:// without
-    replacing native futures, training clients, authentication, or globally patching
-    the upstream SDK. Platform responses already use Tinker's tinker:// form.
-    """
-
-    def __init__(self, *args, **kwargs):
-        # 0.34's public constructor silently ignores these previously supported
-        # options. Keep EnvLoop's per-service auth/timeout boundary explicit.
-        self._envloop_transport_options = {name: kwargs.pop(name) for name in
-                                           ('http_client', 'timeout', 'max_retries') if name in kwargs}
-        headers = kwargs.pop('default_headers', None)
-        if headers is not None:
-            kwargs['default_headers_overrides'] = dict(headers) | dict(kwargs.get('default_headers_overrides') or {})
-        super().__init__(*args, **kwargs)
-        self._checkpoint_adapter_lock = threading.Lock()
-        self._checkpoint_adapter_holder = None
-
-    def create_rest_client(self) -> RestClient:
-        return RestClient(self._get_rest_holder())
-
-    def _get_session_holder(self):
-        holder = self._envloop_holder(session=True) if self._envloop_transport_options else super()._get_session_holder()
-        with self._checkpoint_adapter_lock:
-            if self._checkpoint_adapter_holder is not holder:
-                create = holder._create_sampling_session
-
-                async def create_sampling_session(model_path=None, base_model=None):
-                    if isinstance(model_path, str) and model_path.startswith("envloop://"):
-                        _checked(model_path)
-                        model_path = "tinker://" + model_path.removeprefix("envloop://")
-                    return await create(model_path=model_path, base_model=base_model)
-
-                holder._create_sampling_session = create_sampling_session
-                self._checkpoint_adapter_holder = holder
-        return holder
-
-    def _get_rest_holder(self):
-        return self._envloop_holder(session=False) if self._envloop_transport_options else super()._get_rest_holder()
-
-    def _envloop_holder(self, *, session):
-        from .credentials import TrainingClientHolder
-
-        attribute = '_session_holder' if session else '_rest_holder'
-        lock = self._session_holder_lock if session else self._rest_holder_lock
-        with self._lifecycle_lock:
-            if self._closed:
-                raise RuntimeError('ServiceClient is closed')
-            holder = getattr(self, attribute)
-            if holder is not None:
-                return holder
-        with lock:
-            with self._lifecycle_lock:
-                if self._closed:
-                    raise RuntimeError('ServiceClient is closed')
-                holder = getattr(self, attribute)
-                if holder is None:
-                    options = dict(user_metadata=self._user_metadata, project_id=self._project_id,
-                                   display_name=self._display_name) if session else {'_skip_session': True}
-                    holder = TrainingClientHolder(
-                        base_url=self._base_url, api_key=self._api_key,
-                        default_headers_overrides=self._default_headers_overrides,
-                        transport_options=self._envloop_transport_options, **options)
-                    setattr(self, attribute, holder)
-                return holder

envloop_cli-1.4.0.dist-info/METADATA

@@ -1,122 +0,0 @@
-Metadata-Version: 2.5
-Name: envloop-cli
-Version: 1.4.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
-Project-URL: Repository, https://github.com/EnvLoop/envloop-cli
-Project-URL: Issues, https://github.com/EnvLoop/envloop-cli/issues
-Project-URL: Agent instructions, https://docs.envloop.ai/skill.md
-Requires-Python: >=3.11
-Requires-Dist: tinker==0.34.0
-Description-Content-Type: text/markdown
-
-# envloop-cli: EnvLoop CLI and Python SDK
-
-Install the public client to run agent Jobs, inspect Trials, manage training and
-checkpoints, and deploy or call inference endpoints. The `el` and `envloop`
-commands are equivalent. The Python import package is `envloop`.
-
-## Install
-
-Use a Python virtual environment:
-
-```bash
-python -m pip install --upgrade envloop-cli
-el --help
-```
-
-The standard installation includes training support:
-
-```bash
-python -c 'from envloop import Client, training; print("EnvLoop SDK ready")'
-```
-
-The package installs the training protocol client by default. You do not need a source checkout, GitHub account,
-local execution backend, Docker, or a GPU to install the client.
-
-## Connect
-
-Use an authorized EnvLoop account and project. Browser authorization:
-
-```bash
-el auth login
-el auth status --check
-```
-
-For an existing project API key, use the masked configuration wizard:
-
-```bash
-el auth config
-el auth status --check
-```
-
-CI can read credentials from `ENVLOOP_API_KEY` and connection settings from
-`ENVLOOP_BASE_URL`, `ENVLOOP_WORKSPACE_ID` and `ENVLOOP_PROJECT_ID`. Keep keys in
-your secret manager. Public API access is scoped to the authorized project.
-
-## Explore your project
-
-```bash
-el job list --limit 5
-el job list --type train --limit 5
-el trail list --limit 5
-el trail list --type train --job-id JOB_ID
-el checkpoint list --limit 5
-el job list --type inference
-```
-
-Query a returned Job ID with `el job get JOB_ID` and `el job result JOB_ID`.
-Trial commands use the spelling `trail`, for example
-`el trail artifact list TRIAL_ID`. Use each command's `--help` for options.
-
-For the Python SDK:
-
-```python
-from envloop import Client
-
-with Client.remote() as client:
-    print(client.jobs.list(limit=5))
-    print(client.trials.list(type="train", limit=5))
-```
-
-Submitting work, training a model or starting inference can allocate billable
-resources. Follow the task-specific guide and retain the outputs you need before
-cleaning up temporary resources.
-
-## Sandbox jobs
-
-With a matching platform and a published `envhub/base` ANS Runner, submit a
-Sandbox Job without a Dataset:
-
-```bash
-el job submit --type sandbox --runner base --command 'python --version'
-el job submit --type sandbox --runner base --image python:3.11 --wait
-el job list --type sandbox
-el job log JOB_ID --follow
-```
-
-The platform resolves `base` to the registered `envhub/base@main` source ref and
-freezes its immutable Revision. The Sandbox image defaults to `python:3.11`;
-`--image` accepts an image name, tag or digest. The execution provider is configured
-by the server. Job logs retain the actual captured output and collection metadata.
-Failures include a code, readable explanation, HTTP status when available, and
-recovery guidance without echoing arbitrary response bodies or credentials.
-
-## Existing installations
-
-This distribution provides both the CLI and the `envloop` import package. Use a
-fresh environment if you previously installed the separate source distribution
-named `envloop`, so two distributions do not own the same Python module files.
-Existing client configuration is reused; installing a package does not change
-your account permissions or move remote resources. Check `el --help` when
-upgrading because command groups may differ from your earlier installation.
-
-## Documentation
-
-- [English documentation](https://docs.envloop.ai/)
-- [中文文档](https://docs.envloop.ai/zh-cn/)
-- [Installation](https://docs.envloop.ai/cli-install)
-- [CLI reference](https://docs.envloop.ai/reference/cli)
-- [Training and deployment](https://docs.envloop.ai/training/train-deploy)
-- [Agent entry: skill.md](https://docs.envloop.ai/skill.md)