agentrun-inner-test 0.0.46__py3-none-any.whl

agentrun/model/__client_async_template.py

@@ -0,0 +1,357 @@
+"""Model Service 客户端 / Model Service Client
+
+此模块提供模型服务和模型代理的客户端API。
+This module provides the client API for model services and model proxies.
+"""
+
+from typing import List, Literal, Optional, overload, Union
+
+from alibabacloud_agentrun20250910.models import (
+    CreateModelProxyInput,
+    CreateModelServiceInput,
+    ListModelProxiesRequest,
+    ListModelServicesRequest,
+    UpdateModelProxyInput,
+    UpdateModelServiceInput,
+)
+import pydash
+
+from agentrun.utils.config import Config
+from agentrun.utils.exception import HTTPError
+
+from .api.control import ModelControlAPI
+from .model import (
+    BackendType,
+    ModelProxyCreateInput,
+    ModelProxyListInput,
+    ModelProxyUpdateInput,
+    ModelServiceCreateInput,
+    ModelServiceListInput,
+    ModelServiceUpdateInput,
+    ProxyMode,
+)
+from .model_proxy import ModelProxy
+from .model_service import ModelService
+
+
+class ModelClient:
+    """Model Service 客户端 / Model Service Client
+
+    提供模型服务和模型代理的创建、删除、更新和查询功能。
+    Provides create, delete, update and query functions for model services and model proxies.
+    """
+
+    def __init__(self, config: Optional[Config] = None):
+        """初始化客户端 / Initialize client
+
+        Args:
+            config: 配置对象,可选 / Configuration object, optional
+        """
+        self.__control_api = ModelControlAPI(config)
+
+    @overload
+    async def create_async(
+        self, input: ModelServiceCreateInput, config: Optional[Config] = None
+    ) -> ModelService:
+        ...
+
+    @overload
+    async def create_async(
+        self, input: ModelProxyCreateInput, config: Optional[Config] = None
+    ) -> ModelProxy:
+        ...
+
+    async def create_async(
+        self,
+        input: Union[ModelServiceCreateInput, ModelProxyCreateInput],
+        config: Optional[Config] = None,
+    ):
+        """创建模型服务（异步）
+
+        Args:
+            input: 模型服务输入参数
+            config: 配置
+
+        Returns:
+            model: 创建的对象
+        """
+        try:
+            if isinstance(input, ModelProxyCreateInput):
+                if not input.proxy_mode:
+                    input.proxy_mode = (
+                        ProxyMode.MULTI
+                        if len(pydash.get(input, "proxy_config.endpoints", []))
+                        > 1
+                        else ProxyMode.SINGLE
+                    )
+
+                result = await self.__control_api.create_model_proxy_async(
+                    CreateModelProxyInput().from_map(input.model_dump()),
+                    config=config,
+                )
+                return ModelProxy.from_inner_object(result)
+            else:
+                result = await self.__control_api.create_model_service_async(
+                    CreateModelServiceInput().from_map(input.model_dump()),
+                    config=config,
+                )
+                return ModelService.from_inner_object(result)
+        except HTTPError as e:
+            raise e.to_resource_error(
+                "Model",
+                (
+                    input.model_proxy_name
+                    if isinstance(input, ModelProxyCreateInput)
+                    else input.model_service_name
+                ),
+            ) from e
+
+    @overload
+    async def delete_async(
+        self,
+        name: str,
+        backend_type: Literal[BackendType.PROXY],
+        config: Optional[Config] = None,
+    ) -> ModelProxy:
+        ...
+
+    @overload
+    async def delete_async(
+        self,
+        name: str,
+        backend_type: Literal[BackendType.SERVICE],
+        config: Optional[Config] = None,
+    ) -> ModelService:
+        ...
+
+    @overload
+    async def delete_async(
+        self,
+        name: str,
+        backend_type: None = None,
+        config: Optional[Config] = None,
+    ) -> Union[ModelProxy, ModelService]:
+        ...
+
+    async def delete_async(
+        self,
+        name: str,
+        backend_type: Optional[BackendType] = None,
+        config: Optional[Config] = None,
+    ):
+        """删除模型服务（异步）
+
+        Args:
+            model_service_name: 模型服务名称
+            config: 配置
+
+        Raises:
+            ResourceNotExistError: 模型服务不存在
+        """
+
+        error: Optional[HTTPError] = None
+        if backend_type == BackendType.PROXY or backend_type is None:
+            try:
+                result = await self.__control_api.delete_model_proxy_async(
+                    model_proxy_name=name, config=config
+                )
+                return ModelProxy.from_inner_object(result)
+            except HTTPError as e:
+                error = e
+
+        if backend_type == BackendType.PROXY and error is not None:
+            raise error.to_resource_error("Model", name) from error
+
+        try:
+            result = await self.__control_api.delete_model_service_async(
+                model_service_name=name, config=config
+            )
+            return ModelService.from_inner_object(result)
+        except HTTPError as e:
+            raise e.to_resource_error("Model", name) from error
+
+    @overload
+    async def update_async(
+        self,
+        name: str,
+        input: ModelServiceUpdateInput,
+        config: Optional[Config] = None,
+    ) -> ModelService:
+        ...
+
+    @overload
+    async def update_async(
+        self,
+        name: str,
+        input: ModelProxyUpdateInput,
+        config: Optional[Config] = None,
+    ) -> ModelProxy:
+        ...
+
+    async def update_async(
+        self,
+        name: str,
+        input: Union[ModelServiceUpdateInput, ModelProxyUpdateInput],
+        config: Optional[Config] = None,
+    ):
+        """更新模型服务（异步）
+
+        Args:
+            model_service_name: 模型服务名称
+            input: 模型服务更新输入参数
+            config: 配置
+
+        Returns:
+            ModelService: 更新后的模型服务对象
+
+        Raises:
+            ResourceNotExistError: 模型服务不存在
+        """
+
+        if isinstance(input, ModelProxyUpdateInput):
+            try:
+                if not input.proxy_mode:
+                    input.proxy_mode = (
+                        ProxyMode.MULTI
+                        if len(pydash.get(input, "proxy_config.endpoints", []))
+                        > 1
+                        else ProxyMode.SINGLE
+                    )
+                result = await self.__control_api.update_model_proxy_async(
+                    model_proxy_name=name,
+                    input=UpdateModelProxyInput().from_map(input.model_dump()),
+                    config=config,
+                )
+                return ModelProxy.from_inner_object(result)
+            except HTTPError as e:
+                raise e.to_resource_error("Model", name) from e
+
+        else:
+            try:
+                result = await self.__control_api.update_model_service_async(
+                    model_service_name=name,
+                    input=UpdateModelServiceInput().from_map(
+                        input.model_dump()
+                    ),
+                    config=config,
+                )
+                return ModelService.from_inner_object(result)
+            except HTTPError as e:
+                raise e.to_resource_error("Model", name) from e
+
+    @overload
+    async def get_async(
+        self,
+        name: str,
+        backend_type: Literal[BackendType.SERVICE],
+        config: Optional[Config] = None,
+    ) -> ModelService:
+        ...
+
+    @overload
+    async def get_async(
+        self,
+        name: str,
+        backend_type: Literal[BackendType.PROXY],
+        config: Optional[Config] = None,
+    ) -> ModelProxy:
+        ...
+
+    @overload
+    async def get_async(
+        self,
+        name: str,
+        backend_type: None = None,
+        config: Optional[Config] = None,
+    ) -> Union[ModelService, ModelProxy]:
+        ...
+
+    async def get_async(
+        self,
+        name: str,
+        backend_type: Optional[BackendType] = None,
+        config: Optional[Config] = None,
+    ):
+        """获取模型服务（异步）
+
+        Args:
+            model_service_name: 模型服务名称
+            config: 配置
+
+        Returns:
+            ModelService: 模型服务对象
+
+        Raises:
+            ResourceNotExistError: 模型服务不存在
+        """
+
+        error: Optional[HTTPError] = None
+        if backend_type == BackendType.PROXY or backend_type is None:
+            try:
+                result = await self.__control_api.get_model_proxy_async(
+                    model_proxy_name=name, config=config
+                )
+                return ModelProxy.from_inner_object(result)
+            except HTTPError as e:
+                error = e
+
+        if backend_type == BackendType.PROXY and error is not None:
+            raise error.to_resource_error("Model", name) from error
+
+        try:
+            result = await self.__control_api.get_model_service_async(
+                model_service_name=name, config=config
+            )
+            return ModelService.from_inner_object(result)
+        except HTTPError as e:
+            raise e.to_resource_error("Model", name) from e
+
+    @overload
+    async def list_async(
+        self,
+        input: ModelProxyListInput,
+        config: Optional[Config] = None,
+    ) -> List[ModelProxy]:
+        ...
+
+    @overload
+    async def list_async(
+        self,
+        input: ModelServiceListInput,
+        config: Optional[Config] = None,
+    ) -> List[ModelService]:
+        ...
+
+    async def list_async(
+        self,
+        input: Union[ModelServiceListInput, ModelProxyListInput],
+        config: Optional[Config] = None,
+    ):
+        """列出模型服务（异步）
+
+        Args:
+            input: 分页查询参数
+            config: 配置
+
+        Returns:
+            List[ModelService]: 模型服务列表
+        """
+
+        if isinstance(input, ModelProxyListInput):
+            result = await self.__control_api.list_model_proxies_async(
+                ListModelProxiesRequest().from_map(input.model_dump()),
+                config=config,
+            )
+            return [
+                ModelProxy.from_inner_object(item)
+                for item in result.items or []
+            ]
+        else:
+            result = await self.__control_api.list_model_services_async(
+                ListModelServicesRequest().from_map(input.model_dump()),
+                config=config,
+            )
+            return [
+                ModelService.from_inner_object(item)
+                for item in result.items or []
+            ]

agentrun/model/__init__.py

@@ -0,0 +1,57 @@
+"""Model Service 模块 / Model Service Module"""
+
+from .api import ModelCompletionAPI, ModelControlAPI, ModelDataAPI
+from .client import ModelClient
+from .model import (
+    BackendType,
+    ModelFeatures,
+    ModelInfoConfig,
+    ModelParameterRule,
+    ModelProperties,
+    ModelProxyCreateInput,
+    ModelProxyListInput,
+    ModelProxyUpdateInput,
+    ModelServiceCreateInput,
+    ModelServiceListInput,
+    ModelServiceUpdateInput,
+    ModelType,
+    Provider,
+    ProviderSettings,
+    ProxyConfig,
+    ProxyConfigEndpoint,
+    ProxyConfigFallback,
+    ProxyConfigPolicies,
+)
+from .model_proxy import ModelProxy
+from .model_service import ModelService
+
+__all__ = [
+    # base
+    "ModelClient",
+    "ModelService",
+    "ModelProxy",
+    "ModelControlAPI",
+    "ModelCompletionAPI",
+    "ModelDataAPI",
+    # enum
+    "BackendType",
+    "ModelType",
+    "Provider",
+    # inner model
+    "ProviderSettings",
+    "ModelFeatures",
+    "ModelProperties",
+    "ModelParameterRule",
+    "ModelInfoConfig",
+    "ProxyConfigEndpoint",
+    "ProxyConfigFallback",
+    "ProxyConfigPolicies",
+    "ProxyConfig",
+    # api model
+    "ModelServiceCreateInput",
+    "ModelServiceUpdateInput",
+    "ModelServiceListInput",
+    "ModelProxyCreateInput",
+    "ModelProxyUpdateInput",
+    "ModelProxyListInput",
+]

agentrun/model/__model_proxy_async_template.py

@@ -0,0 +1,270 @@
+"""Model Proxy 高层 API / Model Proxy High-Level API
+
+此模块定义模型代理资源的高级API。
+This module defines the high-level API for model proxy resources.
+"""
+
+from typing import List, Optional
+
+import pydash
+
+from agentrun.model.api.data import BaseInfo, ModelDataAPI
+from agentrun.utils.config import Config
+from agentrun.utils.model import Status
+from agentrun.utils.resource import ResourceBase
+
+from .model import (
+    BackendType,
+    ModelProxyCreateInput,
+    ModelProxyImmutableProps,
+    ModelProxyListInput,
+    ModelProxyMutableProps,
+    ModelProxySystemProps,
+    ModelProxyUpdateInput,
+    PageableInput,
+    ProxyMode,
+)
+
+
+class ModelProxy(
+    ModelProxyImmutableProps,
+    ModelProxyMutableProps,
+    ModelProxySystemProps,
+    ResourceBase,
+):
+    """模型服务"""
+
+    _data_client: Optional[ModelDataAPI] = None
+
+    @classmethod
+    def __get_client(cls):
+        from .client import ModelClient
+
+        return ModelClient()
+
+    @classmethod
+    async def create_async(
+        cls, input: ModelProxyCreateInput, config: Optional[Config] = None
+    ):
+        """创建模型服务（异步）
+
+        Args:
+            input: 模型服务输入参数
+            config: 配置
+
+        Returns:
+            ModelProxy: 创建的模型服务对象
+        """
+        return await cls.__get_client().create_async(input, config=config)
+
+    @classmethod
+    async def delete_by_name_async(
+        cls, model_Proxy_name: str, config: Optional[Config] = None
+    ):
+        """根据名称删除模型服务（异步）
+
+        Args:
+            model_Proxy_name: 模型服务名称
+            config: 配置
+        """
+        return await cls.__get_client().delete_async(
+            model_Proxy_name, backend_type=BackendType.PROXY, config=config
+        )
+
+    @classmethod
+    async def update_by_name_async(
+        cls,
+        model_proxy_name: str,
+        input: ModelProxyUpdateInput,
+        config: Optional[Config] = None,
+    ):
+        """根据名称更新模型服务（异步）
+
+        Args:
+            model_Proxy_name: 模型服务名称
+            input: 模型服务更新输入参数
+            config: 配置
+
+        Returns:
+            ModelProxy: 更新后的模型服务对象
+        """
+        return await cls.__get_client().update_async(
+            model_proxy_name, input, config=config
+        )
+
+    @classmethod
+    async def get_by_name_async(
+        cls, model_proxy_name: str, config: Optional[Config] = None
+    ):
+        """根据名称获取模型服务（异步）
+
+        Args:
+            model_Proxy_name: 模型服务名称
+            config: 配置
+
+        Returns:
+            ModelProxy: 模型服务对象
+        """
+        return await cls.__get_client().get_async(
+            model_proxy_name, backend_type=BackendType.PROXY, config=config
+        )
+
+    @classmethod
+    async def _list_page_async(
+        cls, page_input: PageableInput, config: Config | None = None, **kwargs
+    ):
+        return await cls.__get_client().list_async(
+            input=ModelProxyListInput(
+                **kwargs,
+                **page_input.model_dump(),
+            ),
+            config=config,
+        )
+
+    @classmethod
+    async def list_all_async(
+        cls,
+        *,
+        proxy_mode: Optional[str] = None,
+        status: Optional[Status] = None,
+        config: Optional[Config] = None,
+    ) -> List["ModelProxy"]:
+        return await cls._list_all_async(
+            lambda m: m.model_proxy_id or "",
+            config=config,
+            proxy_mode=proxy_mode,
+            status=status,
+        )
+
+    async def update_async(
+        self, input: ModelProxyUpdateInput, config: Optional[Config] = None
+    ):
+        """更新模型服务（异步）
+
+        Args:
+            input: 模型服务更新输入参数
+            config: 配置
+
+        Returns:
+            ModelProxy: 更新后的模型服务对象
+        """
+        if self.model_proxy_name is None:
+            raise ValueError(
+                "model_Proxy_name is required to update a ModelProxy"
+            )
+
+        result = await self.update_by_name_async(
+            self.model_proxy_name, input, config=config
+        )
+        self.update_self(result)
+
+        return self
+
+    async def delete_async(self, config: Optional[Config] = None):
+        """删除模型服务（异步）
+
+        Args:
+            config: 配置
+        """
+        if self.model_proxy_name is None:
+            raise ValueError(
+                "model_Proxy_name is required to delete a ModelProxy"
+            )
+
+        return await self.delete_by_name_async(
+            self.model_proxy_name, config=config
+        )
+
+    async def get_async(self, config: Optional[Config] = None):
+        """刷新模型服务信息（异步）
+
+        Args:
+            config: 配置
+
+        Returns:
+            ModelProxy: 刷新后的模型服务对象
+        """
+        if self.model_proxy_name is None:
+            raise ValueError(
+                "model_Proxy_name is required to refresh a ModelProxy"
+            )
+
+        result = await self.get_by_name_async(
+            self.model_proxy_name, config=config
+        )
+        self.update_self(result)
+
+        return self
+
+    async def refresh_async(self, config: Optional[Config] = None):
+        """刷新模型服务信息（异步）
+
+        Args:
+            config: 配置
+
+        Returns:
+            ModelProxy: 刷新后的模型服务对象
+        """
+        return await self.get_async(config=config)
+
+    def model_info(self, config: Optional[Config] = None) -> BaseInfo:
+        cfg = Config.with_configs(self._config, config)
+
+        if self._data_client is None:
+            self._data_client = ModelDataAPI(
+                self.model_proxy_name or "",
+                credential_name=self.credential_name,
+                config=cfg,
+            )
+
+        self._data_client.update_model_name(
+            model_proxy_name=self.model_proxy_name,
+            model_name=(
+                pydash.get(self, "proxy_config.endpoints[0].model_names[0]")
+                if self.proxy_mode == ProxyMode.SINGLE
+                else self.model_proxy_name
+            )
+            or "",
+            credential_name=self.credential_name,
+            config=cfg,
+        )
+
+        return self._data_client.model_info()
+
+    def completions(
+        self,
+        messages: list,
+        model: Optional[str] = None,
+        stream: bool = False,
+        config: Optional[Config] = None,
+        **kwargs,
+    ):
+        self.model_info(config)
+        assert self._data_client
+
+        return self._data_client.completions(
+            **kwargs,
+            messages=messages,
+            model=model,
+            stream=stream,
+            config=config,
+        )
+
+    def responses(
+        self,
+        messages: list,
+        model: Optional[str] = None,
+        stream: bool = False,
+        config: Optional[Config] = None,
+        **kwargs,
+    ):
+        self.model_info(config)
+        assert self._data_client
+
+        return self._data_client.responses(
+            **kwargs,
+            messages=messages,
+            model=model,
+            stream=stream,
+            config=config,
+        )