intellif-aihub 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

aihub/services/dataset_management.py

@@ -1,28 +1,48 @@
+# !/usr/bin/env python
+# -*- coding:utf-8 -*-
+"""数据集管理服务模块
+
+本模块围绕 **“数据集生命周期管理”** 提供以下能力：
+
+- **创建数据集及其版本**（支持本地上传和服务器现有文件两种方式）
+- **上传文件到对象存储**（大文件自动分片）
+- **查询数据集／数据集版本详情**
+- **按版本名称或ID下载数据集文件**
+"""
+
 from __future__ import annotations
 
 import mimetypes
 import os
 import pathlib
+import tempfile
+import time
+import uuid
 
 import httpx
+from loguru import logger
 
 from ..exceptions import APIError
 from ..models.common import APIWrapper
-from ..models.dataset_management import *
-from ..utils.download import dataset_download
+from ..models.dataset_management import (
+    CreateDatasetRequest,
+    CreateDatasetResponse,
+    DatasetDetail,
+    CreateDatasetVersionRequest,
+    CreateDatasetVersionResponse,
+    UploadDatasetVersionRequest,
+    DatasetVersionDetail,
+    UploadDatasetVersionResponse,
+    FileUploadData,
+)
+from ..models.dataset_management import DatasetVersionStatus
+from ..utils.download import dataset_download, zip_dir
 
 _BASE = "/dataset-mng/api/v2"
 
 
 class DatasetManagementService:
-    """数据集管理服务，用于数据集的上传、下载
-
-    Methods:
-        create_dataset_and_version: 创建数据集版本
-        run_download: 下载
-
-
-    """
+    """数据集管理服务，用于数据集的上传、下载"""
 
     def __init__(self, http: httpx.Client):
         self._dataset = _Dataset(http)
@@ -31,24 +51,80 @@ class DatasetManagementService:
 
     # 直接把常用方法抛到一级，调用体验简单
     def create_dataset(self, payload: CreateDatasetRequest) -> int:
+        """创建数据集
+
+        Args:
+            payload (CreateDatasetRequest): 创建数据集所需信息，如名称、描述、可见性等
+
+        Returns:
+            int: 新建数据集的 ``dataset_id``
+        """
         return self._dataset.create(payload)
 
     def get_dataset(self, dataset_id: int) -> DatasetDetail:
+        """获取数据集详情
+
+        Args:
+            dataset_id (int): 数据集 ID
+
+        Returns:
+            DatasetDetail: 数据集完整信息（含所有版本元数据）
+        """
         return self._dataset.get(dataset_id)
 
     def create_dataset_version(self, payload: CreateDatasetVersionRequest) -> int:
+        """创建数据集版本
+
+        Args:
+            payload (CreateDatasetVersionRequest): 版本元信息
+
+        Returns:
+            int: 新建版本的 ``version_id``。
+        """
         return self._dataset_version.create(payload)
 
     def upload_dataset_version(self, payload: UploadDatasetVersionRequest) -> int:
+        """上传数据集版本
+
+        Args:
+            payload (UploadDatasetVersionRequest): 上传请求，需包含本地文件已上传后的 OSS 路径等信息
+
+        Returns:
+            int: 新建版本的 ``version_id``
+        """
         return self._dataset_version.upload(payload)
 
     def get_dataset_version(self, version_id: int) -> DatasetVersionDetail:
+        """获取数据集版本详情
+
+        Args:
+            version_id (int): 数据集版本 ID
+
+        Returns:
+            DatasetVersionDetail: 版本详细信息
+        """
         return self._dataset_version.get(version_id)
 
     def get_dataset_version_by_name(self, version_name: str) -> DatasetVersionDetail:
+        """通过 “数据集名/版本号” 获取版本详情
+
+        Args:
+            version_name (str): 形如 ``<dataset_name>/V<version>`` 的唯一标识
+
+        Returns:
+            DatasetVersionDetail: 版本详细信息
+        """
         return self._dataset_version.get_by_name(version_name)
 
     def upload_file(self, file_path: str) -> FileUploadData:
+        """上传本地文件到对象存储
+
+        Args:
+            file_path (str): 本地文件绝对路径
+
+        Returns:
+            FileUploadData: 上传结果（包含 OSS 路径、下载 URL 等）
+        """
         return self._upload.upload_file(file_path)
 
     # 如果想要访问子对象，也保留属性
@@ -61,16 +137,17 @@ class DatasetManagementService:
         return self._dataset_version
 
     def create_dataset_and_version(
-        self,
-        *,
-        dataset_name: str,
-        dataset_description: str = "",
-        is_local_upload: bool,
-        local_file_path: str | None = None,
-        server_file_path: str | None = None,
-        version_description: str = "",
+            self,
+            *,
+            dataset_name: str,
+            dataset_description: str = "",
+            is_local_upload: bool,
+            local_file_path: str | None = None,
+            server_file_path: str | None = None,
+            version_description: str = "",
+            timeout: int = 1_800,
     ) -> tuple[int, int, str]:
-        """创建数据集及其版本。
+        """创建数据集及其版本，并等待版本状态变为 *Success*。
 
         根据参数创建数据集，并根据上传类型（本地或服务器路径）创建对应的数据集版本。
 
@@ -82,6 +159,7 @@ class DatasetManagementService:
             local_file_path: 本地文件路径，当 is_local_upload=True 时必须提供。
             server_file_path: 服务器已有文件路径，当 is_local_upload=False 时必须提供。
             version_description: 版本描述，默认为空。
+            timeout: 最大等待秒数（默认1800s）。超过后仍未成功则引发 ``TimeoutError``。
 
         Returns:
            tuple[int, int, str]: 一个三元组，包含：[数据集 ID,数据集版本 ID, 数据集版本标签（格式为 <dataset_name>/V<version_number>)]
@@ -100,14 +178,34 @@ class DatasetManagementService:
                 name=dataset_name,
                 description=dataset_description,
                 tags=[],
+                cover_img=None,
+                create_by=None,
+                is_private=None,
+                access_user_ids=None,
             )
         )
+        logger.info(
+            f"创建数据集成功，名称为 {dataset_name} ,开始准备创建版本、上传数据"
+        )
 
         if is_local_upload:
-            upload_data = self._upload.upload_file(local_file_path)
+            # 上传文件，检查是文件夹还是zip
+            local_file_path = pathlib.Path(local_file_path)
+            if local_file_path.is_dir():
+                # 把文件夹打包为一个 zip
+                temp_zip_path = (
+                        pathlib.Path(tempfile.mkdtemp()) / f" {uuid.uuid4().hex}.zip"
+                )
+                zip_dir(local_file_path, temp_zip_path)
+                upload_data = self._upload.upload_file(temp_zip_path)
+                os.remove(temp_zip_path)
+            else:
+                upload_data = self._upload.upload_file(local_file_path)
+
             upload_path = upload_data.path
         else:
             upload_path = server_file_path
+        logger.info(f"文件上传成功：{local_file_path}")
 
         version_id = self._dataset_version.upload(
             UploadDatasetVersionRequest(
@@ -115,6 +213,7 @@ class DatasetManagementService:
                 upload_type=upload_type,
                 dataset_id=dataset_id,
                 description=version_description,
+                parent_version_id=0,
             )
         )
 
@@ -127,12 +226,32 @@ class DatasetManagementService:
             ver_num = 1
 
         version_tag = f"{detail.name}/V{ver_num}"
+        logger.info(f"数据集版本创建成功，名称为 {version_tag}，开始轮询状态…")
+
+        start_ts = time.time()
+        poll_interval = 10
+
+        while True:
+            ver_detail = self._dataset_version.get(version_id)
+            status = ver_detail.status
+
+            if status == DatasetVersionStatus.Success:
+                logger.info("版本状态已成功")
+                break
+
+            if status == DatasetVersionStatus.Fail:
+                raise APIError(f"版本构建失败：{ver_detail.message}")
+
+            elapsed = time.time() - start_ts
+            if elapsed > timeout:
+                raise TimeoutError(f"等待版本成功超时（{timeout}s），当前状态：{status}")
+
+            logger.debug(f"已等待 {elapsed:.0f}s，继续轮询…")
+            time.sleep(poll_interval)
 
         return dataset_id, version_id, version_tag
 
-    def run_download(
-        self, dataset_version_name: str, local_dir: str, worker: int = 4
-    ) -> None:
+    def run_download(self, dataset_version_name: str, local_dir: str, worker: int = 4) -> None:
         """根据数据集版本名称下载对应的数据集文件。
 
         Args:

aihub/services/document_center.py

@@ -1,23 +1,42 @@
 # !/usr/bin/env python
-# -*-coding:utf-8 -*-
+# -*- coding:utf-8 -*-
+"""文档中心服务模块
+
+本模块围绕 **“文档检索”** 提供以下能力：
+
+- **分页查询文档列表**
+"""
+
 from __future__ import annotations
 
+from typing import List
+
 import httpx
 
 from ..exceptions import APIError
 from ..models.common import APIWrapper
-from ..models.document_center import *
+from ..models.document_center import Document, GetDocumentsResponse
 
 _BASE = "/document-center/api/v1"
 
 
 class DocumentCenterService:
+    """文档中心服务封装"""
+
     def __init__(self, http: httpx.Client):
         self._document = _Document(http)
 
-    def get_documents(
-            self, page_size: int = 9999, page_num: int = 1, name: str = ""
-    ) -> List[Document]:
+    def get_documents(self, page_size: int = 9999, page_num: int = 1, name: str = "") -> List[Document]:
+        """分页查询文档
+
+        Args:
+            page_size: 每页条数，默认 9999
+            page_num: 当前页码，默认第 1 页
+            name: 按名字过滤，默认为空
+
+        Returns:
+            List[Document]: 文档对象列表
+        """
         return self._document.get_documents(page_size, page_num, name)
 
     @property

aihub/services/eval.py

@@ -1,10 +1,17 @@
 # !/usr/bin/env python
-# -*-coding:utf-8 -*-
+# -*- coding:utf-8 -*-
+"""评测平台服务模块
+
+本模块围绕 **“模型评测（Run → Report）”** 提供能力：
+
+- **创建评测任务 / 评测报告**
+"""
+
 import httpx
 
 from ..exceptions import APIError
 from ..models.common import APIWrapper
-from ..models.eval import CreatEvalReq, CreatEvalResp
+from ..models.eval import CreateEvalReq, CreateEvalResp
 
 _BASE = "/eval-platform/api/v1"
 
@@ -44,7 +51,7 @@ class EvalService:
         dataset_version = dataset_service.get_dataset_version_by_name(
             dataset_version_name
         )
-        payload = CreatEvalReq(
+        payload = CreateEvalReq(
             dataset_id=dataset_version.dataset_id,
             dataset_version_id=dataset_version.id,
             evaled_artifact_path=evaled_artifact_path,
@@ -60,9 +67,9 @@ class _Eval:
     def __init__(self, http: httpx.Client):
         self._http = http
 
-    def create(self, payload: CreatEvalReq) -> int:
-        resp = self._http.post(f"{_BASE}/RUN/", json=payload.model_dump())
-        wrapper = APIWrapper[CreatEvalResp].model_validate(resp.json())
+    def create(self, payload: CreateEvalReq) -> int:
+        resp = self._http.post(f"{_BASE}/run/", json=payload.model_dump())
+        wrapper = APIWrapper[CreateEvalResp].model_validate(resp.json())
         if wrapper.code != 0:
             raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
-        return wrapper.data.id
+        return wrapper.data.eval_run.id

aihub/services/labelfree.py

@@ -1,3 +1,12 @@
+# !/usr/bin/env python
+# -*- coding:utf-8 -*-
+"""标注服务模块
+
+本模块用于对接 **标注平台**，提供以下能力：
+
+- **获取指定项目的整体标注 / 审核完成度等统计信息**
+"""
+
 from __future__ import annotations
 
 import httpx
@@ -10,6 +19,8 @@ _BASE = "/labelfree/api/v2"
 
 
 class LabelfreeService:
+    """标注服务"""
+
     def __init__(self, http: httpx.Client):
         self._project = _Project(http)
 

aihub/services/model_center.py

@@ -0,0 +1,183 @@
+# !/usr/bin/env python
+# -*- coding:utf-8 -*-
+"""模型中心服务模块
+
+封装与 **Model‑Center** 后端交互的常用能力，主要涉及模型的增、删、改、查，以及模型元数据（类型 / 部署平台 / 量化等级）的查询功能：
+
+- **分页查询模型列表**
+- **获取单个模型详情**
+- **新建模型**
+- **编辑模型**
+- **删除模型**
+- **查询模型类型下拉**
+- **查询部署平台下拉**
+- **查询量化等级下拉**
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from ..exceptions import APIError
+from ..models.common import APIWrapper
+from ..models.model_center import (
+    ListModelsRequest,
+    ListModelsResponse,
+    ListModelTypesRequest,
+    ListModelTypesResponse,
+    ListDeployPlatformsRequest,
+    ListDeployPlatformsResponse,
+    ListQuantLevelsRequest,
+    ListQuantLevelsResponse,
+    CreateModelRequest,
+    CreateModelResponse,
+    EditModelRequest,
+    Model,
+)
+
+_BASE = "/model-center/api/v1"
+
+
+class ModelCenterService:
+    """模型中心业务封装"""
+
+    def __init__(self, http: httpx.Client):
+        self._model = _Model(http)
+
+    def list_models(self, payload: ListModelsRequest) -> ListModelsResponse:
+        """分页查询模型列表
+
+        Args:
+            payload: 查询参数（分页、名称过滤等）
+
+        Returns:
+            ListModelsResponse: 包含分页信息与模型数据
+        """
+        return self._model.list(payload)
+
+    def get_model(self, model_id: int) -> Model:
+        """获取模型详情
+
+        Args:
+            model_id: 模型 ID
+
+        Returns:
+            Model: 模型完整信息
+        """
+        return self._model.get(model_id)
+
+    def create_model(self, payload: CreateModelRequest) -> int:
+        """创建模型
+
+        Args:
+            payload: 创建模型所需字段
+
+        Returns:
+            int: 后端生成的模型 ID
+        """
+        return self._model.create(payload)
+
+    def edit_model(self, payload: EditModelRequest) -> None:
+        """编辑模型信息
+
+        Args:
+            payload: 编辑模型所需字段（需包含 id）
+        """
+        self._model.edit(payload)
+
+    def delete_model(self, model_id: int) -> None:
+        """删除模型
+
+        Args:
+            model_id: 目标模型 ID
+        """
+        self._model.delete(model_id)
+
+    def list_model_types(self) -> ListModelTypesResponse:
+        """查询模型类型列表
+
+        Returns:
+            ListModelTypesResponse: 模型类型集合
+        """
+        return self._model.list_types(ListModelTypesRequest())
+
+    def list_deploy_platforms(self) -> ListDeployPlatformsResponse:
+        """查询可用部署平台列表
+
+        Returns:
+            ListDeployPlatformsResponse: 部署平台集合
+        """
+        return self._model.list_platforms(ListDeployPlatformsRequest())
+
+    def list_quant_levels(self) -> ListQuantLevelsResponse:
+        """查询量化等级列表
+
+        Returns:
+            ListQuantLevelsResponse: 量化等级集合
+        """
+        return self._model.list_quant_levels(ListQuantLevelsRequest())
+
+    @property
+    def model(self) -> _Model:
+        return self._model
+
+
+class _Model:
+
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def list(self, payload: ListModelsRequest) -> ListModelsResponse:
+        resp = self._http.get(f"{_BASE}/models", params=payload.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[ListModelsResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get(self, model_id: int) -> Model:
+        resp = self._http.get(f"{_BASE}/models/{model_id}")
+        wrapper = APIWrapper[Model].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def create(self, payload: CreateModelRequest) -> int:
+        resp = self._http.post(f"{_BASE}/models", json=payload.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[CreateModelResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.id
+
+    def edit(self, payload: EditModelRequest) -> None:
+        resp = self._http.put(f"{_BASE}/models/{payload.id}",
+                              json=payload.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+    def delete(self, model_id: int) -> None:
+        resp = self._http.delete(f"{_BASE}/models/{model_id}")
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+    def list_types(self, payload: ListModelTypesRequest) -> ListModelTypesResponse:
+        resp = self._http.get(f"{_BASE}/model-types", params=payload.model_dump(by_alias=True))
+        wrapper = APIWrapper[ListModelTypesResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def list_platforms(self, payload: ListDeployPlatformsRequest) -> ListDeployPlatformsResponse:
+        resp = self._http.get(f"{_BASE}/deploy-platforms", params=payload.model_dump(by_alias=True))
+        wrapper = APIWrapper[ListDeployPlatformsResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def list_quant_levels(self, payload: ListQuantLevelsRequest) -> ListQuantLevelsResponse:
+        resp = self._http.get(f"{_BASE}/quant-levels", params=payload.model_dump(by_alias=True))
+        wrapper = APIWrapper[ListQuantLevelsResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data