benchloop-client 0.2.24__tar.gz → 0.2.25__tar.gz

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: benchloop_client
-Version: 0.2.24
+Version: 0.2.25
 Summary: Benchloop CLI — command line tool for benchmark analysis data (metrics, trajectory, reports, artifacts).
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.25.2
@@ -84,6 +84,9 @@ bl metadata download --task-id TASK_ID -o ./out
 bl report download -j J123 -o ./out
 bl report get -g G123
 bl report download -g G123 -o ./out
+bl rsi get -j J123
+bl rsi trigger -j J123
+bl rsi download -g G123 -o ./out
 bl jobs get -g G1 --all          # get supports --all (auto-paginate)
 bl jobs download -g G1           # download is always full
 bl artifacts download -g G1 -o ./out

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/README.md

@@ -72,6 +72,9 @@ bl metadata download --task-id TASK_ID -o ./out
 bl report download -j J123 -o ./out
 bl report get -g G123
 bl report download -g G123 -o ./out
+bl rsi get -j J123
+bl rsi trigger -j J123
+bl rsi download -g G123 -o ./out
 bl jobs get -g G1 --all          # get supports --all (auto-paginate)
 bl jobs download -g G1           # download is always full
 bl artifacts download -g G1 -o ./out

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "benchloop_client"
-version = "0.2.24"
+version = "0.2.25"
 description = "Benchloop CLI — command line tool for benchmark analysis data (metrics, trajectory, reports, artifacts)."
 readme = "README.md"
 requires-python = ">=3.10"

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/src/aliyun/bmcli/cli.py

@@ -17,6 +17,7 @@ from aliyun.bmcli.commands import (
     overview as overview_cmd,
     pull as pull_cmd,
     report as report_cmd,
+    rsi as rsi_cmd,
     tasks as tasks_cmd,
     trajectory as trajectory_cmd,
 )
@@ -139,6 +140,7 @@ app.add_typer(jobs_cmd.app, name="jobs")
 app.add_typer(artifacts_cmd.app, name="artifacts")
 app.add_typer(metadata_cmd.app, name="metadata")
 app.add_typer(brm_cmd.app, name="brm")
+app.add_typer(rsi_cmd.app, name="rsi")
 app.command(
     "ap-cmd",
     context_settings={"allow_extra_args": True, "ignore_unknown_options": True},

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/src/aliyun/bmcli/client.py

@@ -38,6 +38,9 @@ class ArtifactMissingError(ClientError):
     """
 
 
+_SSO_LOGIN_HOST = "login.alibaba-inc.com"
+
+
 class ApiClient:
     """Thin wrapper over ``httpx.Client`` for the benchmark openapi."""
 
@@ -148,11 +151,16 @@ class ApiClient:
         url: str,
         dest_path: str | Path,
         progress: Optional[Any] = None,
+        *,
+        detect_sso_redirect: bool = False,
     ) -> Path:
         """Stream ``url`` to ``dest_path`` on disk. Returns the path written.
 
         ``progress``（可选）需提供 ``begin(total)`` / ``advance(nbytes)`` 两个
         方法（如 ``output.TransferStream``）；每次重试会重新 ``begin`` 归零。
+
+        ``detect_sso_redirect`` 开启时，被网关 302 到 SSO 登录页抛 ``AuthError``；
+        默认关闭，保持"HTML 错误页 = 产物缺失"的既有分类，不影响其他调用方。
         """
         dest = Path(dest_path)
         dest.parent.mkdir(parents=True, exist_ok=True)
@@ -161,6 +169,13 @@ class ApiClient:
             try:
                 with httpx.Client(timeout=self.timeout, follow_redirects=True) as client:
                     with client.stream("GET", self._url(url), headers=self._headers()) as resp:
+                        if detect_sso_redirect and self._is_sso_login_redirect(resp):
+                            # 网关不认 X-API-Key 时会 302 到 SSO 登录页；这是
+                            # 认证问题，不能落入下面的“HTML 错误页=文件缺失”误判。
+                            raise AuthError(
+                                "endpoint requires SSO login (redirected to "
+                                f"{_SSO_LOGIN_HOST}); X-API-Key not accepted"
+                            )
                         if resp.status_code == 401:
                             raise AuthError("authentication failed (HTTP 401)")
                         if resp.status_code == 404:
@@ -199,6 +214,15 @@ class ApiClient:
             raise last_exc
         return dest  # pragma: no cover
 
+    @staticmethod
+    def _is_sso_login_redirect(resp: httpx.Response) -> bool:
+        targets = [r.headers.get("location", "") for r in resp.history]
+        try:
+            targets.append(str(resp.url))
+        except RuntimeError:
+            pass  # resp.request 未设置时（如测试里的裸 Response）没有 url
+        return any(_SSO_LOGIN_HOST in target for target in targets)
+
     @staticmethod
     def _safe_body(resp: httpx.Response) -> Any:
         try:

benchloop_client-0.2.25/src/aliyun/bmcli/commands/rsi.py

@@ -0,0 +1,235 @@
+"""`bmcli rsi` — RSI weakness analysis reports."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import typer
+
+from aliyun.bmcli import output
+from aliyun.bmcli.client import AuthError, NetworkError
+from aliyun.bmcli.commands._common import (
+    GroupOption,
+    JobOption,
+    OutputDirOption,
+    SkipExistingOption,
+    expand,
+    resolve_output_dir,
+)
+from aliyun.bmcli.commands.group_data import (
+    fetch_all_jobs,
+    fetch_job_resources,
+    job_ids,
+    raise_for_failures,
+)
+from aliyun.bmcli.ids import enforce_mutually_exclusive, require_any
+from aliyun.bmcli.runtime import get_runtime, report_and_exit, safe_run_concurrent
+
+app = typer.Typer(help="RSI weakness analysis reports.", no_args_is_help=True)
+
+
+def _guard(groups: list[str], jobs: list[str]) -> None:
+    enforce_mutually_exclusive(groups, jobs)
+    require_any(groups, jobs)
+
+
+def _markdown(data: Any, key: str) -> str:
+    if not isinstance(data, dict):
+        return ""
+    report = data.get("report")
+    if not isinstance(report, dict):
+        return ""
+    content = report.get(key) or ""
+    return content if isinstance(content, str) else ""
+
+
+def _fetch_job(client, job_id: str):
+    return client.get_json(f"/openapi/jobs/{job_id}/rsi")
+
+
+def _fetch_group(client, group_id: str):
+    return client.get_json(f"/openapi/groups/{group_id}/rsi")
+
+
+def _trigger_job(client, job_id: str):
+    return client.post_json(f"/openapi/jobs/{job_id}/rsi/trigger")
+
+
+def _trigger_group(client, group_id: str, include_passed: bool):
+    return client.post_json(
+        f"/openapi/groups/{group_id}/rsi/trigger",
+        {"include_passed": include_passed},
+    )
+
+
+def _write_markdown(content: str, dest, skip_existing: bool):
+    if not content:
+        return None
+    if skip_existing and dest.exists():
+        output.log(f"skip existing {dest}")
+    else:
+        output.write_text_file(dest, content)
+        output.log(f"wrote {dest}")
+    return str(dest)
+
+
+@app.command("get")
+def get(
+    ctx: typer.Context,
+    group: Optional[list[str]] = GroupOption,
+    job: Optional[list[str]] = JobOption,
+) -> None:
+    """Query Job or Group RSI reports; prints a JSON array."""
+    rt = get_runtime(ctx)
+    groups = expand(group)
+    jobs = expand(job)
+    _guard(groups, jobs)
+
+    if jobs:
+        res = safe_run_concurrent(
+            jobs, lambda jid: _fetch_job(rt.client, jid), rt.concurrency
+        )
+    else:
+        res = safe_run_concurrent(
+            groups, lambda gid: _fetch_group(rt.client, gid), rt.concurrency
+        )
+    report_and_exit(res, emit=True, pretty=rt.pretty)
+
+
+@app.command("download")
+def download(
+    ctx: typer.Context,
+    group: Optional[list[str]] = GroupOption,
+    job: Optional[list[str]] = JobOption,
+    output_dir: Optional[str] = OutputDirOption,
+    skip_existing: bool = SkipExistingOption,
+) -> None:
+    """Download RSI report markdown returned inline by the get API."""
+    rt = get_runtime(ctx)
+    groups = expand(group)
+    jobs = expand(job)
+    _guard(groups, jobs)
+    root = resolve_output_dir(rt.output_dir, output_dir)
+
+    def job_worker(job_id: str):
+        try:
+            dest = root / f"{job_id}_rsi.md"
+            if skip_existing and dest.exists():
+                output.log(f"skip existing {dest}")
+                return str(dest)
+            return _write_markdown(
+                _markdown(_fetch_job(rt.client, job_id), "report_md"),
+                dest,
+                skip_existing,
+            )
+        finally:
+            job_progress.advance(job_id)
+
+    def download_group_reports(group_id: str):
+        written = []
+        failures = []
+        try:
+            summary_dest = root / f"{group_id}_rsi.md"
+            if skip_existing and summary_dest.exists():
+                output.log(f"skip existing {summary_dest}")
+                summary = str(summary_dest)
+            else:
+                summary = _write_markdown(
+                    _markdown(_fetch_group(rt.client, group_id), "summary_md"),
+                    summary_dest,
+                    skip_existing,
+                )
+            if summary:
+                written.append(summary)
+        except AuthError:
+            raise
+        except NetworkError as exc:
+            failures.append((f"{group_id}:summary", f"network: {exc}"))
+        except Exception as exc:  # noqa: BLE001 - continue with per-Job reports
+            failures.append((f"{group_id}:summary", str(exc)))
+
+        jobs_data = fetch_all_jobs(rt.client, group_id)
+        ids = job_ids(jobs_data)
+        report_progress = output.ProgressCounter(
+            f"group rsi jobs {group_id}",
+            len(ids),
+            "jobs",
+            action="processed",
+            show_eta=True,
+        )
+        report_progress.start()
+
+        def download_job_report(api, job_id: str):
+            try:
+                dest = root / group_id / f"{job_id}_rsi.md"
+                if skip_existing and dest.exists():
+                    output.log(f"skip existing {dest}")
+                    return str(dest)
+                return _write_markdown(
+                    _markdown(_fetch_job(api, job_id), "report_md"),
+                    dest,
+                    skip_existing,
+                )
+            finally:
+                report_progress.advance(job_id)
+
+        reports = fetch_job_resources(
+            rt.client,
+            ids,
+            download_job_report,
+            rt.concurrency,
+        )
+        written.extend(dest for dest in reports.items if dest)
+        failures.extend(reports.failures)
+        raise_for_failures("rsi reports", failures)
+        return written
+
+    def group_worker(group_id: str):
+        try:
+            return download_group_reports(group_id)
+        finally:
+            group_progress.advance(group_id)
+
+    if jobs:
+        job_progress = output.ProgressCounter(
+            "job rsi downloads", len(jobs), "jobs", action="processed"
+        )
+        job_progress.start()
+        res = safe_run_concurrent(jobs, job_worker, rt.concurrency)
+    else:
+        group_progress = output.ProgressCounter(
+            "group rsi downloads", len(groups), "groups", action="processed"
+        )
+        group_progress.start()
+        res = safe_run_concurrent(groups, group_worker, 1)
+    report_and_exit(res, emit=False)
+
+
+@app.command("trigger")
+def trigger(
+    ctx: typer.Context,
+    group: Optional[list[str]] = GroupOption,
+    job: Optional[list[str]] = JobOption,
+    include_passed: bool = typer.Option(
+        False,
+        "--include-passed",
+        help="Include passed jobs when triggering a Group RSI report.",
+    ),
+) -> None:
+    """Trigger Job or Group RSI report generation."""
+    rt = get_runtime(ctx)
+    groups = expand(group)
+    jobs = expand(job)
+    _guard(groups, jobs)
+
+    if jobs:
+        res = safe_run_concurrent(
+            jobs, lambda jid: _trigger_job(rt.client, jid), rt.concurrency
+        )
+    else:
+        res = safe_run_concurrent(
+            groups,
+            lambda gid: _trigger_group(rt.client, gid, include_passed),
+            rt.concurrency,
+        )
+    report_and_exit(res, emit=True, pretty=rt.pretty)

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/src/aliyun/bmcli/commands/trajectory.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import gzip
 import json
+import mimetypes
 import os
 import shutil
 import tempfile
@@ -282,6 +283,85 @@ def write_group_trajectories(
     return dest
 
 
+_TRACE_MEDIA_ENDPOINT = "/openapi/getTrajV2/mediaFile"
+
+
+def _iter_trace_media(node: Any) -> Iterator[tuple[str, str]]:
+    """Yield ``(oss_uri, mime_type)`` for every ``trace_media`` field in ``node``."""
+    if isinstance(node, dict):
+        media = node.get("trace_media")
+        if isinstance(media, dict):
+            oss_uri = media.get("oss_uri")
+            mime_type = media.get("mime_type")
+            if isinstance(oss_uri, str) and oss_uri.strip():
+                yield (
+                    oss_uri.strip(),
+                    mime_type.strip() if isinstance(mime_type, str) else "",
+                )
+        for value in node.values():
+            yield from _iter_trace_media(value)
+    elif isinstance(node, list):
+        for item in node:
+            yield from _iter_trace_media(item)
+
+
+def _trace_media_download_path(oss_uri: str, mime_type: str) -> str:
+    return (
+        f"{_TRACE_MEDIA_ENDPOINT}"
+        f"?ossUri={quote(oss_uri, safe='')}&mime={quote(mime_type, safe='')}"
+    )
+
+
+def _trace_media_file_name(oss_uri: str, mime_type: str, used_names: set[str]) -> str:
+    raw_name = oss_uri.rstrip("/").rsplit("/", 1)[-1].strip()
+    name = quote(raw_name, safe="-_.")
+    if name in ("", ".", ".."):
+        name = "media"
+    if not Path(name).suffix:
+        name += mimetypes.guess_extension(mime_type) or ""
+    stem, dot, suffix = name.partition(".")
+    candidate = name
+    counter = 2
+    while candidate in used_names:
+        candidate = f"{stem}-{counter}{dot}{suffix}" if dot else f"{name}-{counter}"
+        counter += 1
+    return candidate
+
+
+def _download_trace_media(client, trajectory_path: Path, source_dir: Path) -> list[str]:
+    """Download every OSS file referenced by ``trace_media`` in one trajectory JSON.
+
+    返回错误列表；媒体文件下载失败不影响轨迹本身，由调用方记入 manifest。
+    同一 oss_uri 重复引用只下载一次。
+    """
+    try:
+        payload = json.loads(trajectory_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        return [f"unreadable trajectory json: {exc}"]
+    errors: list[str] = []
+    used_names: set[str] = set()
+    seen_uris: set[str] = set()
+    for oss_uri, mime_type in _iter_trace_media(payload):
+        if oss_uri in seen_uris:
+            continue
+        seen_uris.add(oss_uri)
+        name = _trace_media_file_name(oss_uri, mime_type, used_names)
+        used_names.add(name)
+        try:
+            # SSO 跳转识别只对本媒体下载链路开启，其他 download_file 调用方
+            # 维持原有错误分类不变。
+            client.download_file(
+                _trace_media_download_path(oss_uri, mime_type),
+                source_dir / name,
+                detect_sso_redirect=True,
+            )
+        except Exception as exc:  # noqa: BLE001 - keep the trajectory
+            # 媒体是辅助数据：任何失败（包括跳转 SSO 登录页这类认证问题）都只
+            # 记为媒体级失败，错误信息会保留具体原因，不影响轨迹归档产出。
+            errors.append(f"{oss_uri}: {exc}")
+    return errors
+
+
 def _write_task_archive(
     archive_path: Path,
     task_payload: dict,
@@ -291,15 +371,20 @@ def _write_task_archive(
     *,
     metadata: list[tuple[str, Path]] | None = None,
     metadata_failures: list[tuple[str, str]] | None = None,
+    sources: list[tuple[str, Path]] | None = None,
+    source_failures: list[tuple[str, str]] | None = None,
     pretty: bool,
 ) -> Path:
     """Create the task ZIP atomically from successfully downloaded trajectories.
 
-    归档结构：轨迹在 trajectories/ 目录，job 元数据在 metadata/ 目录（一个
-    job 一个 json），manifest.json 留在根目录。
+    归档结构：轨迹在 trajectories/ 目录，轨迹引用的 trace_media OSS 文件在
+    source/ 目录（一个 job 一个以 job_id 命名的子目录），job 元数据在
+    metadata/ 目录（一个 job 一个 json），manifest.json 留在根目录。
     """
     metadata = metadata or []
     metadata_failures = metadata_failures or []
+    sources = sources or []
+    source_failures = source_failures or []
     manifest = {
         "task_id": task_id,
         "group_id": task_payload.get("group_id"),
@@ -312,6 +397,9 @@ def _write_task_archive(
         "metadata_failures": [
             {"job_id": job_id, "error": error} for job_id, error in metadata_failures
         ],
+        "source_failures": [
+            {"job_id": job_id, "error": error} for job_id, error in source_failures
+        ],
     }
     indent = 2 if pretty else None
     separators = None if pretty else (",", ":")
@@ -345,6 +433,16 @@ def _write_task_archive(
             for job_id, path in downloaded:
                 file_job_id = quote(job_id, safe="-_.")
                 archive.write(path, arcname=f"trajectories/{file_job_id}_trajectory.json")
+            for job_id, source_dir in sources:
+                file_job_id = quote(job_id, safe="-_.")
+                for media_path in sorted(source_dir.rglob("*")):
+                    if not media_path.is_file():
+                        continue
+                    media_arcname = media_path.relative_to(source_dir).as_posix()
+                    archive.write(
+                        media_path,
+                        arcname=f"source/{file_job_id}/{media_arcname}",
+                    )
             for job_id, path in metadata:
                 file_job_id = quote(job_id, safe="-_.")
                 archive.write(path, arcname=f"metadata/{file_job_id}.json")
@@ -447,7 +545,9 @@ def download(
 
             def task_job_worker(
                 job_id: str,
-            ) -> tuple[str, Path, Optional[Path], Optional[str]]:
+            ) -> tuple[
+                str, Path, Optional[Path], Optional[str], Optional[Path], Optional[str]
+            ]:
                 try:
                     data = fetch_job_trajectory(rt.client, quote(job_id, safe=""))
                     # job_id comes from the server-side task snapshot. Encode it
@@ -468,7 +568,16 @@ def download(
                         output.write_json_file(meta_path, meta, pretty=rt.pretty)
                     except Exception as exc:  # noqa: BLE001 - keep trajectory
                         meta_error = str(exc)
-                    return job_id, dest, meta_path, meta_error
+                    # 同步下载轨迹里 trace_media 引用的 OSS 文件；失败不影响轨迹，
+                    # 记入 manifest.source_failures 并计入退出码。
+                    media_dir = temp_root / "source" / file_job_id
+                    media_errors = _download_trace_media(rt.client, dest, media_dir)
+                    media_error = "; ".join(media_errors) if media_errors else None
+                    has_media = media_dir.is_dir() and any(
+                        p.is_file() for p in media_dir.rglob("*")
+                    )
+                    source_dir: Optional[Path] = media_dir if has_media else None
+                    return job_id, dest, meta_path, meta_error, source_dir, media_error
                 finally:
                     # A failed request is still a completed attempt and must move
                     # the visible task progress forward.
@@ -478,15 +587,28 @@ def download(
             if not result.items:
                 report_and_exit(result, emit=False)
 
-            downloaded = [(job_id, path) for job_id, path, _meta, _err in result.items]
+            downloaded = [
+                (job_id, path)
+                for job_id, path, _meta, _err, _src, _src_err in result.items
+            ]
             metadata = [
                 (job_id, meta_path)
-                for job_id, _path, meta_path, _err in result.items
+                for job_id, _path, meta_path, _err, _src, _src_err in result.items
                 if meta_path is not None
             ]
             metadata_failures = [
                 (job_id, error)
-                for job_id, _path, _meta, error in result.items
+                for job_id, _path, _meta, error, _src, _src_err in result.items
+                if error is not None
+            ]
+            sources = [
+                (job_id, source_dir)
+                for job_id, _path, _meta, _err, source_dir, _src_err in result.items
+                if source_dir is not None
+            ]
+            source_failures = [
+                (job_id, error)
+                for job_id, _path, _meta, _err, _src, error in result.items
                 if error is not None
             ]
 
@@ -499,6 +621,8 @@ def download(
                 result.failures,
                 metadata=metadata,
                 metadata_failures=metadata_failures,
+                sources=sources,
+                source_failures=source_failures,
                 pretty=rt.pretty,
             )
 
@@ -506,6 +630,9 @@ def download(
         result.failures.extend(
             (job_id, f"meta: {error}") for job_id, error in metadata_failures
         )
+        result.failures.extend(
+            (job_id, f"source: {error}") for job_id, error in source_failures
+        )
         report_and_exit(result, emit=False)
 
     def job_worker(job_id: str):

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/tests/test_client.py

@@ -8,7 +8,7 @@ from typing import Any
 import httpx
 import pytest
 
-from aliyun.bmcli.client import ApiClient, ArtifactMissingError, NetworkError
+from aliyun.bmcli.client import ApiClient, ArtifactMissingError, AuthError, NetworkError
 
 
 class FakeHttpxClient:
@@ -164,6 +164,68 @@ def test_download_file_rejects_html_error_page(
     assert not (tmp_path / "a.tgz").exists()
 
 
+def test_download_file_redirect_to_sso_login_raises_auth_error(
+    fake_httpx_client: type[FakeHttpxClient], tmp_path
+) -> None:
+    # 网关不认 X-API-Key 时会 302 到 SSO 登录页（HTTP 200 + HTML）：开启
+    # detect_sso_redirect 时必须报成认证失败（AuthError），不能误判成文件缺失。
+    fake_httpx_client.responses = [
+        httpx.Response(
+            200,
+            headers={"content-type": "text/html;charset=utf-8"},
+            content=b"<html>sso login</html>",
+            history=[
+                httpx.Response(
+                    302,
+                    headers={
+                        "location": "https://login.alibaba-inc.com/ssoLogin.htm?backURL=x"
+                    },
+                )
+            ],
+        )
+    ]
+    client = ApiClient("https://example.com", api_key="k", retry=0)
+
+    with pytest.raises(AuthError, match="SSO login.*X-API-Key not accepted"):
+        client.download_file(
+            "/openapi/getTrajV2/mediaFile?ossUri=x&mime=y",
+            tmp_path / "a.png",
+            detect_sso_redirect=True,
+        )
+
+    assert not (tmp_path / "a.png").exists()
+
+
+def test_download_file_sso_redirect_default_keeps_missing_classification(
+    fake_httpx_client: type[FakeHttpxClient], tmp_path
+) -> None:
+    # 默认不开启 SSO 识别：302 到登录页仍按“HTML 错误页 = 文件缺失”分类，
+    # 保持 artifacts / pull 等其他调用方的既有行为不变。
+    fake_httpx_client.responses = [
+        httpx.Response(
+            200,
+            headers={"content-type": "text/html;charset=utf-8"},
+            content=b"<html>sso login</html>",
+            history=[
+                httpx.Response(
+                    302,
+                    headers={
+                        "location": "https://login.alibaba-inc.com/ssoLogin.htm?backURL=x"
+                    },
+                )
+            ],
+        )
+    ]
+    client = ApiClient("https://example.com", api_key="k", retry=0)
+
+    with pytest.raises(ArtifactMissingError, match="html error page"):
+        client.download_file(
+            "/openapi/jobs/J1/artifacts/download", tmp_path / "a.tgz"
+        )
+
+    assert not (tmp_path / "a.tgz").exists()
+
+
 class RecordingProgress:
     """Minimal progress sink implementing begin/advance."""
 

benchloop_client-0.2.25/tests/test_cmd_rsi.py

@@ -0,0 +1,105 @@
+"""Tests for `bmcli rsi get`, `download`, and `trigger`."""
+
+from __future__ import annotations
+
+from aliyun.bmcli.cli import app
+from tests.conftest import invoke, parse_stdout
+
+
+class TestRsiGet:
+    def test_get_job_calls_rsi_endpoint(self, runner, mock_client):
+        mock_client.get_json.return_value = {
+            "entity_type": "job",
+            "job_id": "J1",
+            "status": "not_created",
+            "report": None,
+            "request": None,
+        }
+        result = invoke(runner, ["--api-key", "k", "rsi", "get", "-j", "J1"])
+        assert result.exit_code == 0
+        mock_client.get_json.assert_called_once_with("/openapi/jobs/J1/rsi")
+        data = parse_stdout(result)
+        assert data[0]["status"] == "not_created"
+
+    def test_get_group_calls_group_rsi_endpoint(self, runner, mock_client):
+        mock_client.get_json.return_value = {
+            "entity_type": "group",
+            "group_id": "G1",
+            "status": "created",
+            "report": {"summary_md": "# group"},
+            "request": None,
+        }
+        result = invoke(runner, ["--api-key", "k", "rsi", "get", "-g", "G1"])
+        assert result.exit_code == 0
+        mock_client.get_json.assert_called_once_with("/openapi/groups/G1/rsi")
+        assert parse_stdout(result)[0]["report"]["summary_md"] == "# group"
+
+    def test_get_rejects_mixed_group_and_job(self, runner, mock_client):
+        result = runner.invoke(
+            app,
+            ["--api-key", "k", "rsi", "get", "-g", "G1", "-j", "J1"],
+            catch_exceptions=False,
+        )
+        assert result.exit_code != 0
+
+
+class TestRsiDownload:
+    def test_download_job_writes_inline_markdown(self, runner, mock_client, tmp_path):
+        mock_client.get_json.return_value = {
+            "status": "created",
+            "report": {"report_md": "# job rsi"},
+        }
+        result = invoke(
+            runner,
+            ["--api-key", "k", "rsi", "download", "-j", "J1", "-o", str(tmp_path)],
+        )
+        assert result.exit_code == 0
+        assert (tmp_path / "J1_rsi.md").read_text() == "# job rsi"
+
+    def test_download_skips_when_report_body_missing(self, runner, mock_client, tmp_path):
+        mock_client.get_json.return_value = {"status": "creating", "report": None}
+        result = invoke(
+            runner,
+            ["--api-key", "k", "rsi", "download", "-j", "J1", "-o", str(tmp_path)],
+        )
+        assert result.exit_code == 0
+        assert not (tmp_path / "J1_rsi.md").exists()
+
+    def test_download_group_writes_summary_and_job_reports(self, runner, mock_client, tmp_path):
+        def response(path, params=None):
+            if path == "/openapi/groups/G1/rsi":
+                return {"status": "created", "report": {"summary_md": "# Group"}}
+            if path == "/openapi/jobs":
+                return {"jobs": [{"job_id": "J1"}], "total": 1}
+            if path == "/openapi/jobs/J1/rsi":
+                return {"status": "created", "report": {"report_md": "# J1"}}
+            raise AssertionError(path)
+
+        mock_client.get_json.side_effect = response
+        result = invoke(
+            runner,
+            ["--api-key", "k", "rsi", "download", "-g", "G1", "-o", str(tmp_path)],
+        )
+        assert result.exit_code == 0
+        assert (tmp_path / "G1_rsi.md").read_text() == "# Group"
+        assert (tmp_path / "G1" / "J1_rsi.md").read_text() == "# J1"
+
+
+class TestRsiTrigger:
+    def test_trigger_job(self, runner, mock_client):
+        mock_client.post_json.return_value = {"status": "creating", "accepted": True}
+        result = invoke(runner, ["--api-key", "k", "rsi", "trigger", "-j", "J1"])
+        assert result.exit_code == 0
+        mock_client.post_json.assert_called_once_with("/openapi/jobs/J1/rsi/trigger")
+        assert parse_stdout(result)[0]["status"] == "creating"
+
+    def test_trigger_group_include_passed(self, runner, mock_client):
+        mock_client.post_json.return_value = {"status": "creating", "accepted": True}
+        result = invoke(
+            runner,
+            ["--api-key", "k", "rsi", "trigger", "-g", "G1", "--include-passed"],
+        )
+        assert result.exit_code == 0
+        mock_client.post_json.assert_called_once_with(
+            "/openapi/groups/G1/rsi/trigger", {"include_passed": True}
+        )

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/tests/test_cmd_trajectory.py

@@ -795,3 +795,237 @@ class TestTrajectoryDownloadTask:
         assert result.exit_code == 1
         assert "download task contains no job ids" in result.stderr
         assert not (tmp_path / "T1_trajectories.zip").exists()
+
+
+class TestTraceMediaDownload:
+    @staticmethod
+    def trajectory_with_media():
+        return {
+            "job_id": "J1",
+            "trajectory": [
+                {
+                    "messages": [
+                        {
+                            "role": "tool",
+                            "parts": [
+                                {
+                                    "response": [
+                                        {
+                                            "trace_media": {
+                                                "mime_type": "image/png",
+                                                "oss_uri": "oss://bucket/a/b/shot.png",
+                                            },
+                                            "type": "input_image",
+                                        }
+                                    ]
+                                }
+                            ],
+                        }
+                    ]
+                }
+            ],
+        }
+
+    def test_task_download_archives_trace_media_under_source_dir(
+        self, runner, mock_client, tmp_path
+    ):
+        def response(path, params=None):
+            if path == "/openapi/trajectory-download-tasks/T1":
+                return TestTrajectoryDownloadTask.task_payload(["J1"])
+            if path.endswith("/meta"):
+                return {"job_id": "J1"}
+            return self.trajectory_with_media()
+
+        def download_file(url, dest_path, progress=None, detect_sso_redirect=False):
+            assert url == (
+                "/openapi/getTrajV2/mediaFile"
+                "?ossUri=oss%3A%2F%2Fbucket%2Fa%2Fb%2Fshot.png&mime=image%2Fpng"
+            )
+            assert detect_sso_redirect is True
+            dest = Path(dest_path)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_bytes(b"png-bytes")
+            return dest
+
+        mock_client.get_json.side_effect = response
+        mock_client.download_file.side_effect = download_file
+        result = invoke(
+            runner,
+            [
+                "--api-key",
+                "k",
+                "trajectory",
+                "download",
+                "--task-id",
+                "T1",
+                "-o",
+                str(tmp_path),
+            ],
+        )
+
+        assert result.exit_code == 0
+        with zipfile.ZipFile(tmp_path / "T1_trajectories.zip") as archive:
+            assert set(archive.namelist()) == {
+                "trajectories/J1_trajectory.json",
+                "metadata/J1.json",
+                "source/J1/shot.png",
+                "manifest.json",
+            }
+            assert archive.read("source/J1/shot.png") == b"png-bytes"
+            manifest = json.loads(archive.read("manifest.json"))
+        assert manifest["source_failures"] == []
+
+    def test_trace_media_failure_keeps_trajectory_and_records_manifest(
+        self, runner, mock_client, tmp_path
+    ):
+        def response(path, params=None):
+            if path == "/openapi/trajectory-download-tasks/T1":
+                return TestTrajectoryDownloadTask.task_payload(["J1"])
+            if path.endswith("/meta"):
+                return {"job_id": "J1"}
+            return self.trajectory_with_media()
+
+        mock_client.get_json.side_effect = response
+        mock_client.download_file.side_effect = RuntimeError("oss unreachable")
+        result = invoke(
+            runner,
+            [
+                "--api-key",
+                "k",
+                "trajectory",
+                "download",
+                "--task-id",
+                "T1",
+                "-o",
+                str(tmp_path),
+            ],
+        )
+
+        # 媒体文件失败不丢轨迹：zip 照常产出，但退出码为部分失败并记入 manifest。
+        archive_path = tmp_path / "T1_trajectories.zip"
+        assert result.exit_code == 1
+        assert "source: " in result.stderr
+        with zipfile.ZipFile(archive_path) as archive:
+            names = set(archive.namelist())
+            assert "trajectories/J1_trajectory.json" in names
+            assert not any(name.startswith("source/") for name in names)
+            manifest = json.loads(archive.read("manifest.json"))
+        assert manifest["successful_jobs"] == 1
+        assert manifest["source_failures"] == [
+            {"job_id": "J1", "error": "oss://bucket/a/b/shot.png: oss unreachable"}
+        ]
+
+    def test_download_trace_media_dedupes_uris_and_guesses_extension(self, tmp_path):
+        from aliyun.bmcli.commands.trajectory import _download_trace_media
+
+        trajectory_path = tmp_path / "J1_trajectory.json"
+        trajectory_path.write_text(
+            json.dumps(
+                {
+                    "trajectory": [
+                        {
+                            "trace_media": {
+                                "oss_uri": "oss://b/a/shot.png",
+                                "mime_type": "image/png",
+                            }
+                        },
+                        {
+                            "trace_media": {
+                                "oss_uri": "oss://b/a/shot.png",
+                                "mime_type": "image/png",
+                            }
+                        },
+                        {
+                            "trace_media": {
+                                "oss_uri": "oss://b/c/shot.png",
+                                "mime_type": "image/png",
+                            }
+                        },
+                        {
+                            "trace_media": {
+                                "oss_uri": "oss://b/a/video",
+                                "mime_type": "video/mp4",
+                            }
+                        },
+                        {"trace_media": {"mime_type": "image/png"}},
+                        {"trace_media": "not-a-dict"},
+                    ]
+                }
+            ),
+            encoding="utf-8",
+        )
+        calls = []
+
+        class FakeClient:
+            def download_file(self, url, dest_path, progress=None, **kwargs):
+                calls.append(url)
+                dest = Path(dest_path)
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                dest.write_bytes(b"x")
+                return dest
+
+        errors = _download_trace_media(
+            FakeClient(), trajectory_path, tmp_path / "source" / "J1"
+        )
+
+        assert errors == []
+        assert calls == [
+            "/openapi/getTrajV2/mediaFile?ossUri=oss%3A%2F%2Fb%2Fa%2Fshot.png&mime=image%2Fpng",
+            "/openapi/getTrajV2/mediaFile?ossUri=oss%3A%2F%2Fb%2Fc%2Fshot.png&mime=image%2Fpng",
+            "/openapi/getTrajV2/mediaFile?ossUri=oss%3A%2F%2Fb%2Fa%2Fvideo&mime=video%2Fmp4",
+        ]
+        assert sorted(p.name for p in (tmp_path / "source" / "J1").iterdir()) == [
+            "shot-2.png",
+            "shot.png",
+            "video.mp4",
+        ]
+
+    def test_trace_media_auth_error_is_recorded_and_archive_kept(
+        self, runner, mock_client, tmp_path
+    ):
+        # 媒体下载跳转到 SSO 登录页 = 认证问题：错误信息要明确（不误报文件缺失），
+        # 但媒体是辅助数据——轨迹归档照常产出，记入 source_failures，退出码 1。
+        from aliyun.bmcli.client import AuthError
+
+        def response(path, params=None):
+            if path == "/openapi/trajectory-download-tasks/T1":
+                return TestTrajectoryDownloadTask.task_payload(["J1"])
+            if path.endswith("/meta"):
+                return {"job_id": "J1"}
+            return self.trajectory_with_media()
+
+        mock_client.get_json.side_effect = response
+        mock_client.download_file.side_effect = AuthError(
+            "endpoint requires SSO login (redirected to login.alibaba-inc.com); "
+            "X-API-Key not accepted"
+        )
+        result = invoke(
+            runner,
+            [
+                "--api-key",
+                "k",
+                "trajectory",
+                "download",
+                "--task-id",
+                "T1",
+                "-o",
+                str(tmp_path),
+            ],
+        )
+
+        archive_path = tmp_path / "T1_trajectories.zip"
+        assert result.exit_code == 1
+        assert "SSO login" in result.stderr
+        assert archive_path.exists()
+        with zipfile.ZipFile(archive_path) as archive:
+            names = set(archive.namelist())
+            assert "trajectories/J1_trajectory.json" in names
+            assert not any(name.startswith("source/") for name in names)
+            manifest = json.loads(archive.read("manifest.json"))
+        assert manifest["source_failures"] == [
+            {
+                "job_id": "J1",
+                "error": "oss://bucket/a/b/shot.png: endpoint requires SSO login "
+                "(redirected to login.alibaba-inc.com); X-API-Key not accepted",
+            }
+        ]

{benchloop_client-0.2.24 → benchloop_client-0.2.25}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.10"
 
 [[package]]
@@ -27,7 +27,7 @@ wheels = [
 
 [[package]]
 name = "benchloop-client"
-version = "0.2.24"
+version = "0.2.18"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },