instance-repo 1.0.9.dev0__tar.gz → 1.0.9.dev1__tar.gz

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instance-repo
-Version: 1.0.9.dev0
+Version: 1.0.9.dev1
 Summary: InstanceRepo SDK — 评测 Instance 统一存储客户端（SDK-only；控制面由 apiserver 承载）
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/__init__.py

@@ -18,7 +18,7 @@ from .errors import (
     TransportError,
 )
 
-__version__ = "1.0.9.dev0"
+__version__ = "1.0.9.dev1"
 
 __all__ = [
     "Repo", "load_instances",

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/cli.py

@@ -912,9 +912,11 @@ def main(argv=None, *, repo: Repo | None = None, out=None) -> int:
                                 status=args.status,
                                 page=args.page, page_size=args.page_size)
             for s in res.items:
+                src = "projected" if s.projected else "record"
                 print(f"{s.name}\tversion={s.version or ''}\tstatus={s.status}"
                       f"\trun_type={s.run_type or ''}\t"
-                      f"instance_count={_split_instance_count(s)}", file=out)
+                      f"instance_count={_split_instance_count(s)}\t[{src}]",
+                      file=out)
             print(f"page={res.page}/{_page_count(res)} total={res.total}", file=out)
             return 0
         # get / set-run-type：需要定位到具体 split
@@ -923,8 +925,10 @@ def main(argv=None, *, repo: Repo | None = None, out=None) -> int:
             sp = r.splits.get(dataset, split_name, version=args.version)
             if sp is None:
                 raise SystemExit(f"split {dataset}/{split_name} not found")
+            src = "projected" if sp.projected else "record"
             print(f"split\t{sp.name}\tversion={sp.version or ''}"
-                  f"\tstatus={sp.status}\trun_type={sp.run_type or ''}", file=out)
+                  f"\tstatus={sp.status}\trun_type={sp.run_type or ''}"
+                  f"\t[{src}]", file=out)
             print(f"storage_path={sp.storage_path}", file=out)
             print(f"published_at={sp.published_at or ''}"
                   f"\tlast_ingested_at={sp.last_ingested_at or ''}", file=out)
@@ -995,14 +999,20 @@ def main(argv=None, *, repo: Repo | None = None, out=None) -> int:
             return 0
         if args.action in ("access", "revoke"):
             if args.action == "access":
-                res = r.datasets.list_access(dataset,
-                                             page=args.page, page_size=args.page_size)
-                for rb in res.items:
+                # 自动翻页取全量（服务端默认 20 会漏绑定量大的 dataset）
+                page_n, all_items = 1, []
+                while True:
+                    res = r.datasets.list_access(dataset,
+                                                 page=page_n, page_size=200)
+                    all_items.extend(res.items)
+                    if not res.has_more or not res.items:
+                        break
+                    page_n += 1
+                for rb in all_items:
                     print(f"{rb.principal_type}\t{rb.principal_id}\t{rb.role_id}"
                           f"\tadded_by={rb.added_by}\tadded_at={rb.added_at}",
                           file=out)
-                print(f"page={res.page}/{_page_count(res)} total={res.total}",
-                      file=out)
+                print(f"total={len(all_items)}", file=out)
                 return 0
             if not (args.principal and args.role):
                 raise SystemExit("dataset revoke 需要 --principal + --role")

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/clients/datasets.py

@@ -372,13 +372,16 @@ class DatasetsClient:
             f"{self._BASE}/{quote(dataset_id, safe='')}/claim", body)
 
 
+# 与 apiserver `DatasetListItem`（pkg/server/dataset_service.go:231）逐字段对齐。
 _SERIES_FIELDS = ("dataset_name", "dataset_l1", "dataset_l2", "dataset_id",
                   "teacher_direction", "teacher_type", "benchmark_id", "visibility",
                   "owner_team_id", "display_name", "description", "default_scaffold",
-                  "owner", "version_count", "split_count", "latest_version",
+
+                  "owner", "status", "version_count", "split_count", "latest_version",
                   "claimable", "updated_at", "available_envs")
 
 
+
 # TEACHER_ENUMS 是 teacher 级联标签（teacher_direction → 允许的 teacher_type 列表）的
 # **参考快照**，供本地填参/校验提示使用。
 #

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/clients/instances.py

@@ -28,6 +28,17 @@ from ..validate import (check_layout, check_swe_json, check_custom,
 logger = logging.getLogger(__name__)
 
 
+def _registry_overrides(environment: str | None,
+                        metadata_model: str | None) -> dict:
+    """把显式指定的 environment / metadata_model 变成注册表调用参数(缺省不下发)。"""
+    overrides: dict = {}
+    if environment is not None:
+        overrides["environment"] = environment
+    if metadata_model is not None:
+        overrides["metadata_model"] = metadata_model
+    return overrides
+
+
 class InstancesClient:
     # registry 的 BASE 同值；此处独立声明使 list_paged/update 等纯控制面方法
     # 不依赖注入的 registry（直构客户端亦可调用）。
@@ -81,12 +92,26 @@ class InstancesClient:
         return check_layout(local_path)
 
     def get(self, dataset: str, version: str, instance_id: str,
-            split: str | None = None) -> DatasetInstance | None:
-        return self._reg.get(dataset, version, instance_id, split)
+            split: str | None = None, *,
+            environment: str | None = None,
+            metadata_model: str | None = None) -> DatasetInstance | None:
+        """取单个实例；不存在返回 None。
+
+        ``environment`` / ``metadata_model`` 传 None 用 profile 派生的值（默认行为
+        不变）；显式传值可覆盖本次调用——CLI 需要读 online 集合时不必重建 Repo。
+        """
+        # 只在调用方显式指定时才下发覆盖参数:注册表是可注入实现,
+        # 保持缺省调用形态与历史一致,避免破坏既有实现。
+        overrides = _registry_overrides(environment, metadata_model)
+        return self._reg.get(dataset, version, instance_id, split, **overrides)
 
     def list(self, dataset: str, version: str,
-             split: str | None = None) -> list[DatasetInstance]:
-        return self._reg.query(dataset, version, split)
+             split: str | None = None, *,
+             environment: str | None = None,
+             metadata_model: str | None = None) -> list[DatasetInstance]:
+        """自动翻页取全量；``environment`` / ``metadata_model`` 语义同 :meth:`get`。"""
+        overrides = _registry_overrides(environment, metadata_model)
+        return self._reg.query(dataset, version, split, **overrides)
 
     def list_paged(self, dataset: str, version: str = "", *,
                    split: str | None = None, q: str | None = None,

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/clients/splits.py

@@ -88,6 +88,11 @@ class SplitsClient:
         rows = data.get("splits", data) if isinstance(data, dict) else data
         rows = rows if isinstance(rows, list) else []
         items = [DatasetSplit.from_dict(r) for r in rows if isinstance(r, dict)]
+        # 存量数据回退：split-first 集合无记录（version_first 存量）时，聚合
+        # version 内嵌 splits[] 投影。仅当直查**零记录**且未按 status 过滤时
+        # 触发（投影无 status，过滤必为空，回退无意义）。
+        if not items and not (status or "").strip():
+            items = self._legacy_list(dataset, version, self._env(environment))
         return PagedResult.from_response(items, pagination, int(page), int(page_size))
 
     def get(self, dataset: str, split: str, *, version: str | None = None,
@@ -97,6 +102,12 @@ class SplitsClient:
         只吞 HTTP 404（服务端 split 不存在）；dataset 名拼错等服务端也按 404 报，
         此处不区分（split detail 端点无独立业务码可判——与 instances.get 的
         92003/92001 二分不同，这里统一 None，调用方拿不准时用 datasets.get 核对）。
+
+        **存量数据回退（1.0.10 真机反馈）**：split 记录只存在于 split_first
+        新数据（split-first 集合）；存量 version_first 数据的 split 内嵌在
+        version 文档 ``splits[]`` 里，split detail 端点 404。此时回退到
+        versions.get 的内嵌投影（``projected=True``，无 status/published_at，
+        storage_path 取自 oss_prefix）；仍找不到才返回 None。
         """
         if not (dataset or "").strip():
             raise SchemaError("dataset is required for splits.get")
@@ -113,10 +124,102 @@ class SplitsClient:
             data = self._t.get(f"{self._BASE}/detail?{q}")
         except TransportError as e:
             if e.status == 404:
-                return None
+                return self._legacy_get(dataset, split, version, env)
             raise
         return DatasetSplit.from_dict(data) if isinstance(data, dict) else None
 
+    # ── 存量数据兼容投影（version_first 的 split 内嵌在 version 文档里）──
+
+    def _legacy_get(self, dataset: str, split: str, version: str | None,
+                    env: str) -> DatasetSplit | None:
+        """split detail 404 后的回退：读 version 内嵌 splits[] 投影。
+
+        有 version 时单查该 version；无 version 时扫描全部 version（分页）
+        直到命中。返回 projected=True 的 DatasetSplit；仍无则 None。
+        TransportError 按 status 区分：404 重试/继续（version 不存在/实例
+        未找到属正常），5xx 与连接错误重抛——不把网络故障伪装成"数据不存在"。
+        """
+        from .versions import VersionsClient
+        vc = VersionsClient(self._t, self._p)
+        if (version or "").strip():
+            try:
+                detail = vc.get(dataset, version, environment=env or None)
+            except TransportError as e:
+                if e.status == 404:
+                    return None   # version 不存在 → 回退无果
+                raise
+            return _project_embedded_split(detail, split, version, dataset)
+        # 无 version：扫描全部 version
+        page = 1
+        while True:
+            try:
+                res = vc.list_paged(dataset, page=page, page_size=200,
+                                    environment=env or None)
+            except TransportError as e:
+                if e.status == 404:
+                    return None   # dataset 不存在 → 终止扫描
+                raise
+            for item in res.items:
+                try:
+                    detail = vc.get(dataset, item.version,
+                                    environment=env or None)
+                except TransportError as e:
+                    if e.status == 404:
+                        continue  # 该 version 不存在，继续找下一个
+                    raise
+                found = _project_embedded_split(detail, split,
+                                                item.version, dataset)
+                if found is not None:
+                    return found
+            if not res.has_more or not res.items:
+                break
+            page += 1
+        return None
+
+    def _legacy_list(self, dataset: str, version: str | None, env: str
+                     ) -> list[DatasetSplit]:
+        """split 集合无记录时的回退：聚合全部 version 的内嵌 splits[] 投影。
+
+        投影项无 status/published_at（内嵌字段集只有 name/run_type/oss_prefix/
+        is_default/instance_count 等），因此 status 过滤对存量数据天然为空——
+        如实返回空列表而非伪造状态。
+        TransportError 按 status 区分：404→跳过/终止；其他重抛。
+        """
+        from .versions import VersionsClient
+        vc = VersionsClient(self._t, self._p)
+        out: list[DatasetSplit] = []
+        if (version or "").strip():
+            try:
+                detail = vc.get(dataset, version, environment=env or None)
+            except TransportError as e:
+                if e.status == 404:
+                    return out   # version 不存在，无数据可投影
+                raise
+            return _project_all_embedded_splits(detail, version, dataset)
+        page = 1
+        while True:
+            try:
+                res = vc.list_paged(dataset, page=page, page_size=200,
+                                    environment=env or None)
+            except TransportError as e:
+                if e.status == 404:
+                    break         # dataset 不存在，终止扫描
+                raise
+            for item in res.items:
+                try:
+                    detail = vc.get(dataset, item.version,
+                                    environment=env or None)
+                except TransportError as e:
+                    if e.status == 404:
+                        continue  # 该 version 不存在
+                    raise
+                out.extend(_project_all_embedded_splits(
+                    detail, item.version, dataset))
+            if not res.has_more or not res.items:
+                break
+            page += 1
+        return out
+
     # ── 写 ──
 
     def update(self, dataset: str, split: str | None = None, *,
@@ -168,3 +271,55 @@ def normalize_split_version_scope(version: str | None,
                 f"{', '.join(VERSION_SCOPE_VALUES)}")
         return scope
     return "all" if not (version or "").strip() else "exact"
+
+
+# ── 存量数据内嵌 splits[] 投影 ────────────────────────────────────────────────
+
+def _embedded_splits_of(detail) -> list:
+    """取 version 详情的内嵌 splits[]（兼容 dict 与 DatasetVersion 对象）。"""
+    if detail is None:
+        return []
+    if isinstance(detail, dict):
+        return detail.get("splits") or []
+    return getattr(detail, "splits", None) or []
+
+
+def _project_embedded_split(detail, split: str, version: str,
+                            dataset: str) -> "DatasetSplit | None":
+    """从 versions/detail 响应投影单个 split（projected=True）。
+
+    内嵌字段集：{name, run_type?, oss_prefix, is_default, instance_count?,
+    file_count?, size_bytes?}——无 status/published_at/storage_path。
+    """
+    for sp in _embedded_splits_of(detail):
+        if not isinstance(sp, dict) or sp.get("name") != split:
+            continue
+        return _build_projected_split(sp, version, dataset)
+    return None
+
+
+def _project_all_embedded_splits(detail, version: str,
+                                 dataset: str) -> list["DatasetSplit"]:
+    """从 versions/detail 响应投影全部内嵌 split（projected=True）。"""
+    return [_build_projected_split(sp, version, dataset)
+            for sp in _embedded_splits_of(detail) if isinstance(sp, dict)]
+
+
+def _build_projected_split(sp: dict, version: str,
+                           dataset: str) -> "DatasetSplit":
+    from ..models import SplitManifest
+    manifest = SplitManifest(
+        instance_count=sp.get("instance_count"),
+        file_count=sp.get("file_count"),
+        size_bytes=sp.get("size_bytes"))
+    return DatasetSplit(
+        dataset=dataset,
+        dataset_id="",
+        dataset_version_id=None,        # 内嵌投影拿不到 version 记录 id
+        version=version,
+        name=sp.get("name", ""),
+        run_type=sp.get("run_type"),
+        status="",                      # 内嵌无 status
+        storage_path=sp.get("oss_prefix", ""),
+        manifest=manifest,
+        projected=True)

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/clients/versions.py

@@ -799,8 +799,14 @@ class VersionsClient:
         return last
 
 
+# 与 apiserver `DatasetVersionListItem`（pkg/server/dataset_service.go:315）对齐:
+# 列表项带 instance_count/split_count/updated_at/last_ingested_at,详情接口才带
+# splits/manifest/run_type/created_by/published_at —— 两者都收进模型。
 _FIELDS = ("version", "dataset", "status", "dataset_version_id",
-           "storage_path", "published_at")
+
+           "storage_path", "published_at",
+           "instance_count", "split_count", "last_ingested_at", "updated_at")
+
 
 
 def _pick(d: dict) -> dict:
@@ -808,4 +814,7 @@ def _pick(d: dict) -> dict:
     out.setdefault("version", d.get("version", ""))
     out.setdefault("dataset", d.get("dataset", ""))
     out.setdefault("status", d.get("status", "draft"))
+    # 列表项**不带** storage_type，「缺省即 oss」的模型默认值会让调用方以为服务端
+    # 返回了它（CLI 原样透出服务端响应，凭空多字段就是契约变更）。这里显式给 None。
+    out.setdefault("storage_type", d.get("storage_type"))
     return out

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/models.py

@@ -80,12 +80,17 @@ class ManifestEntry:
     content_type: str = "file"
     content_format: str = "json"
     content_digest: str | None = None
+    #: 服务端返回的对象相对路径（`GET /datasets/instances` 的 manifest 项带
+    #: `object_path`）；本地扫描出的条目为 None，不进 to_dict，保证推送载荷不变。
+    object_path: str | None = None
 
     def to_dict(self) -> dict:
         d = {"file_path": self.file_path, "content_type": self.content_type,
              "content_format": self.content_format}
         if self.content_digest is not None:
             d["content_digest"] = self.content_digest
+        if self.object_path is not None:
+            d["object_path"] = self.object_path
         return d
 
 
@@ -117,6 +122,9 @@ class DatasetSeries:
     claimable: bool | None = None
     updated_at: str | None = None
     available_envs: list[str] = field(default_factory=list)
+    # 服务端 `DatasetSeriesStatus`（"" 正常 / "deprecated"）；列表项
+    # `DatasetListItem.Status` 带 `omitempty`，正常态不出现。
+    # 与 class 开头 status 字段合并到此位置。
 
     def validate(self) -> None:
         if self.visibility not in VISIBILITY_VALUES:
@@ -163,6 +171,11 @@ class DatasetVersion:
     updated_at: str | None = None
     parent_shell: bool = False
 
+    # ── 列表项统计字段（GET /datasets/versions 每项返回 instance_count/split_count）──
+
+    instance_count: int | None = None
+    split_count: int | None = None
+
     def validate(self) -> None:
         if self.status not in VERSION_STATUS_VALUES:
             raise SchemaError(f"invalid status '{self.status}'; valid values: {', '.join(VERSION_STATUS_VALUES)}")
@@ -208,6 +221,9 @@ class DatasetInstance:
     instance_version: str | None = None
     feedbacks: str | None = None
     schema_version: str = "1.0"
+    #: 服务端返回的时间戳；本地扫描构造的实例为 None，不进 to_dict（推送载荷不变）。
+    created_at: str | None = None
+    updated_at: str | None = None
 
     def validate(self) -> None:
         if not self.instance_id:
@@ -229,7 +245,7 @@ class DatasetInstance:
             "schema_version": self.schema_version,
         }
         for k in ("id", "difficulty", "docker_image", "instance_status",
-                  "instance_version", "feedbacks"):
+                  "instance_version", "feedbacks", "created_at", "updated_at"):
             v = getattr(self, k)
             if v is not None:
                 d[k] = v
@@ -248,6 +264,7 @@ class DatasetInstance:
                 content_type=m.get("content_type", "file"),
                 content_format=m.get("content_format", "json"),
                 content_digest=m.get("content_digest"),
+                object_path=m.get("object_path"),
             )
             for m in (d.get("manifest") or [])
         ]
@@ -270,6 +287,8 @@ class DatasetInstance:
             instance_version=d.get("instance_version"),
             feedbacks=d.get("feedbacks"),
             schema_version=d.get("schema_version", "1.0"),
+            created_at=d.get("created_at"),
+            updated_at=d.get("updated_at"),
         )
 
 
@@ -514,6 +533,10 @@ class PagedResult:
     page: int = 1
     page_size: int = 0
     has_more: bool = False
+    #: 服务端返回的**原始**分页信封（键名原样,如 ``pageSize``）；无信封时为 None。
+    #: 给需要逐字透出服务端响应的调用方（CLI 的 ``pagination`` 字段就是原样透出,
+    #: 用归一化后的 ``page_size`` 会改变既有 JSON 契约）。
+    raw: dict | None = None
 
     @classmethod
     def from_response(cls, items: list, pagination: dict | None,
@@ -523,7 +546,8 @@ class PagedResult:
             total = total if isinstance(total, (int, float)) else -1
             return cls(items=items, total=int(total), page=page,
                        page_size=page_size,
-                       has_more=page * page_size < total)
+                       has_more=page * page_size < total,
+                       raw=dict(pagination))
         return cls(items=items, total=-1, page=page, page_size=page_size,
                    has_more=False)
 
@@ -554,8 +578,13 @@ class DatasetSplit:
     """split-first 记录（GET /datasets/splits 系列返回的 DatasetSplitRecord）。
 
     ``version`` 为空表示 unversioned split（split_first 无版本布局）。
+    ``projected=True`` 表示本对象来自 version 内嵌 ``splits[]`` 的兼容投影
+    （存量 version_first 数据无独立 split 记录，SplitsClient 回退投影）：
+    ``dataset_split_id``/``status``/``published_at`` 均为空，``storage_path``
+    取自内嵌 ``oss_prefix``。
     """
     dataset_split_id: str = ""
+    projected: bool = False
     dataset: str = ""
     dataset_id: str = ""
     dataset_version_id: str | None = None
@@ -577,6 +606,7 @@ class DatasetSplit:
         m = d.get("manifest")
         return cls(
             dataset_split_id=d.get("dataset_split_id", ""),
+            projected=bool(d.get("projected", False)),
             dataset=d.get("dataset", ""),
             dataset_id=d.get("dataset_id", ""),
             dataset_version_id=d.get("dataset_version_id"),

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo/store/registry.py

@@ -62,7 +62,9 @@ class ApiMetadataRegistry(BaseMetadataRegistry):
         self._metadata_model = (metadata_model or "").strip()
 
     def _q(self, dataset: str, version: str, split: str | None = None,
-           instance_id: str | None = None) -> str:
+           instance_id: str | None = None, *,
+           environment: str | None = None,
+           metadata_model: str | None = None) -> str:
         """读路径查询串：与写路径（ingest）对称下发 metadata_model 与 environment。
 
         两个字段都**必须**对称：写路径由 storage_env 派生 environment（dev→pre）写入 pre
@@ -70,14 +72,21 @@ class ApiMetadataRegistry(BaseMetadataRegistry):
         服务端对读请求同样把空 metadata_model 归一为 version_first，而 SDK 默认
         split_first，不显式下发就会用旧语义去查 split-first 数据。environment 为空时
         省略（服务端按 online 缺省，保留未配置 storage_env 的旧行为）。
+
+        ``environment`` / ``metadata_model`` 传 None 用构造期值，传非 None（含空串）
+        覆盖本次调用——调用方（如 CLI 的 ``--environment``）需要显式指定集合时用它，
+        不必按环境重建整个 Repo。
         """
+        model = (self._metadata_model if metadata_model is None
+                 else metadata_model).strip()
+        env = (self._environment if environment is None else environment).strip()
         base = _q(dataset, version, split, instance_id,
-                  keep_default_split=(self._metadata_model == "split_first"))
+                  keep_default_split=(model == "split_first"))
         extra = []
-        if self._metadata_model:
-            extra.append(f"metadata_model={quote(self._metadata_model, safe='')}")
-        if self._environment:
-            extra.append(f"environment={quote(self._environment, safe='')}")
+        if model:
+            extra.append(f"metadata_model={quote(model, safe='')}")
+        if env:
+            extra.append(f"environment={quote(env, safe='')}")
         return base + ("&" + "&".join(extra) if extra else "")
 
     def register(self, meta: DatasetInstance) -> DatasetInstance:
@@ -137,7 +146,9 @@ class ApiMetadataRegistry(BaseMetadataRegistry):
         return DatasetInstance.from_dict(data)
 
     def get(self, dataset: str, version: str, instance_id: str,
-            split: str | None = None) -> DatasetInstance | None:
+            split: str | None = None, *,
+            environment: str | None = None,
+            metadata_model: str | None = None) -> DatasetInstance | None:
         """取单个实例；**实例不存在返回 None**（"没有"不是错误）。
 
         apiserver 对"实例不存在"回 HTTP 404 + 业务码 92003，对"数据集不存在"回 404 +
@@ -145,7 +156,8 @@ class ApiMetadataRegistry(BaseMetadataRegistry):
         """
         try:
             data = self._t.get(
-                f"{self._BASE}/detail?{self._q(dataset, version, split, instance_id)}")
+                f"{self._BASE}/detail?"
+                f"{self._q(dataset, version, split, instance_id, environment=environment, metadata_model=metadata_model)}")
         except TransportError as e:
             if e.status == 404 and e.biz_code == CODE_INSTANCE_NOT_FOUND:
                 return None
@@ -155,7 +167,9 @@ class ApiMetadataRegistry(BaseMetadataRegistry):
         return DatasetInstance.from_dict(data)
 
     def query(self, dataset: str, version: str,
-              split: str | None = None) -> list[DatasetInstance]:
+              split: str | None = None, *,
+              environment: str | None = None,
+              metadata_model: str | None = None) -> list[DatasetInstance]:
         # 分页遍历：服务端 page_size 上限 200，默认只回第一页（真机踩坑：1580 实例
         # 只读回 50）。显式传 page_size=200 并按 pagination.total 翻页取满；
         # 旧服务端不带 pagination 信封时单页即全部，行为与修复前一致。
@@ -163,7 +177,8 @@ class ApiMetadataRegistry(BaseMetadataRegistry):
         page = 1
         while True:
             data, pagination = self._t.request_with_meta(
-                "GET", f"{self._BASE}?{self._q(dataset, version, split)}"
+                "GET", f"{self._BASE}?"
+                       f"{self._q(dataset, version, split, environment=environment, metadata_model=metadata_model)}"
                        f"&page={page}&page_size=200")
             rows = data.get("instances", data) if isinstance(data, dict) else data
             rows = rows if isinstance(rows, list) else []  # 非列表（裸 dict 等）→ 空结果

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/instance_repo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instance-repo
-Version: 1.0.9.dev0
+Version: 1.0.9.dev1
 Summary: InstanceRepo SDK — 评测 Instance 统一存储客户端（SDK-only；控制面由 apiserver 承载）
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{instance_repo-1.0.9.dev0 → instance_repo-1.0.9.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "instance-repo"
-version = "1.0.9.dev0"
+version = "1.0.9.dev1"
 description = "InstanceRepo SDK — 评测 Instance 统一存储客户端（SDK-only；控制面由 apiserver 承载）"
 requires-python = ">=3.10"
 readme = "README.md"