uenv-bridge 0.2.1__tar.gz

uenv_bridge-0.2.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: uenv-bridge
+Version: 0.2.1
+Summary: Unified UEnv submission client
+Project-URL: Documentation, https://uenv.io
+Project-URL: Repository, https://github.com/audreyyan1015/uenv_refactor
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: uenv-sdk[grpc]==0.1.0
+Requires-Dist: grpcio<2,>=1.80
+Requires-Dist: PyYAML<7,>=6
+Requires-Dist: aiohttp<4,>=3.12
+Provides-Extra: web
+Provides-Extra: training
+
+UEnv client for evaluation, trajectory collection, environment publishing and training integration. Install with `python -m pip install -U uenv-bridge`, then run `uenv --help`. For local training, install in your existing PyTorch, VeRL and vLLM environment. GPU training frameworks and model weights are prepared separately. Documentation: https://uenv.io

uenv_bridge-0.2.1/README.md

@@ -0,0 +1,44 @@
+# UEnv Bridge
+
+CLI、Python 客户端和浏览器共用 UEnvClient；不存在任务专用启动脚本。
+
+- client.py：准备和提交统一批次，查询状态、结果和授权文件，取消任务。
+- cli.py：读取 run.yaml 和标准化 JSONL，调用同一客户端。
+- web.py / web_assets：浏览器适配与静态页面，调用同一客户端。
+- web_state.py：保存网页提交身份、精确重试请求、上传和管理操作关联；任务状态仍由 Server 管理。
+- integrations/verl/jobs.py：在已有训练环境调用 Ray Jobs、读取 VeRL 输出并核对停止；不实现训练器。
+- training.py / integrations/verl/adapter.py / integrations/verl/agent_loop.py：把统一结果及轨迹交给训练器。
+- model_gateway.py：连接训练器提供的模型服务，保留真实 token 与策略版本信息。
+
+源码安装：`python -m pip install -e python/uenv_bridge`。
+
+客户端统一使用基础包，评测、轨迹采集、环境发布和训练接入不需要额外安装选项。正式在线安装命令为 `python -m pip install -U uenv-bridge`；须先将依赖的 `uenv-sdk` 和本包发布到 PyPI，目前使用[发行包安装](../../docs/user/02-安装部署与环境准备/2.1-安装与运行环境准备.md#只安装任务客户端)。本机训练在已有 PyTorch、VeRL、vLLM 的 Python 环境中安装，UEnv 不安装这些训练组件。
+
+`training`、`web` extras 仅为空的兼容名称，供旧发行安装器使用；所有依赖由基础包统一声明。后续停止支持引用这些名称的旧安装器时再移除。
+浏览器：`uenv-web --endpoint http://127.0.0.1:SERVER_PORT --hub http://127.0.0.1:HUB_PORT`。
+默认只监听 127.0.0.1:8090。需要远程访问时使用 TLS 反向代理。
+
+run.yaml 和 SDK 传入的 RunSpec 是同一份配置。标准化样本每行包含 task 和可选 private_data。
+原始样本先由数据集包的 DatasetAdapter 准备；Bridge 不实现数据集评分或特殊调度。
+训练器负责模型服务与权重更新，可编辑的 VeRL 配置在仓库及发行包根目录 training-config/，原生入口说明在 examples/verl/；VeRL 专用接入实现在 integrations/verl/，公共数据准备由 training_data.py 和 uenv training prepare 提供，使用现有 Bridge 提交、轨迹校验与转换路径。
+
+评测批量输出仍使用同一客户端：
+
+    uenv run --run run.yaml --samples samples.jsonl --endpoint http://127.0.0.1:SERVER_PORT --wait --batch-size 100 --output results.jsonl
+
+--output 必须搭配 --wait，文件已存在时拒绝覆盖。
+--wait 持续等待每批任务的终态，涵盖排队时间；Ctrl+C 可停止等待，已提交的任务仍可通过取消命令终止。
+未指定 --output 时，stdout 每行仍是一条 EpisodeResult；运行汇总写 stderr。
+SDK 使用 client.evaluate_prepared(prepared, batch_size=100, output="results.jsonl")，
+返回汇总字典及 exit_code；不要在数据集 Scorer 中再汇总批次分数。
+同一份已准备请求重试时保持 batch_size 不变；分批请求身份由原 batch_id 和切分位置确定。
+
+
+完整 React 运行界面的连接方式见 `frontend/README.md`。`--state-dir` 指定 Linux 节点上的私有提交目录，默认 `~/.local/state/uenv/web`；它必须在 Web 重启后保留。现有未带 Idempotency-Key 的 `run + samples` HTTP 调用保持原返回方式。新界面使用固定键，后台准备后保存精确 BatchRequest，重试不重新生成任务身份。
+
+运行配置查询通过新 `UEnvClient.run_spec()` 调用 Server `GetRunSpec`，读取原运行记录；应同步更新 Server 与 SDK。模型密钥继续使用已有执行侧 credential_ref，不能放进网页配置。网页导出复用 `export_results(..., max_bytes=...)`，命令行默认行为不变。
+
+
+完整控制台的资源发布调用 SDK／Hub；资源启用与凭据交付调用现有安装器受限入口；训练作业使用现有 Ray／VeRL 环境。`--console-config` 提供管理员固定的令牌文件、完整发行目录、集群配置与训练目标。配置、权限、文件上传和恢复说明统一见仓库 `frontend/README.md`。
+
+控制台工作目录只保存必要关联与固定重试产物，不另存 Hub 资源或 Server 调度状态。管理令牌在浏览器内存中使用，密钥通过独立受控接口进入已有 Worker 凭据文件；未启用管理配置时保留原简易任务接口语义。HTTP 的成功回执、真实业务终态和节点就绪分别查询。

uenv_bridge-0.2.1/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "uenv-bridge"
+version = "0.2.1"
+description = "Unified UEnv submission client"
+requires-python = ">=3.11"
+dependencies = ["uenv-sdk[grpc]==0.1.0", "grpcio>=1.80,<2", "PyYAML>=6,<7", "aiohttp>=3.12,<4"]
+
+readme = { text = "UEnv client for evaluation, trajectory collection, environment publishing and training integration. Install with `python -m pip install -U uenv-bridge`, then run `uenv --help`. For local training, install in your existing PyTorch, VeRL and vLLM environment. GPU training frameworks and model weights are prepared separately. Documentation: https://uenv.io", content-type = "text/markdown" }
+
+[project.urls]
+Documentation = "https://uenv.io"
+Repository = "https://github.com/audreyyan1015/uenv_refactor"
+
+[project.optional-dependencies]
+# Empty aliases keep existing released installers working. New installs use the base package.
+web = []
+training = []
+
+[project.scripts]
+uenv = "uenv.bridge.commands:main"
+uenv-bridge = "uenv.bridge.cli:main"
+uenv-web = "uenv.bridge.web:main"
+uenv-evaluate = "uenv.bridge.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"uenv.bridge" = ["web_assets/*"]
+"uenv.bridge.integrations.verl" = ["compat.json", "recipes/*.yaml"]

uenv_bridge-0.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

uenv_bridge-0.2.1/src/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-0.2.1/src/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-0.2.1/src/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())