tamar-model-client 0.1.22__tar.gz → 0.1.24__tar.gz

{tamar_model_client-0.1.22 → tamar_model_client-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.22
+Version: 0.1.24
 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.22 → tamar_model_client-0.1.24}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="tamar-model-client",
-    version="0.1.22",
+    version="0.1.24",
     description="A Python SDK for interacting with the Model Manager gRPC service",
     author="Oscar Ou",
     author_email="oscar.ou@tamaredge.ai",

{tamar_model_client-0.1.22 → tamar_model_client-0.1.24}/tamar_model_client/async_client.py

@@ -33,7 +33,7 @@ from .core import (
     generate_request_id,
     set_request_id,
     get_protected_logger,
-    MAX_MESSAGE_LENGTH
+    MAX_MESSAGE_LENGTH, get_request_id
 )
 from .core.base_client import BaseClient
 from .core.request_builder import RequestBuilder

{tamar_model_client-0.1.22 → tamar_model_client-0.1.24}/tamar_model_client/error_handler.py

@@ -11,6 +11,7 @@ import logging
 from typing import Optional, Dict, Any, Callable, Union
 from collections import defaultdict
 
+from .core import get_protected_logger
 from .exceptions import (
     ErrorContext, TamarModelException,
     NetworkException, ConnectionException, TimeoutException,
@@ -20,17 +21,16 @@ from .exceptions import (
     ERROR_CATEGORIES, RETRY_POLICY, ErrorStats
 )
 
-
-logger = logging.getLogger(__name__)
+logger = get_protected_logger(__name__)
 
 
 class GrpcErrorHandler:
     """统一的 gRPC 错误处理器"""
-    
+
     def __init__(self, client_logger: Optional[logging.Logger] = None):
         self.logger = client_logger or logger
         self.error_stats = ErrorStats()
-        
+
     def handle_error(self, error: Union[grpc.RpcError, Exception], context: dict) -> TamarModelException:
         """
         统一错误处理流程：
@@ -41,7 +41,7 @@ class GrpcErrorHandler:
         5. 返回相应异常
         """
         error_context = ErrorContext(error, context)
-        
+
         # 记录详细错误日志
         # 将error_context的重要信息平铺到日志的data字段中
         log_data = {
@@ -61,64 +61,64 @@ class GrpcErrorHandler:
                 "is_network_cancelled": error_context.is_network_cancelled() if error_context.error_code == grpc.StatusCode.CANCELLED else None
             }
         }
-        
+
         # 如果上下文中有 duration，添加到日志中
         if 'duration' in context:
             log_data['duration'] = context['duration']
-        
+
         self.logger.error(
             f"gRPC Error occurred: {error_context.error_code.name if error_context.error_code else 'UNKNOWN'}",
             extra=log_data
         )
-        
+
         # 更新错误统计
         if error_context.error_code:
             self.error_stats.record_error(error_context.error_code)
-        
+
         # 根据错误类型返回相应异常
         return self._create_exception(error_context)
-    
+
     def _create_exception(self, error_context: ErrorContext) -> TamarModelException:
         """根据错误上下文创建相应的异常"""
         error_code = error_context.error_code
-        
+
         if not error_code:
             return TamarModelException(error_context)
-        
+
         # 认证相关错误
         if error_code in ERROR_CATEGORIES['AUTH']:
             if error_code == grpc.StatusCode.UNAUTHENTICATED:
                 return TokenExpiredException(error_context)
             else:
                 return PermissionDeniedException(error_context)
-        
+
         # 网络相关错误
         elif error_code in ERROR_CATEGORIES['NETWORK']:
             if error_code == grpc.StatusCode.DEADLINE_EXCEEDED:
                 return TimeoutException(error_context)
             else:
                 return ConnectionException(error_context)
-        
+
         # 验证相关错误
         elif error_code in ERROR_CATEGORIES['VALIDATION']:
             return InvalidParameterException(error_context)
-        
+
         # 资源相关错误
         elif error_code == grpc.StatusCode.RESOURCE_EXHAUSTED:
             return RateLimitException(error_context)
-        
+
         # 服务商相关错误
         elif error_code in ERROR_CATEGORIES['PROVIDER']:
             return ProviderException(error_context)
-        
+
         # 默认错误
         else:
             return TamarModelException(error_context)
-    
+
     def get_error_stats(self) -> Dict[str, Any]:
         """获取错误统计信息"""
         return self.error_stats.get_stats()
-    
+
     def reset_stats(self):
         """重置错误统计"""
         self.error_stats.reset()
@@ -126,60 +126,60 @@ class GrpcErrorHandler:
 
 class ErrorRecoveryStrategy:
     """错误恢复策略"""
-    
+
     RECOVERY_ACTIONS = {
         'refresh_token': 'handle_token_refresh',
         'reconnect': 'handle_reconnect',
         'backoff': 'handle_backoff',
         'circuit_break': 'handle_circuit_break',
     }
-    
+
     def __init__(self, client):
         self.client = client
-        
+
     async def recover_from_error(self, error_context: ErrorContext):
         """根据错误类型执行恢复动作"""
         if not error_context.error_code:
             return
-            
+
         policy = RETRY_POLICY.get(error_context.error_code, {})
-        
+
         if action := policy.get('action'):
             if action in self.RECOVERY_ACTIONS:
                 handler = getattr(self, self.RECOVERY_ACTIONS[action])
                 await handler(error_context)
-    
+
     async def handle_token_refresh(self, error_context: ErrorContext):
         """处理 Token 刷新"""
         self.client.logger.info("Attempting to refresh JWT token")
         # 这里需要客户端实现 _refresh_jwt_token 方法
         if hasattr(self.client, '_refresh_jwt_token'):
             await self.client._refresh_jwt_token()
-    
+
     async def handle_reconnect(self, error_context: ErrorContext):
         """处理重连"""
         self.client.logger.info("Attempting to reconnect channel")
         # 这里需要客户端实现 _reconnect_channel 方法
         if hasattr(self.client, '_reconnect_channel'):
             await self.client._reconnect_channel()
-    
+
     async def handle_backoff(self, error_context: ErrorContext):
         """处理退避等待"""
         wait_time = self._calculate_backoff(error_context.retry_count)
         await asyncio.sleep(wait_time)
-    
+
     async def handle_circuit_break(self, error_context: ErrorContext):
         """处理熔断"""
         self.client.logger.warning("Circuit breaker activated")
         # 这里可以实现熔断逻辑
         pass
-    
+
     def _calculate_backoff(self, retry_count: int) -> float:
         """计算退避时间"""
         base_delay = 1.0
         max_delay = 60.0
         jitter_factor = 0.1
-        
+
         delay = min(base_delay * (2 ** retry_count), max_delay)
         jitter = random.uniform(0, delay * jitter_factor)
         return delay + jitter
@@ -187,18 +187,18 @@ class ErrorRecoveryStrategy:
 
 class EnhancedRetryHandler:
     """增强的重试处理器"""
-    
+
     def __init__(self, max_retries: int = 3, base_delay: float = 1.0):
         self.max_retries = max_retries
         self.base_delay = base_delay
         self.error_handler = GrpcErrorHandler()
-        
+
     async def execute_with_retry(
-        self, 
-        func: Callable, 
-        *args, 
-        context: Optional[Dict[str, Any]] = None,
-        **kwargs
+            self,
+            func: Callable,
+            *args,
+            context: Optional[Dict[str, Any]] = None,
+            **kwargs
     ):
         """
         执行函数并处理重试
@@ -218,19 +218,19 @@ class EnhancedRetryHandler:
         # 记录开始时间
         import time
         method_start_time = time.time()
-        
+
         context = context or {}
         last_exception = None
-        
+
         for attempt in range(self.max_retries + 1):
             try:
                 context['retry_count'] = attempt
                 return await func(*args, **kwargs)
-                
+
             except (grpc.RpcError, grpc.aio.AioRpcError) as e:
                 # 创建错误上下文
                 error_context = ErrorContext(e, context)
-                
+
                 # 判断是否可以重试
                 if not self._should_retry(e, attempt):
                     # 不可重试或已达到最大重试次数
@@ -238,10 +238,10 @@ class EnhancedRetryHandler:
                     context['duration'] = current_duration
                     last_exception = self.error_handler.handle_error(e, context)
                     break
-                
+
                 # 计算当前耗时
                 current_duration = time.time() - method_start_time
-                    
+
                 # 记录重试日志
                 log_data = {
                     "log_type": "info",
@@ -261,15 +261,15 @@ class EnhancedRetryHandler:
                     f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}",
                     extra=log_data
                 )
-                
+
                 # 执行退避等待
                 if attempt < self.max_retries:
                     delay = self._calculate_backoff(attempt)
                     await asyncio.sleep(delay)
-                
+
                 context['duration'] = current_duration
                 last_exception = self.error_handler.handle_error(e, context)
-            
+
             except Exception as e:
                 # 非 gRPC 错误，直接包装抛出
                 context['retry_count'] = attempt
@@ -277,28 +277,28 @@ class EnhancedRetryHandler:
                 error_context.error_message = str(e)
                 last_exception = TamarModelException(error_context)
                 break
-        
+
         # 抛出最后的异常
         if last_exception:
             raise last_exception
         else:
             raise TamarModelException("Unknown error occurred")
-    
+
     def _should_retry(self, error: grpc.RpcError, attempt: int) -> bool:
         """判断是否应该重试"""
         error_code = error.code()
         policy = RETRY_POLICY.get(error_code, {})
-        
+
         # 先检查错误级别的 max_attempts 配置
         # max_attempts 表示最大重试次数（不包括初始请求）
         error_max_attempts = policy.get('max_attempts', self.max_retries)
         if attempt >= error_max_attempts:
             return False
-            
+
         # 再检查全局的 max_retries
         if attempt >= self.max_retries:
             return False
-        
+
         # 检查基本重试策略
         retryable = policy.get('retryable', False)
         if retryable == False:
@@ -308,30 +308,30 @@ class EnhancedRetryHandler:
         elif retryable == 'conditional':
             # 条件重试，需要检查错误详情
             return self._check_conditional_retry(error)
-        
+
         return False
-    
+
     def _check_conditional_retry(self, error: grpc.RpcError) -> bool:
         """检查条件重试"""
         error_message = error.details().lower() if error.details() else ""
-        
+
         # 一些可重试的内部错误模式
         retryable_patterns = [
-            'temporary', 'timeout', 'unavailable', 
+            'temporary', 'timeout', 'unavailable',
             'connection', 'network', 'try again'
         ]
-        
+
         for pattern in retryable_patterns:
             if pattern in error_message:
                 return True
-                
+
         return False
-    
+
     def _calculate_backoff(self, attempt: int) -> float:
         """计算退避时间"""
         max_delay = 60.0
         jitter_factor = 0.1
-        
+
         delay = min(self.base_delay * (2 ** attempt), max_delay)
         jitter = random.uniform(0, delay * jitter_factor)
-        return delay + jitter
+        return delay + jitter

{tamar_model_client-0.1.22 → tamar_model_client-0.1.24}/tamar_model_client/exceptions.py

@@ -65,9 +65,9 @@ RETRY_POLICY = {
         'max_attempts': 3
     },
     grpc.StatusCode.INTERNAL: {
-        'retryable': 'conditional',  # 条件重试
+        'retryable': False,  # 内部错误通常不应重试
         'check_details': True,
-        'max_attempts': 2
+        'max_attempts': 0
     },
     grpc.StatusCode.UNAUTHENTICATED: {
         'retryable': True,

{tamar_model_client-0.1.22 → tamar_model_client-0.1.24}/tamar_model_client/sync_client.py

@@ -31,7 +31,7 @@ from .core import (
     generate_request_id,
     set_request_id,
     get_protected_logger,
-    MAX_MESSAGE_LENGTH
+    MAX_MESSAGE_LENGTH, get_request_id
 )
 from .core.base_client import BaseClient
 from .core.request_builder import RequestBuilder

{tamar_model_client-0.1.22 → tamar_model_client-0.1.24}/tamar_model_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.22
+Version: 0.1.24
 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.22 → tamar_model_client-0.1.24}/tamar_model_client.egg-info/SOURCES.txt

@@ -33,7 +33,4 @@ tamar_model_client/schemas/__init__.py
 tamar_model_client/schemas/inputs.py
 tamar_model_client/schemas/outputs.py
 tests/__init__.py
-tests/stream_hanging_analysis.py
-tests/test_google_azure_final.py
-tests/test_logging_issue.py
-tests/test_simple.py
+tests/test_google_azure_final.py

{tamar_model_client-0.1.22 → tamar_model_client-0.1.24}/tests/test_google_azure_final.py

@@ -27,7 +27,7 @@ test_logger.addHandler(test_handler)
 logger = test_logger
 
 os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "true"
-os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "model-manager-server-grpc-131786869360.asia-northeast1.run.app"
+os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "localhost:50051"
 os.environ['MODEL_MANAGER_SERVER_JWT_SECRET_KEY'] = "model-manager-server-jwt-key"
 
 # 导入客户端模块
@@ -414,7 +414,7 @@ def test_concurrent_requests(num_requests: int = 150):
                 model="tamar-google-gemini-flash-lite",
                 contents="1+1等于几？",
                 user_context=UserContext(
-                    user_id=f"concurrent_user_{request_id:03d}",
+                    user_id=f"{os.environ.get('INSTANCE_ID', '0')}_{request_id:03d}",
                     org_id="test_org",
                     client_type="concurrent_test"
                 ),
@@ -533,7 +533,7 @@ async def test_async_concurrent_requests(num_requests: int = 150):
                 model="tamar-google-gemini-flash-lite",
                 contents="1+1等于几？",
                 user_context=UserContext(
-                    user_id=f"async_concurrent_user_{request_id:03d}",
+                    user_id=f"{os.environ.get('INSTANCE_ID', '0')}_{request_id:03d}",
                     org_id="test_org",
                     client_type="async_concurrent_test"
                 ),
@@ -648,7 +648,7 @@ async def main():
         #test_concurrent_requests(150)  # 测试150个并发请求
 
         # 异步并发测试
-        await test_async_concurrent_requests(1000)  # 测试150个异步并发请求
+        await test_async_concurrent_requests(50)  # 测试150个异步并发请求
 
         print("\n✅ 测试完成")
 

tamar_model_client-0.1.22/tests/stream_hanging_analysis.py

@@ -1,357 +0,0 @@
-#!/usr/bin/env python3
-"""
-流式响应挂起分析和解决方案演示
-
-这个脚本模拟各种流式响应挂起场景，并展示解决方案。
-"""
-
-import asyncio
-import time
-import logging
-from typing import AsyncIterator, Optional
-from dataclasses import dataclass
-from enum import Enum
-
-# 配置日志
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-
-class StreamingFailureType(Enum):
-    """流式响应失败类型"""
-    PARTIAL_DATA_THEN_HANG = "partial_data_then_hang"          # 发送部分数据后挂起
-    NETWORK_INTERRUPTION = "network_interruption"              # 网络中断
-    SERVER_CRASH = "server_crash"                              # 服务器崩溃
-    SLOW_RESPONSE = "slow_response"                             # 响应过慢
-    CONNECTION_RESET = "connection_reset"                       # 连接重置
-
-
-@dataclass
-class StreamChunk:
-    """流式数据块"""
-    content: str
-    chunk_id: int
-    is_last: bool = False
-    error: Optional[str] = None
-
-
-class MockStreamingServer:
-    """模拟流式服务器的各种故障场景"""
-    
-    def __init__(self, failure_type: StreamingFailureType, failure_at_chunk: int = 3):
-        self.failure_type = failure_type
-        self.failure_at_chunk = failure_at_chunk
-        self.chunks_sent = 0
-    
-    async def generate_stream(self) -> AsyncIterator[StreamChunk]:
-        """生成流式数据"""
-        try:
-            while True:
-                self.chunks_sent += 1
-                
-                # 正常发送数据
-                if self.chunks_sent <= self.failure_at_chunk:
-                    chunk = StreamChunk(
-                        content=f"数据块 {self.chunks_sent}",
-                        chunk_id=self.chunks_sent,
-                        is_last=(self.chunks_sent == 10)  # 假设10个块就结束
-                    )
-                    logger.info(f"📦 发送数据块 {self.chunks_sent}: {chunk.content}")
-                    yield chunk
-                    
-                    # 模拟正常的块间延迟
-                    await asyncio.sleep(0.1)
-                    
-                    if chunk.is_last:
-                        logger.info("✅ 流式传输正常完成")
-                        return
-                
-                # 在指定位置触发故障
-                elif self.chunks_sent == self.failure_at_chunk + 1:
-                    await self._trigger_failure()
-                    # 故障后就不再发送数据
-                    return
-                    
-        except Exception as e:
-            logger.error(f"❌ 流式传输异常: {e}")
-            yield StreamChunk(
-                content="",
-                chunk_id=self.chunks_sent,
-                error=str(e)
-            )
-    
-    async def _trigger_failure(self):
-        """触发特定类型的故障"""
-        logger.warning(f"⚠️ 触发故障类型: {self.failure_type.value}")
-        
-        if self.failure_type == StreamingFailureType.PARTIAL_DATA_THEN_HANG:
-            logger.warning("🔄 服务器发送部分数据后挂起...")
-            # 无限等待，模拟服务器挂起
-            await asyncio.sleep(3600)  # 等待1小时（实际会被超时机制打断）
-            
-        elif self.failure_type == StreamingFailureType.NETWORK_INTERRUPTION:
-            logger.warning("📡 模拟网络中断...")
-            await asyncio.sleep(2)  # 短暂延迟后
-            raise ConnectionError("网络连接中断")
-            
-        elif self.failure_type == StreamingFailureType.SERVER_CRASH:
-            logger.warning("💥 模拟服务器崩溃...")
-            raise RuntimeError("服务器内部错误")
-            
-        elif self.failure_type == StreamingFailureType.SLOW_RESPONSE:
-            logger.warning("🐌 模拟服务器响应过慢...")
-            await asyncio.sleep(30)  # 30秒延迟
-            
-        elif self.failure_type == StreamingFailureType.CONNECTION_RESET:
-            logger.warning("🔌 模拟连接重置...")
-            raise ConnectionResetError("连接被重置")
-
-
-class StreamConsumer:
-    """流式数据消费者，演示不同的处理策略"""
-    
-    def __init__(self, name: str):
-        self.name = name
-        self.chunks_received = 0
-        self.start_time = time.time()
-    
-    async def consume_stream_basic(self, stream: AsyncIterator[StreamChunk]) -> bool:
-        """基础流消费（容易挂起的版本）"""
-        logger.info(f"🔄 {self.name}: 开始基础流消费...")
-        
-        try:
-            async for chunk in stream:
-                self.chunks_received += 1
-                logger.info(f"📥 {self.name}: 收到数据块 {chunk.chunk_id}: {chunk.content}")
-                
-                if chunk.error:
-                    logger.error(f"❌ {self.name}: 数据块包含错误: {chunk.error}")
-                    return False
-                
-                if chunk.is_last:
-                    logger.info(f"✅ {self.name}: 流正常结束")
-                    return True
-                    
-            logger.warning(f"⚠️ {self.name}: 流意外结束")
-            return False
-            
-        except Exception as e:
-            logger.error(f"❌ {self.name}: 流消费异常: {e}")
-            return False
-    
-    async def consume_stream_with_timeout(self, stream: AsyncIterator[StreamChunk], 
-                                        chunk_timeout: float = 5.0) -> bool:
-        """带超时保护的流消费"""
-        logger.info(f"🔄 {self.name}: 开始带超时保护的流消费 (块超时: {chunk_timeout}s)...")
-        
-        try:
-            # 注意：这种方法仍然有问题，因为 async for 本身不能被超时保护
-            async for chunk in stream:
-                self.chunks_received += 1
-                logger.info(f"📥 {self.name}: 收到数据块 {chunk.chunk_id}: {chunk.content}")
-                
-                if chunk.error:
-                    logger.error(f"❌ {self.name}: 数据块包含错误: {chunk.error}")
-                    return False
-                
-                if chunk.is_last:
-                    logger.info(f"✅ {self.name}: 流正常结束")
-                    return True
-                    
-            logger.warning(f"⚠️ {self.name}: 流意外结束")
-            return False
-            
-        except asyncio.TimeoutError:
-            logger.error(f"⏰ {self.name}: 流消费超时")
-            return False
-        except Exception as e:
-            logger.error(f"❌ {self.name}: 流消费异常: {e}")
-            return False
-    
-    async def consume_stream_with_chunk_timeout(self, stream: AsyncIterator[StreamChunk], 
-                                              chunk_timeout: float = 5.0,
-                                              total_timeout: float = 60.0) -> bool:
-        """正确的超时保护方案"""
-        logger.info(f"🔄 {self.name}: 开始改进的流消费 (块超时: {chunk_timeout}s, 总超时: {total_timeout}s)...")
-        
-        stream_iter = stream.__aiter__()
-        overall_start = time.time()
-        
-        try:
-            while True:
-                # 检查总体超时
-                if time.time() - overall_start > total_timeout:
-                    logger.error(f"⏰ {self.name}: 总体超时 ({total_timeout}s)")
-                    return False
-                
-                # 对单个数据块获取进行超时保护
-                try:
-                    chunk = await asyncio.wait_for(
-                        stream_iter.__anext__(), 
-                        timeout=chunk_timeout
-                    )
-                    
-                    self.chunks_received += 1
-                    logger.info(f"📥 {self.name}: 收到数据块 {chunk.chunk_id}: {chunk.content}")
-                    
-                    if chunk.error:
-                        logger.error(f"❌ {self.name}: 数据块包含错误: {chunk.error}")
-                        return False
-                    
-                    if chunk.is_last:
-                        logger.info(f"✅ {self.name}: 流正常结束")
-                        return True
-                        
-                except asyncio.TimeoutError:
-                    logger.error(f"⏰ {self.name}: 等待下一个数据块超时 ({chunk_timeout}s)")
-                    return False
-                    
-                except StopAsyncIteration:
-                    logger.warning(f"⚠️ {self.name}: 流意外结束")
-                    return False
-                    
-        except Exception as e:
-            logger.error(f"❌ {self.name}: 流消费异常: {e}")
-            return False
-    
-    async def consume_stream_with_heartbeat(self, stream: AsyncIterator[StreamChunk], 
-                                          heartbeat_interval: float = 2.0) -> bool:
-        """带心跳检测的流消费"""
-        logger.info(f"🔄 {self.name}: 开始带心跳检测的流消费...")
-        
-        stream_iter = stream.__aiter__()
-        last_heartbeat = time.time()
-        
-        async def heartbeat_monitor():
-            """心跳监控任务"""
-            while True:
-                await asyncio.sleep(heartbeat_interval)
-                if time.time() - last_heartbeat > heartbeat_interval * 3:
-                    logger.warning(f"💓 {self.name}: 心跳超时，可能存在问题")
-        
-        # 启动心跳监控
-        heartbeat_task = asyncio.create_task(heartbeat_monitor())
-        
-        try:
-            while True:
-                try:
-                    chunk = await asyncio.wait_for(
-                        stream_iter.__anext__(), 
-                        timeout=10.0  # 10秒超时
-                    )
-                    
-                    last_heartbeat = time.time()  # 更新心跳时间
-                    self.chunks_received += 1
-                    logger.info(f"📥 {self.name}: 收到数据块 {chunk.chunk_id}: {chunk.content}")
-                    
-                    if chunk.error:
-                        logger.error(f"❌ {self.name}: 数据块包含错误: {chunk.error}")
-                        return False
-                    
-                    if chunk.is_last:
-                        logger.info(f"✅ {self.name}: 流正常结束")
-                        return True
-                        
-                except asyncio.TimeoutError:
-                    logger.error(f"⏰ {self.name}: 等待数据块超时")
-                    return False
-                    
-                except StopAsyncIteration:
-                    logger.warning(f"⚠️ {self.name}: 流意外结束")
-                    return False
-                    
-        finally:
-            heartbeat_task.cancel()
-            try:
-                await heartbeat_task
-            except asyncio.CancelledError:
-                pass
-
-
-async def test_streaming_failure_scenario(failure_type: StreamingFailureType):
-    """测试特定的流式失败场景"""
-    logger.info(f"\n{'='*60}")
-    logger.info(f"🧪 测试场景: {failure_type.value}")
-    logger.info(f"{'='*60}")
-    
-    # 创建模拟服务器
-    server = MockStreamingServer(failure_type, failure_at_chunk=3)
-    
-    # 创建不同策略的消费者
-    consumers = [
-        ("基础消费者", "consume_stream_basic"),
-        ("改进的超时消费者", "consume_stream_with_chunk_timeout"),
-        ("心跳检测消费者", "consume_stream_with_heartbeat")
-    ]
-    
-    for consumer_name, method_name in consumers:
-        logger.info(f"\n🔍 测试 {consumer_name}...")
-        
-        consumer = StreamConsumer(consumer_name)
-        stream = server.generate_stream()
-        
-        start_time = time.time()
-        
-        try:
-            # 根据方法名调用不同的消费策略
-            method = getattr(consumer, method_name)
-            
-            if method_name == "consume_stream_basic":
-                # 基础方法需要额外的超时保护
-                success = await asyncio.wait_for(method(stream), timeout=15.0)
-            else:
-                success = await method(stream)
-            
-            duration = time.time() - start_time
-            
-            if success:
-                logger.info(f"✅ {consumer_name} 成功完成，耗时: {duration:.2f}s，收到 {consumer.chunks_received} 个数据块")
-            else:
-                logger.warning(f"⚠️ {consumer_name} 未能成功完成，耗时: {duration:.2f}s，收到 {consumer.chunks_received} 个数据块")
-                
-        except asyncio.TimeoutError:
-            duration = time.time() - start_time
-            logger.error(f"⏰ {consumer_name} 超时，耗时: {duration:.2f}s，收到 {consumer.chunks_received} 个数据块")
-            
-        except Exception as e:
-            duration = time.time() - start_time
-            logger.error(f"❌ {consumer_name} 异常: {e}，耗时: {duration:.2f}s，收到 {consumer.chunks_received} 个数据块")
-        
-        # 重置服务器状态进行下一个测试
-        server = MockStreamingServer(failure_type, failure_at_chunk=3)
-
-
-async def main():
-    """主测试函数"""
-    logger.info("🚀 开始流式响应挂起分析...")
-    
-    # 测试各种失败场景
-    failure_scenarios = [
-        StreamingFailureType.PARTIAL_DATA_THEN_HANG,
-        StreamingFailureType.NETWORK_INTERRUPTION,
-        StreamingFailureType.SERVER_CRASH,
-        StreamingFailureType.SLOW_RESPONSE,
-    ]
-    
-    for scenario in failure_scenarios:
-        try:
-            await test_streaming_failure_scenario(scenario)
-        except Exception as e:
-            logger.error(f"❌ 测试场景 {scenario.value} 时出错: {e}")
-    
-    logger.info(f"\n{'='*60}")
-    logger.info("🎯 分析结论:")
-    logger.info("1. 基础的 async for 循环容易在流中断时挂起")
-    logger.info("2. 需要对单个数据块的获取进行超时保护")
-    logger.info("3. 心跳检测可以提供额外的监控能力")
-    logger.info("4. 总体超时 + 块超时的双重保护最为可靠")
-    logger.info(f"{'='*60}")
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        logger.info("\n⚠️ 用户中断测试")
-    finally:
-        logger.info("🏁 流式响应分析完成")

tamar_model_client-0.1.22/tests/test_logging_issue.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""
-测试日志格式问题
-"""
-
-import asyncio
-import logging
-import os
-import sys
-
-# 设置环境变量
-os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "false"
-os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "localhost:50051"
-os.environ['MODEL_MANAGER_SERVER_JWT_SECRET_KEY'] = "model-manager-server-jwt-key"
-
-# 先导入 SDK
-from tamar_model_client import AsyncTamarModelClient
-from tamar_model_client.schemas import ModelRequest, UserContext
-from tamar_model_client.enums import ProviderType, InvokeType, Channel
-
-# 检查 SDK 的日志配置
-print("=== SDK Logger Configuration ===")
-sdk_loggers = [
-    'tamar_model_client',
-    'tamar_model_client.async_client',
-    'tamar_model_client.error_handler',
-    'tamar_model_client.core.base_client'
-]
-
-for logger_name in sdk_loggers:
-    logger = logging.getLogger(logger_name)
-    print(f"\nLogger: {logger_name}")
-    print(f"  Level: {logging.getLevelName(logger.level)}")
-    print(f"  Handlers: {len(logger.handlers)}")
-    for i, handler in enumerate(logger.handlers):
-        print(f"    Handler {i}: {type(handler).__name__}")
-        if hasattr(handler, 'formatter'):
-            print(f"      Formatter: {type(handler.formatter).__name__ if handler.formatter else 'None'}")
-    print(f"  Propagate: {logger.propagate}")
-
-
-async def test_error_logging():
-    """测试错误日志格式"""
-    print("\n=== Testing Error Logging ===")
-    
-    try:
-        async with AsyncTamarModelClient() as client:
-            # 故意创建一个会失败的请求
-            request = ModelRequest(
-                provider=ProviderType.GOOGLE,
-                channel=Channel.VERTEXAI,
-                invoke_type=InvokeType.GENERATION,
-                model="invalid-model",
-                contents="test",
-                user_context=UserContext(
-                    user_id="test_user",
-                    org_id="test_org",
-                    client_type="test_client"
-                )
-            )
-            
-            response = await client.invoke(request, timeout=5.0)
-            print(f"Response: {response}")
-            
-    except Exception as e:
-        print(f"Exception caught: {type(e).__name__}: {str(e)}")
-
-
-async def main():
-    await test_error_logging()
-
-
-if __name__ == "__main__":
-    print("Starting logging test...")
-    asyncio.run(main())

tamar_model_client-0.1.22/tests/test_simple.py

@@ -1,235 +0,0 @@
-#!/usr/bin/env python3
-"""
-简化版的 Google/Azure 场景测试脚本
-只保留基本调用和打印功能
-"""
-
-import asyncio
-import logging
-import os
-import sys
-
-# 配置日志
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "false"
-os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "localhost:50051"
-os.environ['MODEL_MANAGER_SERVER_JWT_SECRET_KEY'] = "model-manager-server-jwt-key"
-
-# 导入客户端模块
-try:
-    from tamar_model_client import TamarModelClient, AsyncTamarModelClient
-    from tamar_model_client.schemas import ModelRequest, UserContext
-    from tamar_model_client.enums import ProviderType, InvokeType, Channel
-except ImportError as e:
-    logger.error(f"导入模块失败: {e}")
-    sys.exit(1)
-
-
-def test_google_ai_studio():
-    """测试 Google AI Studio"""
-    print("\n🔍 测试 Google AI Studio...")
-    
-    try:
-        client = TamarModelClient()
-        
-        request = ModelRequest(
-            provider=ProviderType.GOOGLE,
-            channel=Channel.AI_STUDIO,
-            invoke_type=InvokeType.GENERATION,
-            model="gemini-pro",
-            contents=[
-                {"role": "user", "parts": [{"text": "Hello, how are you?"}]}
-            ],
-            user_context=UserContext(
-                user_id="test_user",
-                org_id="test_org",
-                client_type="test_client"
-            ),
-            config={
-                "temperature": 0.7,
-                "maxOutputTokens": 100
-            }
-        )
-        
-        response = client.invoke(request)
-        print(f"✅ Google AI Studio 成功")
-        print(f"   响应类型: {type(response)}")
-        print(f"   响应内容: {str(response)[:200]}...")
-        
-    except Exception as e:
-        print(f"❌ Google AI Studio 失败: {str(e)}")
-
-
-def test_google_vertex_ai():
-    """测试 Google Vertex AI"""
-    print("\n🔍 测试 Google Vertex AI...")
-    
-    try:
-        client = TamarModelClient()
-        
-        request = ModelRequest(
-            provider=ProviderType.GOOGLE,
-            channel=Channel.VERTEXAI,
-            invoke_type=InvokeType.GENERATION,
-            model="gemini-1.5-flash",
-            contents=[
-                {"role": "user", "parts": [{"text": "What is AI?"}]}
-            ],
-            user_context=UserContext(
-                user_id="test_user",
-                org_id="test_org",
-                client_type="test_client"
-            ),
-            config={
-                "temperature": 0.5
-            }
-        )
-        
-        response = client.invoke(request)
-        print(f"✅ Google Vertex AI 成功")
-        print(f"   响应类型: {type(response)}")
-        print(f"   响应内容: {str(response)[:200]}...")
-        
-    except Exception as e:
-        print(f"❌ Google Vertex AI 失败: {str(e)}")
-
-
-def test_azure_openai():
-    """测试 Azure OpenAI"""
-    print("\n☁️  测试 Azure OpenAI...")
-    
-    try:
-        client = TamarModelClient()
-        
-        request = ModelRequest(
-            provider=ProviderType.AZURE,
-            channel=Channel.OPENAI,
-            invoke_type=InvokeType.CHAT_COMPLETIONS,
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "user", "content": "Hello, how are you?"}
-            ],
-            user_context=UserContext(
-                user_id="test_user",
-                org_id="test_org",
-                client_type="test_client"
-            ),
-            temperature=0.7,
-            max_tokens=100
-        )
-        
-        response = client.invoke(request)
-        print(f"✅ Azure OpenAI 成功")
-        print(f"   响应类型: {type(response)}")
-        print(f"   响应内容: {str(response)[:200]}...")
-        
-    except Exception as e:
-        print(f"❌ Azure OpenAI 失败: {str(e)}")
-
-
-async def test_google_streaming():
-    """测试 Google 流式响应"""
-    print("\n📡 测试 Google 流式响应...")
-    
-    try:
-        client = AsyncTamarModelClient()
-        
-        request = ModelRequest(
-            provider=ProviderType.GOOGLE,
-            channel=Channel.AI_STUDIO,
-            invoke_type=InvokeType.GENERATION,
-            model="gemini-pro",
-            contents=[
-                {"role": "user", "parts": [{"text": "Count 1 to 5"}]}
-            ],
-            user_context=UserContext(
-                user_id="test_user",
-                org_id="test_org",
-                client_type="test_client"
-            ),
-            stream=True,
-            config={
-                "temperature": 0.1,
-                "maxOutputTokens": 50
-            }
-        )
-        
-        response_gen = await client.invoke(request)
-        print(f"✅ Google 流式调用成功")
-        print(f"   响应类型: {type(response_gen)}")
-        
-        chunk_count = 0
-        async for chunk in response_gen:
-            chunk_count += 1
-            print(f"   数据块 {chunk_count}: {type(chunk)} - {str(chunk)[:100]}...")
-            if chunk_count >= 3:  # 只显示前3个数据块
-                break
-        
-    except Exception as e:
-        print(f"❌ Google 流式响应失败: {str(e)}")
-
-
-async def test_azure_streaming():
-    """测试 Azure 流式响应"""
-    print("\n📡 测试 Azure 流式响应...")
-    
-    try:
-        client = AsyncTamarModelClient()
-        
-        request = ModelRequest(
-            provider=ProviderType.AZURE,
-            channel=Channel.OPENAI,
-            invoke_type=InvokeType.CHAT_COMPLETIONS,
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "user", "content": "Count 1 to 5"}
-            ],
-            user_context=UserContext(
-                user_id="test_user",
-                org_id="test_org",
-                client_type="test_client"
-            ),
-            stream=True,
-            temperature=0.1,
-            max_tokens=50
-        )
-        
-        response_gen = await client.invoke(request)
-        print(f"✅ Azure 流式调用成功")
-        print(f"   响应类型: {type(response_gen)}")
-        
-        chunk_count = 0
-        async for chunk in response_gen:
-            chunk_count += 1
-            print(f"   数据块 {chunk_count}: {type(chunk)} - {str(chunk)[:100]}...")
-            if chunk_count >= 3:  # 只显示前3个数据块
-                break
-        
-    except Exception as e:
-        print(f"❌ Azure 流式响应失败: {str(e)}")
-
-
-async def main():
-    """主函数"""
-    print("🚀 简化版 Google/Azure 测试")
-    print("=" * 50)
-    
-    # 同步测试
-    test_google_ai_studio()
-    test_google_vertex_ai()
-    test_azure_openai()
-    
-    # 异步流式测试
-    await test_google_streaming()
-    await test_azure_streaming()
-    
-    print("\n✅ 测试完成")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())