uenv-bridge 0.2.1__py3-none-any.whl

uenv/bridge/__init__.py

@@ -0,0 +1,4 @@
+"""The CLI and framework integrations share UEnvClient's submission boundary."""
+from .client import UEnvClient
+
+__all__ = ["UEnvClient"]

uenv/bridge/authorized_hub.py

@@ -0,0 +1,43 @@
+"""Authorize existing Hub reads before the trusted preparation pipeline uses them."""
+from uenv.sdk.hub import HubClient
+
+
+class AuthorizedHub(HubClient):
+    def __init__(self, hub, policy, principal, *, permission='execute'):
+        super().__init__(hub.origin.geturl())
+        self.hub, self.policy, self.principal, self.permission = hub, policy, principal, permission
+        self.origin, self.cache = hub.origin, None
+
+    def require(self, kind, ref):
+        return self.policy.require(self.principal, kind, ref['id'],
+            ref['revision' if kind == 'data' else 'version'], permission=self.permission)
+
+    def package(self, ref):
+        self.require('package',ref)
+        return self.hub.package(ref)
+
+    def data(self, ref):
+        self.require('data',ref)
+        result = self.hub.data(ref)
+        self.require('package',result['dataset_package'])
+        return result
+
+    def dataset_release(self, ref):
+        self.data(ref)
+        return self.hub.dataset_release(ref)
+
+    def samples(self, dataset, **kwargs):
+        self.data(dataset)
+        return self.hub.samples(dataset, **kwargs)
+
+    def iter_samples(self, dataset, **kwargs):
+        self.data(dataset)
+        return self.hub.iter_samples(dataset, **kwargs)
+
+    def _cached_file(self, query):
+        self.require('package' if 'package' in query else 'data', query.get('package',query.get('dataset')))
+        return self.hub._cached_file(query)
+
+    def cached_data_file(self, manifest, ref):
+        self.data(manifest['dataset'])
+        return self.hub.cached_data_file(manifest,ref)

uenv/bridge/cli.py

@@ -0,0 +1,294 @@
+"""Load files, then call the same UEnvClient methods as Python integrations."""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from uenv.sdk import SchemaRegistry
+from uenv.sdk.package_loader import load_yaml
+from .client import UEnvClient
+from .client_settings import load_client_settings
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description="Submit and manage unified UEnv runs")
+    parser.add_argument("--config", type=Path, help="Client connection YAML")
+    parser.add_argument("--endpoint")
+    parser.add_argument("--direct", action="store_true", help="Explicit legacy caller-owned submission; --wait owns its window")
+    action = parser.add_mutually_exclusive_group(required=True)
+    action.add_argument("--run", type=Path)
+    action.add_argument("--retry-submission", metavar="SUBMISSION_ID", help="Retry the saved request without replacing its configuration")
+    action.add_argument(
+        "--status", metavar="RUN_ID", help="Read current run state counts"
+    )
+    action.add_argument(
+        "--cancel-run",
+        metavar="RUN_ID",
+        help="Cancel the run and reject later new batches",
+    )
+    action.add_argument(
+        "--upload-file",
+        type=Path,
+        help="Upload task material using the same UEnvClient.upload_file API",
+    )
+    parser.add_argument(
+        "--media-type",
+        help="Uploaded file media type; default application/octet-stream",
+    )
+    source = parser.add_mutually_exclusive_group()
+    source.add_argument("--samples", type=Path)
+    source.add_argument(
+        "--hub-selection",
+        type=Path,
+        help="Deprecated: HubSampleQuery file; put dataset in --run instead",
+    )
+    parser.add_argument(
+        "--hub-endpoint", help="Hub origin"
+    )
+    parser.add_argument(
+        "--raw-package",
+        type=Path,
+        help="Trusted selected dataset package; read and normalize the package source format before submission",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=Path,
+        help="Deprecated: data identity file for --raw-package; put dataset in --run instead",
+    )
+    parser.add_argument("--wait", action="store_true")
+    parser.add_argument("--output", type=Path, help="Write unchanged EpisodeResult JSONL; requires --wait")
+    parser.add_argument("--batch-size", type=int, help="Maximum submitted episodes awaiting results")
+    parser.add_argument("--name", default="", help="Display name for a managed run")
+    parser.add_argument("--id", help="Stable idempotency key for a managed Hub run; reuse after a lost HTTP reply")
+    args = parser.parse_args(argv)
+    if args.name and (not args.run or args.direct):
+        parser.error("--name requires a managed --run")
+    if len(args.name) > 200:
+        parser.error("--name must be at most 200 characters")
+    if args.id and (not args.run or args.direct):
+        parser.error("--id requires a managed --run")
+    if args.output is not None and not ((args.run or args.retry_submission) and args.wait):
+        parser.error("--output requires --run and --wait")
+    if args.batch_size is not None and (not args.run or (args.direct and not args.wait)):
+        parser.error("--batch-size requires --run; --direct also requires --wait")
+    if args.batch_size is not None and args.batch_size < 1:
+        parser.error("--batch-size must be positive")
+    try:
+        connection = load_client_settings(args.config, server=args.endpoint, hub=args.hub_endpoint,
+            require_hub=bool(args.run), allow_platform=bool((args.status or args.cancel_run or args.run) and not args.direct))
+    except ValueError as error:
+        parser.error(str(error))
+    args.endpoint = connection.server
+    if args.run and not args.direct and not connection.management:
+        parser.error("Managed runs require management in client.yaml; --direct explicitly selects caller-owned submission")
+    def observe_operation(manager, operation, *, stop_event=None):
+        print(json.dumps(operation, ensure_ascii=False), file=sys.stderr if args.wait else sys.stdout, flush=True)
+        if args.wait:
+            from .evaluation import observe_run
+            run_id = manager.wait_submission(operation,stop_event=stop_event)
+            summary = observe_run(manager, run_id, output=args.output,stop_event=stop_event)
+            print(json.dumps(summary, ensure_ascii=False), file=sys.stderr)
+            return summary["exit_code"]
+        return 0
+
+    if args.retry_submission:
+        if args.direct or not connection.management or any((args.samples, args.hub_selection, args.raw_package, args.dataset, args.media_type, args.hub_endpoint)):
+            parser.error("--retry-submission requires management and takes no replacement task or execution parameters")
+        from .management_gateway import ManagementGatewayClient
+        manager = ManagementGatewayClient(connection.management, token_file=connection.management_token_file)
+        return observe_operation(manager, manager.submission(args.retry_submission, retry=True))
+    if args.status is not None or args.cancel_run is not None:
+        if any(
+            (
+                args.samples,
+                args.hub_selection,
+                args.hub_endpoint,
+                args.raw_package,
+                args.dataset,
+                args.wait,
+                args.media_type,
+            )
+        ):
+            parser.error(
+                "Run management cannot be combined with submission or upload arguments"
+            )
+        if connection.management and not args.direct:
+            from .management_gateway import ManagementGatewayClient
+            manager = ManagementGatewayClient(connection.management, token_file=connection.management_token_file)
+            result = manager.run_status(args.status) if args.status is not None else manager.management.stop("run", args.cancel_run)
+            print(json.dumps(result, ensure_ascii=False))
+            return
+        with UEnvClient(args.endpoint) as client:
+            result = (
+                client.run_status(args.status)
+                if args.status is not None
+                else (client.cancel_run(args.cancel_run) if args.direct
+                      else client.management.stop("run", args.cancel_run))
+            )
+            print(json.dumps(result, ensure_ascii=False))
+        return
+    if args.upload_file:
+        if any(
+            (
+                args.samples,
+                args.hub_selection,
+                args.hub_endpoint,
+                args.raw_package,
+                args.dataset,
+                args.wait,
+            )
+        ):
+            parser.error(
+                "--upload-file cannot be combined with task submission arguments"
+            )
+        with UEnvClient(args.endpoint) as client:
+            print(
+                json.dumps(
+                    client.upload_file(
+                        args.upload_file,
+                        media_type=args.media_type or "application/octet-stream",
+                    ),
+                    ensure_ascii=False,
+                )
+            )
+        return
+    if args.media_type:
+        parser.error("--media-type is only valid with --upload-file")
+    run = load_yaml(args.run)
+    inline_dataset = isinstance(run, dict) and "dataset" in run
+    if args.hub_selection and inline_dataset:
+        parser.error("--hub-selection conflicts with dataset in --run")
+    if args.dataset and inline_dataset:
+        parser.error("--dataset conflicts with dataset in --run")
+    if args.dataset and not args.raw_package:
+        parser.error("--dataset requires --raw-package")
+    if args.raw_package and not (args.dataset or inline_dataset):
+        parser.error("--raw-package requires dataset in --run (or legacy --dataset)")
+    if args.hub_selection and args.raw_package:
+        parser.error("Hub rows are already normalized; --raw-package is not applicable")
+    embedded_hub = inline_dataset and not args.raw_package
+    if embedded_hub and args.samples:
+        parser.error("dataset in --run cannot be combined with --samples unless --raw-package is used")
+    if not args.direct and embedded_hub:
+        from uuid import uuid4
+        from .management_gateway import ManagementGatewayClient
+        identifier = args.id or str(uuid4())
+        # Print the retry key before HTTP, including when its acknowledgement is lost.
+        print(json.dumps({"submission_key": identifier}), file=sys.stderr, flush=True)
+        manager = ManagementGatewayClient(connection.management, token_file=connection.management_token_file)
+        if connection.platform:
+            if not args.wait:
+                parser.error("Platform local models require --wait to keep the outbound model session alive")
+            if run.get("model",{}).get("credential_ref"):
+                parser.error("The local model session does not use platform credential references")
+            import asyncio
+            from .model_sessions import OutboundModelSession
+            async def connected():
+                import threading
+                stop = threading.Event()
+                operation = None
+                async with OutboundModelSession(manager,run["model"]["endpoint"]) as session:
+                    try:
+                        operation = await asyncio.to_thread(manager.submit_run,run,identifier=identifier,
+                            name=args.name,batch_size=args.batch_size or 100,model_session_id=session.descriptor["session_id"])
+                        return await session.wait(asyncio.to_thread(observe_operation,manager,operation,stop_event=stop))
+                    except BaseException as error:
+                        stop.set()
+                        if operation is not None:
+                            try:
+                                await asyncio.to_thread(manager.management.stop,'run',operation['run_id'])
+                            except Exception as cancellation:
+                                error.add_note('Run cancellation not confirmed: '+type(cancellation).__name__)
+                        raise
+            return asyncio.run(connected())
+        return observe_operation(manager, manager.submit_run(run, identifier=identifier, name=args.name, batch_size=args.batch_size or 100))
+    if args.id:
+        parser.error("--id requires a managed Hub dataset selection")
+    hub_endpoint = connection.hub
+    if not hub_endpoint:
+        parser.error("Task preparation requires a Hub address")
+    if not (args.samples or args.hub_selection or embedded_hub):
+        parser.error("--run requires an inline Hub dataset or --samples")
+    registry = SchemaRegistry.bundled()
+    from uenv.sdk.hub import HubClient
+    hub = HubClient(hub_endpoint)
+    samples = (
+        args.samples
+        if args.raw_package
+        else [
+            json.loads(line)
+            for line in args.samples.read_text(encoding="utf-8").splitlines()
+            if line.strip()
+        ]
+        if args.samples
+        else None
+    )
+    with UEnvClient(
+        args.endpoint,
+
+        registry=registry,
+        hub=hub if not (args.hub_selection or embedded_hub) else None,
+    ) as client:
+        if args.hub_selection or embedded_hub:
+            if args.hub_selection:
+                selection = load_yaml(args.hub_selection)
+                registry.validate("HubSampleQuery", selection)
+                print(
+                    "warning: --hub-selection is deprecated; put dataset in --run",
+                    file=sys.stderr,
+                )
+                prepared = client.prepare_hub(run, hub=hub, **selection)
+            else:
+                prepared = client.prepare_hub(run, hub=hub)
+        else:
+            if args.dataset:
+                print(
+                    "warning: --dataset is deprecated; put dataset in --run",
+                    file=sys.stderr,
+                )
+            prepared = (
+                client.prepare_raw(
+                    run,
+                    samples,
+                    package_directory=args.raw_package,
+                    **(
+                        {"dataset": load_yaml(args.dataset)}
+                        if args.dataset
+                        else {}
+                    ),
+                )
+                if args.raw_package
+                else client.prepare(run, samples)
+            )
+        def print_receipt(receipt):
+            print(
+                json.dumps(
+                    {"run_id": prepared["run_spec"]["run_id"], "receipt": receipt},
+                    ensure_ascii=False,
+                ),
+                file=sys.stderr if args.wait else sys.stdout,
+                flush=True,
+            )
+
+        if not args.direct:
+            from .management_gateway import ManagementGatewayClient
+            from .evaluation import observe_prepared
+            manager = ManagementGatewayClient(connection.management, token_file=connection.management_token_file, registry=client.registry)
+            operation = manager.submit_prepared(prepared, batch_size=args.batch_size or 100, name=args.name)
+            print(json.dumps(operation, ensure_ascii=False), file=sys.stderr if args.wait else sys.stdout, flush=True)
+            if args.wait:
+                summary = observe_prepared(manager, prepared, output=args.output)
+                print(json.dumps(summary, ensure_ascii=False), file=sys.stderr)
+                return summary["exit_code"]
+            return 0
+        if args.wait:
+            summary = client.evaluate_prepared(prepared, batch_size=args.batch_size or 100,
+                                               output=args.output, on_submitted=print_receipt)
+            print(json.dumps(summary, ensure_ascii=False), file=sys.stderr)
+            return summary["exit_code"]
+        print_receipt(client.submit_prepared(prepared))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())