tamar-model-client 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

tamar_model_client/schemas/inputs.py

@@ -127,11 +127,16 @@ class OpenAIChatCompletionsInput(BaseModel):
 
 class OpenAIImagesInput(BaseModel):
     prompt: str
+    background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN
     model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN
+    moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN
     n: Optional[int] | NotGiven = NOT_GIVEN
+    output_compression: Optional[int] | NotGiven = NOT_GIVEN
+    output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN
     quality: Literal["standard", "hd"] | NotGiven = NOT_GIVEN
     response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN
-    size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN
+    size: Optional[Literal[
+        "auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN
     style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN
     user: str | NotGiven = NOT_GIVEN
     extra_headers: Headers | None = None

{tamar_model_client-0.1.12.dist-info → tamar_model_client-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.12
+Version: 0.1.14
 Summary: A Python SDK for interacting with the Model Manager gRPC service
 Home-page: http://gitlab.tamaredge.top/project-tap/AgentOS/model-manager-client
 Author: Oscar Ou

tamar_model_client-0.1.14.dist-info/RECORD

@@ -0,0 +1,19 @@
+tamar_model_client/__init__.py,sha256=LMECAuDARWHV1XzH3msoDXcyurS2eihRQmBy26_PUE0,328
+tamar_model_client/async_client.py,sha256=gmZ2xMHO_F-Vtg3OK7B_yf-gtI-WH2NU2LzC6YO_t7k,19649
+tamar_model_client/auth.py,sha256=gbwW5Aakeb49PMbmYvrYlVx1mfyn1LEDJ4qQVs-9DA4,438
+tamar_model_client/exceptions.py,sha256=jYU494OU_NeIa4X393V-Y73mTNm0JZ9yZApnlOM9CJQ,332
+tamar_model_client/sync_client.py,sha256=o8b20fQUvtMq1gWax3_dfOpputYT4l9pRTz6cHdB0lg,4006
+tamar_model_client/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
+tamar_model_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
+tamar_model_client/enums/invoke.py,sha256=WufImoN_87ZjGyzYitZkhNNFefWJehKfLtyP-DTBYlA,267
+tamar_model_client/enums/providers.py,sha256=L_bX75K6KnWURoFizoitZ1Ybza7bmYDqXecNzNpgIrI,165
+tamar_model_client/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tamar_model_client/generated/model_service_pb2.py,sha256=RI6wNSmgmylzWPedFfPxx938UzS7kcPR58YTzYshcL8,3066
+tamar_model_client/generated/model_service_pb2_grpc.py,sha256=k4tIbp3XBxdyuOVR18Ung_4SUryONB51UYf_uUEl6V4,5145
+tamar_model_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
+tamar_model_client/schemas/inputs.py,sha256=AlvjTRp_UGnbmqzv4OJ3RjH4UGErzSNfKS8Puj6oEXQ,19088
+tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
+tamar_model_client-0.1.14.dist-info/METADATA,sha256=XB9fzmRzMJM2UL8udezQf6PHy103GgtwICGmlFUnn4U,16566
+tamar_model_client-0.1.14.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+tamar_model_client-0.1.14.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
+tamar_model_client-0.1.14.dist-info/RECORD,,

model_manager_client/__init__.py

@@ -1,11 +0,0 @@
-from .sync_client import ModelManagerClient
-from .async_client import AsyncModelManagerClient
-from .exceptions import ModelManagerClientError, ConnectionError, ValidationError
-
-__all__ = [
-    "ModelManagerClient",
-    "AsyncModelManagerClient",
-    "ModelManagerClientError",
-    "ConnectionError",
-    "ValidationError",
-]

model_manager_client/async_client.py

@@ -1,419 +0,0 @@
-import asyncio
-import atexit
-import json
-import logging
-import os
-
-import grpc
-from typing import Optional, AsyncIterator, Union, Iterable
-
-from openai import NOT_GIVEN
-from pydantic import BaseModel
-
-from .auth import JWTAuthHandler
-from .enums import ProviderType, InvokeType
-from .exceptions import ConnectionError, ValidationError
-from .schemas import ModelRequest, ModelResponse, BatchModelRequest, BatchModelResponse
-from .generated import model_service_pb2, model_service_pb2_grpc
-from .schemas.inputs import GoogleGenAiInput, OpenAIResponsesInput, OpenAIChatCompletionsInput
-
-if not logging.getLogger().hasHandlers():
-    # 配置日志格式
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s [%(levelname)s] %(message)s",
-    )
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncModelManagerClient:
-    def __init__(
-            self,
-            server_address: Optional[str] = None,
-            jwt_secret_key: Optional[str] = None,
-            jwt_token: Optional[str] = None,
-            default_payload: Optional[dict] = None,
-            token_expires_in: int = 3600,
-            max_retries: int = 3,  # 最大重试次数
-            retry_delay: float = 1.0,  # 初始重试延迟（秒）
-    ):
-        # 服务端地址
-        self.server_address = server_address or os.getenv("MODEL_MANAGER_SERVER_ADDRESS")
-        if not self.server_address:
-            raise ValueError("Server address must be provided via argument or environment variable.")
-        self.default_invoke_timeout = float(os.getenv("MODEL_MANAGER_SERVER_INVOKE_TIMEOUT", 30.0))
-
-        # JWT 配置
-        self.jwt_secret_key = jwt_secret_key or os.getenv("MODEL_MANAGER_SERVER_JWT_SECRET_KEY")
-        self.jwt_handler = JWTAuthHandler(self.jwt_secret_key)
-        self.jwt_token = jwt_token  # 用户传入的 Token（可选）
-        self.default_payload = default_payload
-        self.token_expires_in = token_expires_in
-
-        # === TLS/Authority 配置 ===
-        self.use_tls = os.getenv("MODEL_MANAGER_SERVER_GRPC_USE_TLS", "true").lower() == "true"
-        self.default_authority = os.getenv("MODEL_MANAGER_SERVER_GRPC_DEFAULT_AUTHORITY")
-
-        # === 重试配置 ===
-        self.max_retries = max_retries if max_retries is not None else int(
-            os.getenv("MODEL_MANAGER_SERVER_GRPC_MAX_RETRIES", 3))
-        self.retry_delay = retry_delay if retry_delay is not None else float(
-            os.getenv("MODEL_MANAGER_SERVER_GRPC_RETRY_DELAY", 1.0))
-
-        # === gRPC 通道相关 ===
-        self.channel: Optional[grpc.aio.Channel] = None
-        self.stub: Optional[model_service_pb2_grpc.ModelServiceStub] = None
-        self._closed = False
-        atexit.register(self._safe_sync_close)  # 注册进程退出自动关闭
-
-    def _build_auth_metadata(self) -> list:
-        if not self.jwt_token and self.jwt_handler:
-            self.jwt_token = self.jwt_handler.encode_token(self.default_payload, expires_in=self.token_expires_in)
-        return [("authorization", f"Bearer {self.jwt_token}")] if self.jwt_token else []
-
-    async def _ensure_initialized(self):
-        """初始化 gRPC 通道，支持 TLS 与重试机制"""
-        if self.channel and self.stub:
-            return
-
-        retry_count = 0
-        options = []
-        if self.default_authority:
-            options.append(("grpc.default_authority", self.default_authority))
-
-        while retry_count <= self.max_retries:
-            try:
-                if self.use_tls:
-                    credentials = grpc.ssl_channel_credentials()
-                    self.channel = grpc.aio.secure_channel(
-                        self.server_address,
-                        credentials,
-                        options=options
-                    )
-                    logger.info("🔐 Using secure gRPC channel (TLS enabled)")
-                else:
-                    self.channel = grpc.aio.insecure_channel(
-                        self.server_address,
-                        options=options
-                    )
-                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)")
-                await self.channel.channel_ready()
-                self.stub = model_service_pb2_grpc.ModelServiceStub(self.channel)
-                logger.info(f"✅ gRPC channel initialized to {self.server_address}")
-                return
-            except grpc.FutureTimeoutError as e:
-                logger.warning(f"❌ gRPC channel initialization timed out: {str(e)}")
-            except grpc.RpcError as e:
-                logger.warning(f"❌ gRPC channel initialization failed: {str(e)}")
-            except Exception as e:
-                logger.warning(f"❌ Unexpected error during channel initialization: {str(e)}")
-
-            retry_count += 1
-            if retry_count > self.max_retries:
-                raise ConnectionError(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.")
-
-            # 指数退避：延迟时间 = retry_delay * (2 ^ (retry_count - 1))
-            delay = self.retry_delay * (2 ** (retry_count - 1))
-            logger.info(f"🚀 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...")
-            await asyncio.sleep(delay)
-
-    async def _stream(self, model_request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
-        try:
-            async for response in self.stub.Invoke(model_request, metadata=metadata, timeout=invoke_timeout):
-                yield ModelResponse(
-                    content=response.content,
-                    usage=json.loads(response.usage) if response.usage else None,
-                    raw_response=json.loads(response.raw_response) if response.raw_response else None,
-                    error=response.error or None,
-                )
-        except grpc.RpcError as e:
-            raise ConnectionError(f"gRPC call failed: {str(e)}")
-        except Exception as e:
-            raise ValidationError(f"Invalid input: {str(e)}")
-
-    async def invoke(self, model_request: ModelRequest, timeout: Optional[float] = None) -> Union[
-        ModelResponse, AsyncIterator[ModelResponse]]:
-        """
-       通用调用模型方法。
-
-        Args:
-            model_request: ModelRequest 对象，包含请求参数。
-
-        Yields:
-            ModelResponse: 支持流式或非流式的模型响应
-
-        Raises:
-            ValidationError: 输入验证失败。
-            ConnectionError: 连接服务端失败。
-        """
-        await self._ensure_initialized()
-
-        if not self.default_payload:
-            self.default_payload = {
-                "org_id": model_request.user_context.org_id or "",
-                "user_id": model_request.user_context.user_id or ""
-            }
-
-        # 动态根据 provider/invoke_type 决定使用哪个 input 字段
-        try:
-            if model_request.provider == ProviderType.GOOGLE:
-                allowed_fields = GoogleGenAiInput.model_fields.keys()
-            elif model_request.provider in {ProviderType.OPENAI, ProviderType.AZURE}:
-                if model_request.invoke_type in {InvokeType.RESPONSES, InvokeType.GENERATION}:
-                    allowed_fields = OpenAIResponsesInput.model_fields.keys()
-                elif model_request.invoke_type == InvokeType.CHAT_COMPLETIONS:
-                    allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
-                else:
-                    raise ValueError(f"暂不支持的调用类型: {model_request.invoke_type}")
-            else:
-                raise ValueError(f"暂不支持的提供商: {model_request.provider}")
-
-            # 将 ModelRequest 转 dict，过滤只保留 base + allowed 的字段
-            model_request_dict = model_request.model_dump(exclude_unset=True)
-
-            grpc_request_kwargs = {}
-            for field in allowed_fields:
-                if field in model_request_dict:
-                    value = model_request_dict[field]
-
-                    # Skip fields with NotGiven or None (unless explicitly allowed)
-                    if value is NOT_GIVEN or value is None:
-                        continue
-
-                    # 特别处理：如果是自定义的 BaseModel 或特定类型
-                    if isinstance(value, BaseModel):
-                        grpc_request_kwargs[field] = value.model_dump()
-                    # 如果是 OpenAI / Google 里的自定义对象，通常有 dict() 方法
-                    elif hasattr(value, "dict") and callable(value.dict):
-                        grpc_request_kwargs[field] = value.dict()
-                    # 如果是 list，需要处理里面元素也是自定义对象的情况
-                    elif isinstance(value, Iterable) and not isinstance(value, (str, bytes, dict)):
-                        new_list = []
-                        for item in value:
-                            if isinstance(item, BaseModel):
-                                new_list.append(item.model_dump())
-                            elif hasattr(item, "dict") and callable(item.dict):
-                                new_list.append(item.dict())
-                            elif isinstance(item, dict):
-                                # Handle nested dictionaries
-                                nested_dict = {}
-                                for k, v in item.items():
-                                    if isinstance(v, BaseModel):
-                                        nested_dict[k] = v.model_dump()
-                                    elif hasattr(v, "dict") and callable(v.dict):
-                                        nested_dict[k] = v.dict()
-                                    else:
-                                        nested_dict[k] = v
-                                new_list.append(nested_dict)
-                            else:
-                                new_list.append(item)
-                        grpc_request_kwargs[field] = new_list
-                        # 如果是 dict，同理处理内部元素
-                    elif isinstance(value, dict):
-                        new_dict = {}
-                        for k, v in value.items():
-                            if isinstance(v, BaseModel):
-                                new_dict[k] = v.model_dump()
-                            elif hasattr(v, "dict") and callable(v.dict):
-                                new_dict[k] = v.dict()
-                            else:
-                                new_dict[k] = v
-                        grpc_request_kwargs[field] = new_dict
-                    else:
-                        grpc_request_kwargs[field] = value
-
-            request = model_service_pb2.ModelRequestItem(
-                provider=model_request.provider.value,
-                channel=model_request.channel.value,
-                invoke_type=model_request.invoke_type.value,
-                stream=model_request.stream or False,
-                org_id=model_request.user_context.org_id or "",
-                user_id=model_request.user_context.user_id or "",
-                client_type=model_request.user_context.client_type or "",
-                extra=grpc_request_kwargs
-            )
-
-        except Exception as e:
-            raise ValueError(f"构建请求失败: {str(e)}") from e
-
-        metadata = self._build_auth_metadata()
-
-        invoke_timeout = timeout or self.default_invoke_timeout
-        if model_request.stream:
-            return self._stream(request, metadata, invoke_timeout)
-        else:
-            async for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
-                return ModelResponse(
-                    content=response.content,
-                    usage=json.loads(response.usage) if response.usage else None,
-                    raw_response=json.loads(response.raw_response) if response.raw_response else None,
-                    error=response.error or None,
-                    custom_id=None,
-                    request_id=response.request_id if response.request_id else None,
-                )
-
-    async def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None) -> \
-            BatchModelResponse:
-        """
-        批量模型调用接口
-
-        Args:
-            batch_request_model: 多条 BatchModelRequest 输入
-            timeout: 调用超时，单位秒
-
-        Returns:
-            BatchModelResponse: 批量请求的结果
-        """
-        await self._ensure_initialized()
-
-        if not self.default_payload:
-            self.default_payload = {
-                "org_id": batch_request_model.user_context.org_id or "",
-                "user_id": batch_request_model.user_context.user_id or ""
-            }
-
-        metadata = self._build_auth_metadata()
-
-        # 构造批量请求
-        items = []
-        for model_request_item in batch_request_model.items:
-            # 动态根据 provider/invoke_type 决定使用哪个 input 字段
-            try:
-                if model_request_item.provider == ProviderType.GOOGLE:
-                    allowed_fields = GoogleGenAiInput.model_fields.keys()
-                elif model_request_item.provider in {ProviderType.OPENAI, ProviderType.AZURE}:
-                    if model_request_item.invoke_type in {InvokeType.RESPONSES, InvokeType.GENERATION}:
-                        allowed_fields = OpenAIResponsesInput.model_fields.keys()
-                    elif model_request_item.invoke_type == InvokeType.CHAT_COMPLETIONS:
-                        allowed_fields = OpenAIChatCompletionsInput.model_fields.keys()
-                    else:
-                        raise ValueError(f"暂不支持的调用类型: {model_request_item.invoke_type}")
-                else:
-                    raise ValueError(f"暂不支持的提供商: {model_request_item.provider}")
-
-                # 将 ModelRequest 转 dict，过滤只保留 base + allowed 的字段
-                model_request_dict = model_request_item.model_dump(exclude_unset=True)
-
-                grpc_request_kwargs = {}
-                for field in allowed_fields:
-                    if field in model_request_dict:
-                        value = model_request_dict[field]
-
-                        # Skip fields with NotGiven or None (unless explicitly allowed)
-                        if value is NOT_GIVEN or value is None:
-                            continue
-
-                        # 特别处理：如果是自定义的 BaseModel 或特定类型
-                        if isinstance(value, BaseModel):
-                            grpc_request_kwargs[field] = value.model_dump()
-                        # 如果是 OpenAI / Google 里的自定义对象，通常有 dict() 方法
-                        elif hasattr(value, "dict") and callable(value.dict):
-                            grpc_request_kwargs[field] = value.dict()
-                        # 如果是 list，需要处理里面元素也是自定义对象的情况
-                        elif isinstance(value, Iterable) and not isinstance(value, (str, bytes, dict)):
-                            new_list = []
-                            for item in value:
-                                if isinstance(item, BaseModel):
-                                    new_list.append(item.model_dump())
-                                elif hasattr(item, "dict") and callable(item.dict):
-                                    new_list.append(item.dict())
-                                elif isinstance(item, dict):
-                                    # Handle nested dictionaries
-                                    nested_dict = {}
-                                    for k, v in item.items():
-                                        if isinstance(v, BaseModel):
-                                            nested_dict[k] = v.model_dump()
-                                        elif hasattr(v, "dict") and callable(v.dict):
-                                            nested_dict[k] = v.dict()
-                                        else:
-                                            nested_dict[k] = v
-                                    new_list.append(nested_dict)
-                                else:
-                                    new_list.append(item)
-                            grpc_request_kwargs[field] = new_list
-                            # 如果是 dict，同理处理内部元素
-                        elif isinstance(value, dict):
-                            new_dict = {}
-                            for k, v in value.items():
-                                if isinstance(v, BaseModel):
-                                    new_dict[k] = v.model_dump()
-                                elif hasattr(v, "dict") and callable(v.dict):
-                                    new_dict[k] = v.dict()
-                                else:
-                                    new_dict[k] = v
-                            grpc_request_kwargs[field] = new_dict
-                        else:
-                            grpc_request_kwargs[field] = value
-
-                items.append(model_service_pb2.ModelRequestItem(
-                    provider=model_request_item.provider.value,
-                    channel=model_request_item.channel.value,
-                    invoke_type=model_request_item.invoke_type.value,
-                    stream=model_request_item.stream or False,
-                    custom_id=model_request_item.custom_id or "",
-                    priority=model_request_item.priority or 1,
-                    org_id=batch_request_model.user_context.org_id or "",
-                    user_id=batch_request_model.user_context.user_id or "",
-                    client_type=batch_request_model.user_context.client_type or "",
-                    extra=grpc_request_kwargs,
-                ))
-
-            except Exception as e:
-                raise ValueError(f"构建请求失败: {str(e)}，item={model_request_item.custom_id}") from e
-
-        try:
-            # 超时处理逻辑
-            invoke_timeout = timeout or self.default_invoke_timeout
-
-            # 调用 gRPC 接口
-            response = await self.stub.BatchInvoke(
-                model_service_pb2.ModelRequest(items=items),
-                timeout=invoke_timeout,
-                metadata=metadata
-            )
-
-            result = []
-            for res_item in response.items:
-                result.append(ModelResponse(
-                    content=res_item.content,
-                    usage=json.loads(res_item.usage) if res_item.usage else None,
-                    raw_response=json.loads(res_item.raw_response) if res_item.raw_response else None,
-                    error=res_item.error or None,
-                    custom_id=res_item.custom_id if res_item.custom_id else None
-                ))
-            return BatchModelResponse(
-                request_id=response.request_id if response.request_id else None,
-                responses=result
-            )
-        except grpc.RpcError as e:
-            raise ConnectionError(f"BatchInvoke failed: {str(e)}")
-
-    async def close(self):
-        """关闭 gRPC 通道"""
-        if self.channel and not self._closed:
-            await self.channel.close()
-            self._closed = True
-            await self.channel.close()
-            logger.info("✅ gRPC channel closed")
-
-    def _safe_sync_close(self):
-        """进程退出时自动关闭 channel（事件循环处理兼容）"""
-        if self.channel and not self._closed:
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self.close())
-                else:
-                    loop.run_until_complete(self.close())
-            except Exception as e:
-                logger.warning(f"❌ gRPC channel close failed at exit: {e}")
-
-    async def __aenter__(self):
-        """支持 async with 自动初始化连接"""
-        await self._ensure_initialized()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """支持 async with 自动关闭连接"""
-        await self.close()

model_manager_client/auth.py

@@ -1,14 +0,0 @@
-import time
-import jwt
-
-
-# JWT 处理类
-class JWTAuthHandler:
-    def __init__(self, secret_key: str):
-        self.secret_key = secret_key
-
-    def encode_token(self, payload: dict, expires_in: int = 3600) -> str:
-        """生成带过期时间的 JWT Token"""
-        payload = payload.copy()
-        payload["exp"] = int(time.time()) + expires_in
-        return jwt.encode(payload, self.secret_key, algorithm="HS256")

model_manager_client/enums/__init__.py

@@ -1,8 +0,0 @@
-"""
-枚举类型定义
-"""
-from .channel import Channel
-from .invoke import InvokeType
-from .providers import ProviderType
-
-__all__ = ["ProviderType", "InvokeType", "Channel"]

model_manager_client/enums/channel.py

@@ -1,11 +0,0 @@
-from enum import Enum
-
-
-class Channel(str, Enum):
-    """渠道枚举"""
-    OPENAI = "openai"
-    VERTEXAI = "vertexai"
-    AI_STUDIO = "ai-studio"
-
-    # 默认的
-    NORMAL = "normal"

model_manager_client/enums/invoke.py

@@ -1,10 +0,0 @@
-from enum import Enum
-
-
-class InvokeType(str, Enum):
-    """模型调用类型枚举"""
-    RESPONSES = "responses"
-    CHAT_COMPLETIONS = "chat-completions"
-
-    # 默认的
-    GENERATION = "generation"

model_manager_client/enums/providers.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class ProviderType(str, Enum):
-    """模型提供商类型枚举"""
-    OPENAI = "openai"
-    GOOGLE = "google"
-    AZURE = "azure"

model_manager_client/exceptions.py

@@ -1,11 +0,0 @@
-class ModelManagerClientError(Exception):
-    """Base exception for Model Manager Client errors"""
-    pass
-
-class ConnectionError(ModelManagerClientError):
-    """Raised when connection to gRPC server fails"""
-    pass
-
-class ValidationError(ModelManagerClientError):
-    """Raised when input validation fails"""
-    pass

model_manager_client/generated/model_service_pb2.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# NO CHECKED-IN PROTOBUF GENCODE
-# source: model_service.proto
-# Protobuf Python Version: 5.29.0
-"""Generated protocol buffer code."""
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import runtime_version as _runtime_version
-from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
-_runtime_version.ValidateProtobufRuntimeVersion(
-    _runtime_version.Domain.PUBLIC,
-    5,
-    29,
-    0,
-    '',
-    'model_service.proto'
-)
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x13model_service.proto\x12\rmodel_service\x1a\x1cgoogle/protobuf/struct.proto\"\x82\x02\n\x10ModelRequestItem\x12\x10\n\x08provider\x18\x01 \x01(\t\x12\x0f\n\x07\x63hannel\x18\x02 \x01(\t\x12\x13\n\x0binvoke_type\x18\x03 \x01(\t\x12\x0e\n\x06stream\x18\x04 \x01(\x08\x12\x0e\n\x06org_id\x18\x05 \x01(\t\x12\x0f\n\x07user_id\x18\x06 \x01(\t\x12\x13\n\x0b\x63lient_type\x18\x07 \x01(\t\x12\x15\n\x08priority\x18\x08 \x01(\x05H\x00\x88\x01\x01\x12\x16\n\tcustom_id\x18\t \x01(\tH\x01\x88\x01\x01\x12&\n\x05\x65xtra\x18\n \x01(\x0b\x32\x17.google.protobuf.StructB\x0b\n\t_priorityB\x0c\n\n_custom_id\">\n\x0cModelRequest\x12.\n\x05items\x18\x01 \x03(\x0b\x32\x1f.model_service.ModelRequestItem\"\xa6\x01\n\x11ModelResponseItem\x12\x0f\n\x07\x63ontent\x18\x01 \x01(\t\x12\r\n\x05usage\x18\x02 \x01(\t\x12\x14\n\x0craw_response\x18\x03 \x01(\t\x12\r\n\x05\x65rror\x18\x04 \x01(\t\x12\x16\n\tcustom_id\x18\x05 \x01(\tH\x00\x88\x01\x01\x12\x17\n\nrequest_id\x18\x06 \x01(\tH\x01\x88\x01\x01\x42\x0c\n\n_custom_idB\r\n\x0b_request_id\"T\n\rModelResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12/\n\x05items\x18\x02 \x03(\x0b\x32 .model_service.ModelResponseItem2\xa7\x01\n\x0cModelService\x12M\n\x06Invoke\x12\x1f.model_service.ModelRequestItem\x1a .model_service.ModelResponseItem0\x01\x12H\n\x0b\x42\x61tchInvoke\x12\x1b.model_service.ModelRequest\x1a\x1c.model_service.ModelResponseb\x06proto3')
-
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'model_service_pb2', _globals)
-if not _descriptor._USE_C_DESCRIPTORS:
-  DESCRIPTOR._loaded_options = None
-  _globals['_MODELREQUESTITEM']._serialized_start=69
-  _globals['_MODELREQUESTITEM']._serialized_end=327
-  _globals['_MODELREQUEST']._serialized_start=329
-  _globals['_MODELREQUEST']._serialized_end=391
-  _globals['_MODELRESPONSEITEM']._serialized_start=394
-  _globals['_MODELRESPONSEITEM']._serialized_end=560
-  _globals['_MODELRESPONSE']._serialized_start=562
-  _globals['_MODELRESPONSE']._serialized_end=646
-  _globals['_MODELSERVICE']._serialized_start=649
-  _globals['_MODELSERVICE']._serialized_end=816
-# @@protoc_insertion_point(module_scope)

model_manager_client/generated/model_service_pb2_grpc.py

@@ -1,145 +0,0 @@
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-"""Client and server classes corresponding to protobuf-defined services."""
-import grpc
-import warnings
-
-import model_manager_client.generated.model_service_pb2 as model__service__pb2
-
-GRPC_GENERATED_VERSION = '1.71.0'
-GRPC_VERSION = grpc.__version__
-_version_not_supported = False
-
-try:
-    from grpc._utilities import first_version_is_lower
-    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
-except ImportError:
-    _version_not_supported = True
-
-if _version_not_supported:
-    raise RuntimeError(
-        f'The grpc package installed is at version {GRPC_VERSION},'
-        + f' but the generated code in model_service_pb2_grpc.py depends on'
-        + f' grpcio>={GRPC_GENERATED_VERSION}.'
-        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
-        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
-    )
-
-
-class ModelServiceStub(object):
-    """grpc 服务（接口）定义
-    """
-
-    def __init__(self, channel):
-        """Constructor.
-
-        Args:
-            channel: A grpc.Channel.
-        """
-        self.Invoke = channel.unary_stream(
-                '/model_service.ModelService/Invoke',
-                request_serializer=model__service__pb2.ModelRequestItem.SerializeToString,
-                response_deserializer=model__service__pb2.ModelResponseItem.FromString,
-                _registered_method=True)
-        self.BatchInvoke = channel.unary_unary(
-                '/model_service.ModelService/BatchInvoke',
-                request_serializer=model__service__pb2.ModelRequest.SerializeToString,
-                response_deserializer=model__service__pb2.ModelResponse.FromString,
-                _registered_method=True)
-
-
-class ModelServiceServicer(object):
-    """grpc 服务（接口）定义
-    """
-
-    def Invoke(self, request, context):
-        """单条请求 + 流式响应
-        """
-        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-        context.set_details('Method not implemented!')
-        raise NotImplementedError('Method not implemented!')
-
-    def BatchInvoke(self, request, context):
-        """批量调用接口，不支持流式
-        """
-        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-        context.set_details('Method not implemented!')
-        raise NotImplementedError('Method not implemented!')
-
-
-def add_ModelServiceServicer_to_server(servicer, server):
-    rpc_method_handlers = {
-            'Invoke': grpc.unary_stream_rpc_method_handler(
-                    servicer.Invoke,
-                    request_deserializer=model__service__pb2.ModelRequestItem.FromString,
-                    response_serializer=model__service__pb2.ModelResponseItem.SerializeToString,
-            ),
-            'BatchInvoke': grpc.unary_unary_rpc_method_handler(
-                    servicer.BatchInvoke,
-                    request_deserializer=model__service__pb2.ModelRequest.FromString,
-                    response_serializer=model__service__pb2.ModelResponse.SerializeToString,
-            ),
-    }
-    generic_handler = grpc.method_handlers_generic_handler(
-            'model_service.ModelService', rpc_method_handlers)
-    server.add_generic_rpc_handlers((generic_handler,))
-    server.add_registered_method_handlers('model_service.ModelService', rpc_method_handlers)
-
-
- # This class is part of an EXPERIMENTAL API.
-class ModelService(object):
-    """grpc 服务（接口）定义
-    """
-
-    @staticmethod
-    def Invoke(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
-        return grpc.experimental.unary_stream(
-            request,
-            target,
-            '/model_service.ModelService/Invoke',
-            model__service__pb2.ModelRequestItem.SerializeToString,
-            model__service__pb2.ModelResponseItem.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True)
-
-    @staticmethod
-    def BatchInvoke(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
-        return grpc.experimental.unary_unary(
-            request,
-            target,
-            '/model_service.ModelService/BatchInvoke',
-            model__service__pb2.ModelRequest.SerializeToString,
-            model__service__pb2.ModelResponse.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True)

model_manager_client/schemas/__init__.py

@@ -1,17 +0,0 @@
-"""
-Schema definitions for the API
-"""
-
-from .inputs import UserContext, ModelRequest, BatchModelRequestItem, BatchModelRequest
-from .outputs import ModelResponse, BatchModelResponse
-
-__all__ = [
-    # Model Inputs
-    "UserContext",
-    "ModelRequest",
-    "BatchModelRequestItem",
-    "BatchModelRequest",
-    # Model Outputs
-    "ModelResponse",
-    "BatchModelResponse",
-]

model_manager_client/schemas/inputs.py

@@ -1,294 +0,0 @@
-import httpx
-from google.genai import types
-from openai import NotGiven, NOT_GIVEN
-from openai._types import Headers, Query, Body
-from openai.types import ChatModel, Metadata, ReasoningEffort, ResponsesModel, Reasoning
-from openai.types.chat import ChatCompletionMessageParam, ChatCompletionAudioParam, completion_create_params, \
-    ChatCompletionPredictionContentParam, ChatCompletionStreamOptionsParam, ChatCompletionToolChoiceOptionParam, \
-    ChatCompletionToolParam
-from openai.types.responses import ResponseInputParam, ResponseIncludable, ResponseTextConfigParam, \
-    response_create_params, ToolParam
-from pydantic import BaseModel, model_validator
-from typing import List, Optional, Union, Iterable, Dict, Literal
-
-from model_manager_client.enums import ProviderType, InvokeType
-from model_manager_client.enums.channel import Channel
-
-
-class UserContext(BaseModel):
-    org_id: str  # 组织id
-    user_id: str  # 用户id
-    client_type: str  # 客户端类型，这里记录的是哪个服务请求过来的
-
-
-class GoogleGenAiInput(BaseModel):
-    model: str
-    contents: Union[types.ContentListUnion, types.ContentListUnionDict]
-    config: Optional[types.GenerateContentConfigOrDict] = None
-
-    model_config = {
-        "arbitrary_types_allowed": True
-    }
-
-
-class OpenAIResponsesInput(BaseModel):
-    input: Union[str, ResponseInputParam]
-    model: ResponsesModel
-    include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN
-    instructions: Optional[str] | NotGiven = NOT_GIVEN
-    max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN
-    metadata: Optional[Metadata] | NotGiven = NOT_GIVEN
-    parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN
-    previous_response_id: Optional[str] | NotGiven = NOT_GIVEN
-    reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN
-    store: Optional[bool] | NotGiven = NOT_GIVEN
-    stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN
-    temperature: Optional[float] | NotGiven = NOT_GIVEN
-    text: ResponseTextConfigParam | NotGiven = NOT_GIVEN
-    tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN
-    tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN
-    top_p: Optional[float] | NotGiven = NOT_GIVEN
-    truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN
-    user: str | NotGiven = NOT_GIVEN
-    extra_headers: Headers | None = None
-    extra_query: Query | None = None
-    extra_body: Body | None = None
-    timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN
-
-    model_config = {
-        "arbitrary_types_allowed": True
-    }
-
-
-class OpenAIChatCompletionsInput(BaseModel):
-    messages: Iterable[ChatCompletionMessageParam]
-    model: Union[str, ChatModel]
-    audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN
-    frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN
-    function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN
-    functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN
-    logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN
-    logprobs: Optional[bool] | NotGiven = NOT_GIVEN
-    max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN
-    max_tokens: Optional[int] | NotGiven = NOT_GIVEN
-    metadata: Optional[Metadata] | NotGiven = NOT_GIVEN
-    modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN
-    n: Optional[int] | NotGiven = NOT_GIVEN
-    parallel_tool_calls: bool | NotGiven = NOT_GIVEN
-    prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN
-    presence_penalty: Optional[float] | NotGiven = NOT_GIVEN
-    reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN
-    response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN
-    seed: Optional[int] | NotGiven = NOT_GIVEN
-    service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN
-    stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN
-    store: Optional[bool] | NotGiven = NOT_GIVEN
-    stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN
-    stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN
-    temperature: Optional[float] | NotGiven = NOT_GIVEN
-    tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN
-    tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN
-    top_logprobs: Optional[int] | NotGiven = NOT_GIVEN
-    top_p: Optional[float] | NotGiven = NOT_GIVEN
-    user: str | NotGiven = NOT_GIVEN
-    web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN
-    extra_headers: Headers | None = None
-    extra_query: Query | None = None
-    extra_body: Body | None = None
-    timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN
-
-    model_config = {
-        "arbitrary_types_allowed": True
-    }
-
-
-class BaseRequest(BaseModel):
-    provider: ProviderType  # 供应商，如 "openai", "google" 等
-    channel: Channel = Channel.NORMAL  # 渠道：不同服务商之前有不同的调用SDK，这里指定是调用哪个SDK
-    invoke_type: InvokeType = InvokeType.TEXT_GENERATION  # 模型调用类型：generation-生成模型调用
-
-
-class ModelRequestInput(BaseRequest):
-    # 合并model字段
-    model: Optional[Union[str, ResponsesModel, ChatModel]] = None
-
-    # OpenAI Responses Input
-    input: Optional[Union[str, ResponseInputParam]] = None
-    include: Optional[Union[List[ResponseIncludable], NotGiven]] = NOT_GIVEN
-    instructions: Optional[Union[str, NotGiven]] = NOT_GIVEN
-    max_output_tokens: Optional[Union[int, NotGiven]] = NOT_GIVEN
-    metadata: Optional[Union[Metadata, NotGiven]] = NOT_GIVEN
-    parallel_tool_calls: Optional[Union[bool, NotGiven]] = NOT_GIVEN
-    previous_response_id: Optional[Union[str, NotGiven]] = NOT_GIVEN
-    reasoning: Optional[Union[Reasoning, NotGiven]] = NOT_GIVEN
-    store: Optional[Union[bool, NotGiven]] = NOT_GIVEN
-    stream: Optional[Union[Literal[False], Literal[True], NotGiven]] = NOT_GIVEN
-    temperature: Optional[Union[float, NotGiven]] = NOT_GIVEN
-    text: Optional[Union[ResponseTextConfigParam, NotGiven]] = NOT_GIVEN
-    tool_choice: Optional[
-        Union[response_create_params.ToolChoice, ChatCompletionToolChoiceOptionParam, NotGiven]] = NOT_GIVEN
-    tools: Optional[Union[Iterable[ToolParam], Iterable[ChatCompletionToolParam], NotGiven]] = NOT_GIVEN
-    top_p: Optional[Union[float, NotGiven]] = NOT_GIVEN
-    truncation: Optional[Union[Literal["auto", "disabled"], NotGiven]] = NOT_GIVEN
-    user: Optional[Union[str, NotGiven]] = NOT_GIVEN
-
-    extra_headers: Optional[Union[Headers, None]] = None
-    extra_query: Optional[Union[Query, None]] = None
-    extra_body: Optional[Union[Body, None]] = None
-    timeout: Optional[Union[float, httpx.Timeout, None, NotGiven]] = NOT_GIVEN
-
-    # OpenAI Chat Completions Input
-    messages: Optional[Iterable[ChatCompletionMessageParam]] = None
-    audio: Optional[Union[ChatCompletionAudioParam, NotGiven]] = NOT_GIVEN
-    frequency_penalty: Optional[Union[float, NotGiven]] = NOT_GIVEN
-    function_call: Optional[Union[completion_create_params.FunctionCall, NotGiven]] = NOT_GIVEN
-    functions: Optional[Union[Iterable[completion_create_params.Function], NotGiven]] = NOT_GIVEN
-    logit_bias: Optional[Union[Dict[str, int], NotGiven]] = NOT_GIVEN
-    logprobs: Optional[Union[bool, NotGiven]] = NOT_GIVEN
-    max_completion_tokens: Optional[Union[int, NotGiven]] = NOT_GIVEN
-    modalities: Optional[Union[List[Literal["text", "audio"]], NotGiven]] = NOT_GIVEN
-    n: Optional[Union[int, NotGiven]] = NOT_GIVEN
-    prediction: Optional[Union[ChatCompletionPredictionContentParam, NotGiven]] = NOT_GIVEN
-    presence_penalty: Optional[Union[float, NotGiven]] = NOT_GIVEN
-    reasoning_effort: Optional[Union[ReasoningEffort, NotGiven]] = NOT_GIVEN
-    response_format: Optional[Union[completion_create_params.ResponseFormat, NotGiven]] = NOT_GIVEN
-    seed: Optional[Union[int, NotGiven]] = NOT_GIVEN
-    service_tier: Optional[Union[Literal["auto", "default"], NotGiven]] = NOT_GIVEN
-    stop: Optional[Union[Optional[str], List[str], None, NotGiven]] = NOT_GIVEN
-    top_logprobs: Optional[Union[int, NotGiven]] = NOT_GIVEN
-    web_search_options: Optional[Union[completion_create_params.WebSearchOptions, NotGiven]] = NOT_GIVEN
-    stream_options: Optional[Union[ChatCompletionStreamOptionsParam, NotGiven]] = NOT_GIVEN
-
-    # Google GenAI Input
-    contents: Optional[Union[types.ContentListUnion, types.ContentListUnionDict]] = None
-    config: Optional[types.GenerateContentConfigOrDict] = None
-
-    model_config = {
-        "arbitrary_types_allowed": True
-    }
-
-
-class ModelRequest(ModelRequestInput):
-    user_context: UserContext  # 用户信息
-
-    @model_validator(mode="after")
-    def validate_by_provider_and_invoke_type(self) -> "ModelRequest":
-        """根据 provider 和 invoke_type 动态校验具体输入模型字段。"""
-        # 动态获取 allowed fields
-        base_allowed = ["provider", "channel", "invoke_type", "user_context"]
-        google_allowed = set(base_allowed) | set(GoogleGenAiInput.model_fields.keys())
-        openai_responses_allowed = set(base_allowed) | set(OpenAIResponsesInput.model_fields.keys())
-        openai_chat_allowed = set(base_allowed) | set(OpenAIChatCompletionsInput.model_fields.keys())
-
-        # 导入或定义你的原始输入模型
-        google_required_fields = {"model", "contents"}
-        openai_responses_required_fields = {"input", "model"}
-        openai_chat_required_fields = {"messages", "model"}
-
-        # 选择需要校验的字段集合
-        if self.provider == ProviderType.GOOGLE:
-            expected_fields = google_required_fields
-            allowed_fields = google_allowed
-        elif self.provider == ProviderType.OPENAI or self.provider == ProviderType.AZURE:
-            if self.invoke_type == InvokeType.RESPONSES or self.invoke_type == InvokeType.TEXT_GENERATION:
-                expected_fields = openai_responses_required_fields
-                allowed_fields = openai_responses_allowed
-            elif self.invoke_type == InvokeType.CHAT_COMPLETIONS:
-                expected_fields = openai_chat_required_fields
-                allowed_fields = openai_chat_allowed
-            else:
-                raise ValueError(f"暂不支持的调用类型: {self.invoke_type}")
-        else:
-            raise ValueError(f"暂不支持的提供商: {self.provider}")
-
-        # 检查是否缺失关键字段
-        missing = []
-        for field in expected_fields:
-            if getattr(self, field, None) is None:
-                missing.append(field)
-
-        if missing:
-            raise ValueError(
-                f"{self.provider}（{self.invoke_type}）请求缺少必填字段: {missing}"
-            )
-
-        # 检查是否有非法字段
-        illegal_fields = []
-        for name, value in self.__dict__.items():
-            if name in {"provider", "channel", "invoke_type", "stream"}:
-                continue
-            if name not in allowed_fields and value is not None and not isinstance(value, NotGiven):
-                illegal_fields.append(name)
-
-        if illegal_fields:
-            raise ValueError(
-                f"{self.provider}（{self.invoke_type}）存在不支持的字段: {illegal_fields}"
-            )
-
-        return self
-
-
-class BatchModelRequestItem(ModelRequestInput):
-    custom_id: Optional[str] = None
-    priority: Optional[int] = None  # （可选、预留字段）批量调用时执行的优先级
-
-    @model_validator(mode="after")
-    def validate_by_provider_and_invoke_type(self) -> "BatchModelRequestItem":
-        """根据 provider 和 invoke_type 动态校验具体输入模型字段。"""
-        # 动态获取 allowed fields
-        base_allowed = ["provider", "channel", "invoke_type", "custom_id", "priority"]
-        google_allowed = set(base_allowed) | set(GoogleGenAiInput.model_fields.keys())
-        openai_responses_allowed = set(base_allowed) | set(OpenAIResponsesInput.model_fields.keys())
-        openai_chat_allowed = set(base_allowed) | set(OpenAIChatCompletionsInput.model_fields.keys())
-
-        # 导入或定义你的原始输入模型
-        google_required_fields = {"model", "contents"}
-        openai_responses_required_fields = {"input", "model"}
-        openai_chat_required_fields = {"messages", "model"}
-
-        # 选择需要校验的字段集合
-        if self.provider == ProviderType.GOOGLE:
-            expected_fields = google_required_fields
-            allowed_fields = google_allowed
-        elif self.provider == ProviderType.OPENAI or self.provider == ProviderType.AZURE:
-            if self.invoke_type == InvokeType.RESPONSES or self.invoke_type == InvokeType.TEXT_GENERATION:
-                expected_fields = openai_responses_required_fields
-                allowed_fields = openai_responses_allowed
-            elif self.invoke_type == InvokeType.CHAT_COMPLETIONS:
-                expected_fields = openai_chat_required_fields
-                allowed_fields = openai_chat_allowed
-            else:
-                raise ValueError(f"暂不支持的调用类型: {self.invoke_type}")
-        else:
-            raise ValueError(f"暂不支持的提供商: {self.provider}")
-
-        # 检查是否缺失关键字段
-        missing = []
-        for field in expected_fields:
-            if getattr(self, field, None) is None:
-                missing.append(field)
-
-        if missing:
-            raise ValueError(
-                f"{self.provider}（{self.invoke_type}）请求缺少必填字段: {missing}"
-            )
-
-        # 检查是否有非法字段
-        illegal_fields = []
-        for name, value in self.__dict__.items():
-            if name in {"provider", "channel", "invoke_type", "stream"}:
-                continue
-            if name not in allowed_fields and value is not None and not isinstance(value, NotGiven):
-                illegal_fields.append(name)
-
-        if illegal_fields:
-            raise ValueError(
-                f"{self.provider}（{self.invoke_type}）存在不支持的字段: {illegal_fields}"
-            )
-
-        return self
-
-
-class BatchModelRequest(BaseModel):
-    user_context: UserContext  # 用户信息
-    items: List[BatchModelRequestItem]  # 批量请求项列表

model_manager_client/schemas/outputs.py

@@ -1,24 +0,0 @@
-from typing import Any, Iterator, Optional, Union, Dict, List
-
-from pydantic import BaseModel, ConfigDict
-
-
-class BaseResponse(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    content: Optional[str] = None  # 文本输出内容
-    usage: Optional[Dict] = None  # tokens / 请求成本等（JSON）
-    stream_response: Optional[Union[Iterator[str], Any]] = None  # 用于流式响应（同步 or 异步）
-    raw_response: Optional[Union[Dict, List]] = None  # 模型服务商返回的原始结构（JSON）
-    error: Optional[Any] = None  # 错误信息
-    custom_id: Optional[str] = None  # 自定义ID，用于批量请求时结果关联
-
-
-class ModelResponse(BaseResponse):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    request_id: Optional[str] = None  # 请求ID，用于跟踪请求
-
-
-class BatchModelResponse(BaseModel):
-    request_id: Optional[str] = None  # 请求ID，用于跟踪请求
-    responses: Optional[List[BaseResponse]] = None  # 批量请求的响应列表

model_manager_client/sync_client.py

@@ -1,111 +0,0 @@
-import asyncio
-import atexit
-import logging
-from typing import Optional, Union, Iterator
-
-from .async_client import AsyncModelManagerClient
-from .schemas import ModelRequest, BatchModelRequest, ModelResponse, BatchModelResponse
-
-logger = logging.getLogger(__name__)
-
-
-class ModelManagerClient:
-    """
-    同步版本的模型管理客户端，用于非异步环境（如 Flask、Django、脚本）。
-    内部封装 AsyncModelManagerClient 并处理事件循环兼容性。
-    """
-    _loop: Optional[asyncio.AbstractEventLoop] = None
-
-    def __init__(
-            self,
-            server_address: Optional[str] = None,
-            jwt_secret_key: Optional[str] = None,
-            jwt_token: Optional[str] = None,
-            default_payload: Optional[dict] = None,
-            token_expires_in: int = 3600,
-            max_retries: int = 3,
-            retry_delay: float = 1.0,
-    ):
-        # 初始化全局事件循环，仅创建一次
-        if not ModelManagerClient._loop:
-            try:
-                ModelManagerClient._loop = asyncio.get_running_loop()
-            except RuntimeError:
-                ModelManagerClient._loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(ModelManagerClient._loop)
-
-        self._loop = ModelManagerClient._loop
-
-        self._async_client = AsyncModelManagerClient(
-            server_address=server_address,
-            jwt_secret_key=jwt_secret_key,
-            jwt_token=jwt_token,
-            default_payload=default_payload,
-            token_expires_in=token_expires_in,
-            max_retries=max_retries,
-            retry_delay=retry_delay,
-        )
-        atexit.register(self._safe_sync_close)
-
-    def invoke(self, model_request: ModelRequest, timeout: Optional[float] = None) -> Union[
-        ModelResponse, Iterator[ModelResponse]]:
-        """
-        同步调用单个模型任务
-        """
-        if model_request.stream:
-            async def stream():
-                async for r in await self._async_client.invoke(model_request, timeout=timeout):
-                    yield r
-
-            return self._sync_wrap_async_generator(stream())
-        return self._run_async(self._async_client.invoke(model_request, timeout=timeout))
-
-    def invoke_batch(self, batch_model_request: BatchModelRequest,
-                     timeout: Optional[float] = None) -> BatchModelResponse:
-        """
-        同步调用批量模型任务
-        """
-        return self._run_async(self._async_client.invoke_batch(batch_model_request, timeout=timeout))
-
-    def close(self):
-        """手动关闭 gRPC 通道"""
-        self._run_async(self._async_client.close())
-
-    def _safe_sync_close(self):
-        """退出时自动关闭"""
-        try:
-            self._run_async(self._async_client.close())
-            logger.info("✅ gRPC channel closed at exit")
-        except Exception as e:
-            logger.warning(f"❌ gRPC channel close failed at exit: {e}")
-
-    def _run_async(self, coro):
-        """统一运行协程，兼容已存在的事件循环"""
-        try:
-            loop = asyncio.get_running_loop()
-            import nest_asyncio
-            nest_asyncio.apply()
-            return loop.run_until_complete(coro)
-        except RuntimeError:
-            return self._loop.run_until_complete(coro)
-
-    def _sync_wrap_async_generator(self, async_gen_func):
-        """
-        将 async generator 转换为同步 generator，逐条 yield。
-        """
-        loop = self._loop
-
-        # 创建异步生成器对象
-        agen = async_gen_func
-
-        class SyncGenerator:
-            def __iter__(self_inner):
-                return self_inner
-
-            def __next__(self_inner):
-                try:
-                    return loop.run_until_complete(agen.__anext__())
-                except StopAsyncIteration:
-                    raise StopIteration
-
-        return SyncGenerator()

tamar_model_client-0.1.12.dist-info/RECORD

@@ -1,34 +0,0 @@
-model_manager_client/__init__.py,sha256=LsqGh8ARtH9PQijbUjjrvHHmG09YwY4jmejAtlqV9ng,336
-model_manager_client/async_client.py,sha256=4vl4wLMucTqJ8moAZb0bonKYC6gFKwASZFQJIbCiBM4,20599
-model_manager_client/auth.py,sha256=gbwW5Aakeb49PMbmYvrYlVx1mfyn1LEDJ4qQVs-9DA4,438
-model_manager_client/exceptions.py,sha256=jYU494OU_NeIa4X393V-Y73mTNm0JZ9yZApnlOM9CJQ,332
-model_manager_client/sync_client.py,sha256=rLap64kk4rvAGJQsB7OXH565PW35xlMiSXh0iQTnJiM,4024
-model_manager_client/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
-model_manager_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
-model_manager_client/enums/invoke.py,sha256=9C5BxyAd4En-PSscOMynhfDa5WavGaSSOVFSYQGerK4,215
-model_manager_client/enums/providers.py,sha256=L_bX75K6KnWURoFizoitZ1Ybza7bmYDqXecNzNpgIrI,165
-model_manager_client/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-model_manager_client/generated/model_service_pb2.py,sha256=ST84YYQk8x6UtQKIx6HprUxH5uGU4i3LhC8b-lHUQtA,3066
-model_manager_client/generated/model_service_pb2_grpc.py,sha256=BzsINWQeACVnVzLVV0PgieZA25C2-EklMKlA-W50c6Y,5147
-model_manager_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
-model_manager_client/schemas/inputs.py,sha256=3HUxnbuyQbuvMz1C46zydFYz-iEvLAUWVzOx7-eKS_I,14338
-model_manager_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
-tamar_model_client/__init__.py,sha256=LMECAuDARWHV1XzH3msoDXcyurS2eihRQmBy26_PUE0,328
-tamar_model_client/async_client.py,sha256=gmZ2xMHO_F-Vtg3OK7B_yf-gtI-WH2NU2LzC6YO_t7k,19649
-tamar_model_client/auth.py,sha256=gbwW5Aakeb49PMbmYvrYlVx1mfyn1LEDJ4qQVs-9DA4,438
-tamar_model_client/exceptions.py,sha256=jYU494OU_NeIa4X393V-Y73mTNm0JZ9yZApnlOM9CJQ,332
-tamar_model_client/sync_client.py,sha256=o8b20fQUvtMq1gWax3_dfOpputYT4l9pRTz6cHdB0lg,4006
-tamar_model_client/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
-tamar_model_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
-tamar_model_client/enums/invoke.py,sha256=WufImoN_87ZjGyzYitZkhNNFefWJehKfLtyP-DTBYlA,267
-tamar_model_client/enums/providers.py,sha256=L_bX75K6KnWURoFizoitZ1Ybza7bmYDqXecNzNpgIrI,165
-tamar_model_client/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tamar_model_client/generated/model_service_pb2.py,sha256=RI6wNSmgmylzWPedFfPxx938UzS7kcPR58YTzYshcL8,3066
-tamar_model_client/generated/model_service_pb2_grpc.py,sha256=k4tIbp3XBxdyuOVR18Ung_4SUryONB51UYf_uUEl6V4,5145
-tamar_model_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
-tamar_model_client/schemas/inputs.py,sha256=ZqaBek2nluRhDqdXmetEvJRc2wKNxZZDCxPeng5KiIw,18734
-tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
-tamar_model_client-0.1.12.dist-info/METADATA,sha256=_1A8XLUsZuPbCeuuQukzMOE7IeizM6jX3s2N4-viwJM,16566
-tamar_model_client-0.1.12.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-tamar_model_client-0.1.12.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
-tamar_model_client-0.1.12.dist-info/RECORD,,