envloop-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{envloop_cli-0.3.0 → envloop_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: envloop-cli
-Version: 0.3.0
+Version: 0.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
@@ -8,7 +8,7 @@ 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.30.2
+Requires-Dist: tinker==0.34.0
 Description-Content-Type: text/markdown
 
 # envloop-cli: EnvLoop CLI and Python SDK

{envloop_cli-0.3.0 → envloop_cli-0.4.0}/envloop/cli.py

@@ -234,6 +234,7 @@ def parser():
     put.add_argument("name")
     put.add_argument("version")
     put.add_argument("--file", type=Path, required=True, help="ProfileSpec JSON file")
+    put.add_argument("--runner", metavar="RUNNER", help="Bind org/name@<full-commit> to this version")
     secret_input = put.add_mutually_exclusive_group()
     secret_input.add_argument("--prompt-model-api-key", action="store_true", help="Read the model API key from a non-echoing prompt")
     secret_input.add_argument("--model-api-key-stdin", action="store_true", help="Read the model API key from one line of standard input")
@@ -242,6 +243,7 @@ def parser():
     update.add_argument("version", help="New version; existing versions cannot be overwritten")
     update.add_argument("--from-version", help="Source version; omit to use the explicit default")
     update.add_argument("--file", type=Path, required=True, help="JSON patch: merge literal params keys, replace supplied metadata; preserve omitted fields")
+    update.add_argument("--runner", metavar="RUNNER", help="Bind a Runner name@full-commit; omit to preserve the source binding")
     update_secret = update.add_mutually_exclusive_group()
     update_secret.add_argument("--prompt-model-api-key", action="store_true", help="Read an encrypted model connection key from a non-echoing prompt")
     update_secret.add_argument("--model-api-key-stdin", action="store_true", help="Read an encrypted model connection key from one line of standard input")
@@ -424,6 +426,13 @@ def main(argv=None):
         with connection as client:
             if args.group == "profile":
                 if args.action in {"create", "update"}:
+                    from .profile_updates import read_profile_patch, with_runner
+
+                    raw = args.file.read_bytes()
+                    patch = read_profile_patch(raw)
+                    if args.runner is not None:
+                        patch = with_runner(patch, args.runner)
+                        raw = json.dumps(patch).encode('utf-8')
                     secrets = None
                     if args.prompt_model_api_key:
                         import getpass
@@ -437,13 +446,11 @@ def main(argv=None):
                     elif args.model_api_key_stdin:
                         secrets = {"model_api_key": sys.stdin.readline(4098).rstrip("\r\n")}
                     if args.action == "update":
-                        from .profile_updates import read_profile_patch
-
                         result = client.profiles.update(args.name, args.version,
-                            patch=read_profile_patch(args.file.read_bytes()), from_version=args.from_version, secrets=secrets)
+                            patch=patch, from_version=args.from_version, secrets=secrets)
                     else:
                         result = client.profiles.import_spec(
-                            args.file.read_bytes(), name=args.name, version=args.version, secrets=secrets
+                            raw, name=args.name, version=args.version, secrets=secrets
                         )
                 elif args.action == "get":
                     result = client.profiles.get(args.name, args.version)

{envloop_cli-0.3.0 → envloop_cli-0.4.0}/envloop/cli_errors.py

@@ -66,6 +66,9 @@ _register("AUTH_LOGIN_INVALID_RESPONSE INVALID_PROJECT_RESPONSE INVALID_WORKSPAC
 _register("WORKSPACE_PAGINATION_UNSUPPORTED PROJECT_PAGINATION_UNSUPPORTED", "The complete workspace or project selection could not be loaded.", "Select the intended workspace/project by ID and verify its own API key; check client/server API version compatibility.")
 _register("NO_WORKSPACES NO_PROJECTS", "No selectable workspace or project was found.", "Use an API key authorized for the intended workspace/project, or add a verified selection through '{program} auth config'.")
 _register("PROFILE_DEFAULT_REQUIRED", "This Profile has no explicit default version.", "Specify org/name@VERSION, or set an authorized default with '{program} profile set-default'.")
+_register("INVALID_PROFILE_RUNNER", "The Profile Runner binding is invalid.", "Use org/name@<full-commit> from '{program} runner list'; file and --runner must agree.")
+_register("PROFILE_RUNNER_CONFLICT", "The explicit Runner conflicts with the Profile binding.", "Omit --runner, use the bound Revision, or publish a new Profile version.")
+_register("PROFILE_RUNNER_UNSUPPORTED", "This submission path cannot execute the Profile-bound Runner.", "Use a catalog Dataset Job with this Profile; retain the existing training path for unbound Profiles.")
 _register("PROFILE_ARCHIVED PROFILE_HASH_MISMATCH", "The selected Profile is archived or does not match its frozen version.", "Select an available immutable Profile version and resubmit with the verified reference.")
 _register("CHECKPOINT_AMBIGUOUS", "More than one checkpoint matches this selection.", "Provide --job-id or --run-id and an unambiguous checkpoint path.")
 _register("CHECKPOINT_FILES_UNAVAILABLE ARTIFACT_NOT_READY", "The requested download is not available yet.", "Inspect the Job result and artifact/checkpoint listing before retrying the download.")

{envloop_cli-0.3.0 → envloop_cli-0.4.0}/envloop/client.py

@@ -603,13 +603,23 @@ class Client:
 
         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, default_headers=headers,
+        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)
 
     @classmethod

{envloop_cli-0.3.0 → envloop_cli-0.4.0}/envloop/navigation_resources.py

@@ -167,7 +167,8 @@ def _checkpoint_matches(path, item):
         return True
     # The bare-session alias is resolved by the server for either kind.
     return (parsed.netloc == item.get('job_id') and name in {
-        'weights/' + str(item.get('checkpoint_id')), 'sampler_weights/' + str(item.get('checkpoint_id'))})
+        'weights/' + str(item.get('checkpoint_id')), 'sampler_weights/' + str(item.get('checkpoint_id')),
+        'external_weights/' + str(item.get('checkpoint_id'))})
 
 
 def _checkpoint_target(directory, name):

{envloop_cli-0.3.0 → envloop_cli-0.4.0}/envloop/profile_updates.py

@@ -24,7 +24,7 @@ def read_profile_patch(raw):
 
 
 def checked_patch(patch, name, version):
-    allowed = {"schema_version", "name", "version", "params", "description", "created_for", "secret_params"}
+    allowed = {"schema_version", "name", "version", "params", "description", "created_for", "secret_params", "runner"}
 
     def string_keys(value):
         if isinstance(value, Mapping):
@@ -47,3 +47,10 @@ def checked_patch(patch, name, version):
     except (ValueError, TypeError, OverflowError):
         raise RemoteError("INVALID_PROFILE", 422) from None
     return dict(patch)
+
+
+def with_runner(value, runner):
+    """Keep a file binding and explicit CLI binding unambiguous."""
+    if not isinstance(value, Mapping) or value.get('runner', runner) != runner:
+        raise RemoteError('INVALID_PROFILE_RUNNER', 422)
+    return dict(value, runner=runner)

{envloop_cli-0.3.0 → envloop_cli-0.4.0}/envloop/training/__init__.py

@@ -44,7 +44,6 @@ from tinker import (
     SampledSequence as SampledSequence,
     SampleRequest as SampleRequest,
     SampleResponse as SampleResponse,
-    SamplingClient as SamplingClient,
     SamplingParams as SamplingParams,
     StopReason as StopReason,
     TensorData as TensorData,
@@ -59,7 +58,9 @@ from tinker import (
     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__ = [
@@ -79,6 +80,7 @@ __all__ = [
     "Datum",
     "DmelChunk",
     "EncodedTextChunk",
+    "ImageChunk",
     "ForwardBackwardOutput",
     "SampledProvenanceSpan",
     "LoraConfig",

envloop_cli-0.4.0/envloop/training/credentials.py

@@ -0,0 +1,107 @@
+"""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_cli-0.4.0/envloop/training/sampling_client.py

@@ -0,0 +1,58 @@
+"""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_cli-0.3.0 → envloop_cli-0.4.0}/envloop/training/service_client.py

@@ -72,11 +72,32 @@ class RestClient(TinkerRestClient):
     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 0.30.2 validates sampling paths in its shared session holder, and its
+    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
@@ -84,6 +105,13 @@ class ServiceClient(TinkerServiceClient):
     """
 
     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
@@ -92,7 +120,7 @@ class ServiceClient(TinkerServiceClient):
         return RestClient(self._get_rest_holder())
 
     def _get_session_holder(self):
-        holder = super()._get_session_holder()
+        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
@@ -106,3 +134,32 @@ class ServiceClient(TinkerServiceClient):
                 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-0.3.0 → envloop_cli-0.4.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "envloop-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "EnvLoop CLI and Python SDK for jobs, training, checkpoints and inference"
 requires-python = ">=3.11"
 readme = "README.pypi.md"
-dependencies = ["tinker==0.30.2"]
+dependencies = ["tinker==0.34.0"]
 
 [project.scripts]
 envloop = "envloop.cli:main"

envloop_cli-0.3.0/envloop/training/credentials.py

@@ -1,56 +0,0 @@
-"""Per-service HTTP auth boundary for the pinned Tinker client's JWT renewals."""
-
-import re
-
-import httpx
-from tinker._base_client import DefaultAsyncHttpxClient
-
-
-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.
-    This uses Tinker's supported http_client option; no global auth/environment
-    hooks or changes to the server token lifetime are required.
-    """
-
-    def __init__(self, base_url, authorization):
-        super().__init__()
-        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):
-        exchange = request.method == 'POST' and request.url in self._credential_urls
-        if exchange:
-            kwargs['auth'] = self._platform_credential
-            kwargs['follow_redirects'] = False
-        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')