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

aihub/services/quota_schedule_management.py

@@ -3,9 +3,16 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
+import httpx
+
+from ..exceptions import APIError
+from ..models.common import APIWrapper
+from ..models.quota_schedule_management import *
+
 _ENV_KEY = "PRE_STOP_SENTINEL_FILE"
 _DEFAULT_SENTINEL = "/tmp/pre_stop_sentinel_file"
 _SENTINEL_PATH = Path(os.getenv(_ENV_KEY, _DEFAULT_SENTINEL))
+_BASE = "/quota-schedule-management/api/v1"
 
 
 def is_pre_stopped() -> bool:
@@ -16,3 +23,160 @@ class PreStopService:
     @staticmethod
     def is_pre_stopped() -> bool:
         return is_pre_stopped()
+
+
+class QuotaScheduleManagementService:
+
+    def __init__(self, http: httpx.Client):
+        self._task = _Task(http)
+
+    def create_task(self, payload: CreateTaskRequest) -> int:
+        """创建调度任务
+
+        Args:
+            payload: 创建任务的各项参数
+
+        Returns:
+            int: 后端生成的任务 ID
+        """
+        return self._task.create(payload)
+
+    def list_tasks(self, payload: ListTasksRequest) -> ListTasksResponse:
+        """分页查询任务列表
+
+        Args:
+            payload: 查询条件（分页 / 过滤）
+
+        Returns:
+            ListTasksResponse: 列表及分页信息
+        """
+        return self._task.list(payload)
+
+    def get_task(self, task_id: int) -> Task:
+        """获取任务详情
+
+        Args:
+            task_id: 任务 ID
+
+        Returns:
+            Task: 任务完整信息
+        """
+        return self._task.get(task_id)
+
+    def stop_task(self, task_id: int) -> None:
+        """停止任务
+
+        Args:
+            task_id: 任务 ID
+
+        Returns:
+            None
+        """
+        self._task.stop(task_id)
+
+    def list_task_pods(self, task_id: int, payload: ListTaskPodsRequest) -> ListTaskPodsResponse:
+        return self._task.list_pods(task_id, payload)
+
+    def get_task_pod(self, task_id: int, pod_id: int) -> Pod:
+        return self._task.get_pod(task_id, pod_id)
+
+    def get_pod_logs_new(self, task_id: int, pod_id: int) -> List[PodLogInfo]:
+        return self._task.get_logs_new(task_id, pod_id).logs
+
+    def get_pod_spec(self, task_id: int, pod_id: int) -> str:
+        return self._task.get_spec(task_id, pod_id).spec
+
+    def get_pod_events(self, task_id: int, pod_id: int) -> str:
+        return self._task.get_events(task_id, pod_id).events
+
+    def list_task_users(self, payload: ListTaskUsersRequest) -> ListTaskUsersResponse:
+        return self._task.list_users(payload)
+
+    def get_metrics_overview(self, payload: GetMetricsOverviewRequest) -> GetMetricsOverviewResponse:
+        return self._task.get_metrics_overview(payload)
+
+    @property
+    def task(self) -> _Task:
+        return self._task
+
+
+class _Task:
+
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def create(self, payload: CreateTaskRequest) -> int:
+        resp = self._http.post(f"{_BASE}/tasks", json=payload.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[CreateTaskResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.id
+
+    def list(self, payload: ListTasksRequest) -> ListTasksResponse:
+        resp = self._http.get(f"{_BASE}/tasks", params=payload.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[ListTasksResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get(self, task_id: int) -> Task:
+        resp = self._http.get(f"{_BASE}/tasks/{task_id}")
+        wrapper = APIWrapper[Task].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def stop(self, task_id: int) -> None:
+        resp = self._http.post(f"{_BASE}/tasks/{task_id}/stop")
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+    def list_pods(self, task_id: int, payload: ListTaskPodsRequest) -> ListTaskPodsResponse:
+        resp = self._http.get(f"{_BASE}/tasks/{task_id}/pods", params=payload.model_dump(by_alias=True))
+        wrapper = APIWrapper[ListTaskPodsResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get_pod(self, task_id: int, pod_id: int) -> Pod:
+        resp = self._http.get(f"{_BASE}/tasks/{task_id}/pods/{pod_id}")
+        wrapper = APIWrapper[Pod].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get_logs_new(self, task_id: int, pod_id: int) -> GetTaskPodLogsNewResponse:
+        resp = self._http.get(f"{_BASE}/tasks/{task_id}/pods/{pod_id}/logs/new")
+        wrapper = APIWrapper[GetTaskPodLogsNewResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get_spec(self, task_id: int, pod_id: int) -> GetTaskPodSpecResponse:
+        resp = self._http.get(f"{_BASE}/tasks/{task_id}/pods/{pod_id}/spec")
+        wrapper = APIWrapper[GetTaskPodSpecResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get_events(self, task_id: int, pod_id: int) -> GetTaskPodEventsResponse:
+        resp = self._http.get(f"{_BASE}/tasks/{task_id}/pods/{pod_id}/events")
+        wrapper = APIWrapper[GetTaskPodEventsResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def list_users(self, payload: ListTaskUsersRequest) -> ListTaskUsersResponse:
+        resp = self._http.get(f"{_BASE}/task-users", params=payload.model_dump(by_alias=True))
+        wrapper = APIWrapper[ListTaskUsersResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get_metrics_overview(self, payload: GetMetricsOverviewRequest) -> GetMetricsOverviewResponse:
+        resp = self._http.get(f"{_BASE}/metrics/overview", params=payload.model_dump(by_alias=True))
+        wrapper = APIWrapper[GetMetricsOverviewResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data

aihub/services/tag_resource_management.py

@@ -0,0 +1,55 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+from __future__ import annotations
+
+import httpx
+
+from ..exceptions import APIError
+from ..models.common import APIWrapper
+from ..models.tag_resource_management import *
+
+_BASE = "/tag-resource-management/api/v1"
+
+
+class TagResourceManagementService:
+    def __init__(self, http: httpx.Client):
+        self._project = _Project(http)
+        self._virtual_cluster = _VirtualCluster(http)
+
+    def select_projects(self) -> List[Project]:
+        return self._project.select_projects()
+
+    def select_virtual_clusters(self, payload: SelectVirtualClustersRequest) -> List[VirtualClusterBrief]:
+        return self._virtual_cluster.select(payload).data
+
+    @property
+    def project(self) -> _Project:
+        return self._project
+
+    @property
+    def virtual_cluster(self) -> _VirtualCluster:
+        return self._virtual_cluster
+
+
+class _Project:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def select_projects(self) -> List[Project]:
+        resp = self._http.get(f"{_BASE}/select-projects")
+        wrapper = APIWrapper[ProjectListData].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.data
+
+
+class _VirtualCluster:
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def select(self, payload: SelectVirtualClustersRequest) -> SelectVirtualClustersResponse:
+        resp = self._http.get(f"{_BASE}/select-clusters", params=payload.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[SelectVirtualClustersResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data

aihub/services/task_center.py

@@ -5,8 +5,8 @@ import datetime
 import httpx
 from loguru import logger
 
-from .tag_management import TagManagementService
-from .user import UserService
+from .tag_resource_management import TagResourceManagementService
+from .user_system import UserSystemService
 from ..exceptions import APIError
 from ..models.common import APIWrapper
 from ..models.task_center import (
@@ -17,7 +17,7 @@ from ..models.task_center import (
     TaskCenterPriorityEnum,
     LabelTaskDetail,
 )
-from ..models.user import UserSearchReq
+from ..models.user_system import SearchUsersRequest
 
 _BASE = "/task-center/api/v1"
 
@@ -56,16 +56,16 @@ class TaskCenterService:
         return self._TaskCenter
 
     def create_label_task(
-        self,
-        name: str,
-        dataset_version_name: str,
-        feishu_doc_name: str,
-        task_receiver_name: str,
-        estimated_delivery_at: str,
-        project_name: str,
-        label_type: LabelProjectTypeEnum = LabelProjectTypeEnum.IMAGE_CLASSIFICATION,
-        description: str = "",
-        task_priority: TaskCenterPriorityEnum = TaskCenterPriorityEnum.low,
+            self,
+            name: str,
+            dataset_version_name: str,
+            feishu_doc_name: str,
+            task_receiver_name: str,
+            estimated_delivery_at: str,
+            project_name: str,
+            label_type: LabelProjectTypeEnum = LabelProjectTypeEnum.IMAGE_CLASSIFICATION,
+            description: str = "",
+            task_priority: TaskCenterPriorityEnum = TaskCenterPriorityEnum.low,
     ) -> int:
         """创建标注任务
 
@@ -93,13 +93,13 @@ task_priority="low", estimated_delivery_at= "2025-08-01")
             任务ID
         """
         # 获取接收者ID
-        user_service = UserService(self._http)
+        user_service = UserSystemService(self._http)
         task_receiver_id = user_service.search_one(
-            payload=UserSearchReq(nickname=task_receiver_name)
+            payload=SearchUsersRequest(nickname=task_receiver_name)
         )
 
         # 获取项目ID
-        tag_service = TagManagementService(self._http)
+        tag_service = TagResourceManagementService(self._http)
         projects = tag_service.select_projects()
         project_id = None
         for project in projects:

aihub/services/user_system.py

@@ -0,0 +1,339 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+from __future__ import annotations
+
+import httpx
+
+from ..exceptions import APIError
+from ..models.common import APIWrapper
+from ..models.user_system import *
+
+
+class UserSystemService:
+
+    def __init__(self, http: httpx.Client):
+        self._auth = _Auth(http)
+        self._menu = _Menu(http)
+        self._role = _Role(http)
+        self._user = _User(http)
+
+    # ==================================================
+    #  AUTH 一级方法
+    # ==================================================
+    def login(self, payload: LoginRequest) -> LoginResponse:
+        return self._auth.login(payload)
+
+    def signup(self, payload: SignupRequest) -> SignupResponse:
+        return self._auth.signup(payload)
+
+    # ==================================================
+    #  MENU 一级方法
+    # ==================================================
+    def list_menus(self, need_roles: bool = False) -> ListMenusResponse:
+        return self._menu.list(need_roles)
+
+    def get_menu(self, menu_id: int) -> Menu:
+        return self._menu.get(menu_id)
+
+    def create_menu(self, payload: CreateMenuRequest) -> int:
+        return self._menu.create(payload)
+
+    def update_menu(self, menu_id: int, payload: UpdateMenuRequest) -> None:
+        self._menu.update(menu_id, payload)
+
+    def delete_menu(self, menu_id: int) -> None:
+        self._menu.delete(menu_id)
+
+    def get_menu_roles(self, menu_id: int) -> List[int]:
+        return self._menu.get_roles(menu_id)
+
+    def set_menu_roles(self, menu_id: int, role_ids: List[int]) -> None:
+        self._menu.set_roles(menu_id, role_ids)
+
+    # ==================================================
+    #  ROLE 一级方法
+    # ==================================================
+    def list_roles(self, payload: ListRolesRequest) -> ListRolesResponse:
+        return self._role.list(payload)
+
+    def get_role(self, role_id: int) -> Role:
+        return self._role.get(role_id)
+
+    def create_role(self, payload: CreateRoleRequest) -> int:
+        return self._role.create(payload)
+
+    def update_role(self, role_id: int, payload: UpdateRoleRequest) -> None:
+        self._role.update(role_id, payload)
+
+    def delete_role(self, role_id: int) -> None:
+        self._role.delete(role_id)
+
+    def get_role_menus(self, role_id: int) -> List[int]:
+        return self._role.get_menus(role_id)
+
+    def set_role_menus(self, role_id: int, menu_ids: List[int]) -> None:
+        self._role.set_menus(role_id, menu_ids)
+
+    def search_roles(self, payload: SearchRolesRequest) -> SearchRolesResponse:
+        return self._role.search(payload)
+
+    # ==================================================
+    #  USER 一级方法
+    # ==================================================
+    def list_users(self, payload: ListUsersRequest) -> ListUsersResponse:
+        return self._user.list(payload)
+
+    def get_user(self, user_id: int) -> User:
+        return self._user.get(user_id)
+
+    def create_user(self, payload: CreateUserRequest) -> int:
+        return self._user.create(payload)
+
+    def update_user(self, user_id: int, payload: UpdateUserRequest) -> None:
+        self._user.update(user_id, payload)
+
+    def delete_user(self, user_id: int) -> None:
+        self._user.delete(user_id)
+
+    def set_user_roles(self, user_id: int, payload: SetUserRolesRequest) -> None:
+        self._user.set_roles(user_id, payload)
+
+    def get_user_menus(self, user_id: int, parent_id: int | None = None, auth: str | None = None, ) -> List[TreeMenu]:
+        return self._user.get_menus(user_id, parent_id=parent_id, auth=auth)
+
+    def search_users(self, payload: SearchUsersRequest) -> SearchUsersResponse:
+        return self._user.search(payload)
+
+    def search_one(self, payload: SearchUsersRequest) -> int:
+        return self._user.search_one(payload)
+
+    @property
+    def auth(self) -> _Auth:
+        return self._auth
+
+    @property
+    def menu(self) -> _Menu:
+        return self._menu
+
+    @property
+    def role(self) -> _Role:
+        return self._role
+
+    @property
+    def user(self) -> _User:
+        return self._user
+
+
+class _Auth:
+    _base = "/api/v1/auth"
+
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def login(self, req: LoginRequest) -> LoginResponse:
+        resp = self._http.post(
+            f"{self._base}/login",
+            json=req.model_dump(by_alias=True, exclude_none=True),
+        )
+        wrapper = APIWrapper[LoginResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def signup(self, req: SignupRequest) -> SignupResponse:
+        resp = self._http.post(
+            f"{self._base}/signup",
+            json=req.model_dump(by_alias=True, exclude_none=True),
+        )
+        wrapper = APIWrapper[SignupResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+
+class _Menu:
+    _base = "/api/v1/menus"
+
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def list(self, need_roles: bool) -> ListMenusResponse:
+        resp = self._http.get(self._base, params={"need_roles": str(need_roles).lower()})
+        wrapper = APIWrapper[ListMenusResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get(self, menu_id: int) -> Menu:
+        resp = self._http.get(f"{self._base}/{menu_id}")
+        wrapper = APIWrapper[Menu].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def create(self, req: CreateMenuRequest) -> int:
+        resp = self._http.post(self._base, json=req.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[CreateMenuResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.id
+
+    def update(self, menu_id: int, req: UpdateMenuRequest) -> None:
+        resp = self._http.put(f"{self._base}/{menu_id}", json=req.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, menu_id: int) -> None:
+        resp = self._http.delete(f"{self._base}/{menu_id}")
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+    def get_roles(self, menu_id: int) -> List[int]:
+        resp = self._http.get(f"{self._base}/{menu_id}/roles")
+        wrapper = APIWrapper[GetMenuRolesResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.role_ids
+
+    def set_roles(self, menu_id: int, role_ids: List[int]) -> None:
+        resp = self._http.put(f"{self._base}/{menu_id}/roles", json={"role_ids": role_ids})
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+
+class _Role:
+    _base = "/api/v1/roles"
+    _search = "/api/v1/search-roles"
+
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def list(self, req: ListRolesRequest) -> ListRolesResponse:
+        resp = self._http.get(self._base, params=req.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[ListRolesResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get(self, role_id: int) -> Role:
+        resp = self._http.get(f"{self._base}/{role_id}")
+        wrapper = APIWrapper[Role].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def create(self, req: CreateRoleRequest) -> int:
+        resp = self._http.post(self._base, json=req.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[CreateRoleResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.id
+
+    def update(self, role_id: int, req: UpdateRoleRequest) -> None:
+        resp = self._http.put(f"{self._base}/{role_id}", json=req.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, role_id: int) -> None:
+        resp = self._http.delete(f"{self._base}/{role_id}")
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+    def get_menus(self, role_id: int) -> List[int]:
+        resp = self._http.get(f"{self._base}/{role_id}/menus")
+        wrapper = APIWrapper[GetRoleMenusResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.menu_ids
+
+    def set_menus(self, role_id: int, menu_ids: List[int]) -> None:
+        resp = self._http.put(f"{self._base}/{role_id}/menus", json={"menu_ids": menu_ids})
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+    def search(self, req: SearchRolesRequest) -> SearchRolesResponse:
+        resp = self._http.post(self._search, json=req.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[SearchRolesResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+
+class _User:
+    _base = "/api/v1/users"
+    _search = "/api/v1/search-users"
+
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def list(self, req: ListUsersRequest) -> ListUsersResponse:
+        resp = self._http.get(self._base, params=req.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[ListUsersResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def get(self, user_id: int) -> User:
+        resp = self._http.get(f"{self._base}/{user_id}")
+        wrapper = APIWrapper[User].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def create(self, req: CreateUserRequest) -> int:
+        resp = self._http.post(self._base, json=req.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[CreateUserResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.id
+
+    def update(self, user_id: int, req: UpdateUserRequest) -> None:
+        resp = self._http.put(f"{self._base}/{user_id}", json=req.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, user_id: int) -> None:
+        resp = self._http.delete(f"{self._base}/{user_id}")
+        wrapper = APIWrapper[dict].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+
+    def set_roles(self, user_id: int, req: SetUserRolesRequest) -> None:
+        resp = self._http.put(f"{self._base}/{user_id}/roles", json=req.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 get_menus(self, user_id: int, parent_id: int | None = None, auth: str | None = None) -> List[TreeMenu]:
+        params = {}
+        if parent_id is not None:
+            params["parent_id"] = parent_id
+        if auth:
+            params["auth"] = auth
+
+        resp = self._http.get(f"{self._base}/{user_id}/menus", params=params)
+        wrapper = APIWrapper[GetUserMenusResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data.menus
+
+    def search(self, req: SearchUsersRequest) -> SearchUsersResponse:
+        resp = self._http.post(self._search, json=req.model_dump(by_alias=True, exclude_none=True))
+        wrapper = APIWrapper[SearchUsersResponse].model_validate(resp.json())
+        if wrapper.code != 0:
+            raise APIError(f"backend code {wrapper.code}: {wrapper.msg}")
+        return wrapper.data
+
+    def search_one(self, req: SearchUsersRequest) -> int:
+        resp = self.search(req)
+        for user in resp.data:
+            if user.nickname == req.nickname:
+                return user.id
+        raise APIError("no user found")

{intellif_aihub-0.1.2.dist-info → intellif_aihub-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intellif-aihub
-Version: 0.1.2
+Version: 0.1.4
 Summary: Intellif AI-hub SDK.
 Author-email: Platform Team <aihub@example.com>
 License-Expression: Apache-2.0
@@ -13,7 +13,7 @@ License-File: LICENSE
 Requires-Dist: httpx<0.28,>=0.27
 Requires-Dist: pydantic<3.0,>=2.5.3
 Requires-Dist: typing-extensions<5.0,>=4.13.2
-Requires-Dist: pyarrow<16.0,>=15.0
+Requires-Dist: pyarrow<16.0,>=15.0.2
 Requires-Dist: tqdm<5.0,>=4.66
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: minio>=7.2.7