tamar-model-client 0.1.23__tar.gz → 0.1.25__tar.gz

{tamar_model_client-0.1.23 → tamar_model_client-0.1.25}/PKG-INFO

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="tamar-model-client",
-    version="0.1.23",
+    version="0.1.25",
     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.23 → tamar_model_client-0.1.25}/tamar_model_client/async_client.py

@@ -98,6 +98,9 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         # === gRPC 通道和连接管理 ===
         self.channel: Optional[grpc.aio.Channel] = None
         self.stub: Optional[model_service_pb2_grpc.ModelServiceStub] = None
+        self._channel_error_count = 0
+        self._last_channel_error_time = None
+        self._channel_lock = asyncio.Lock()  # 异步锁
         
         # === 增强的重试处理器 ===
         self.retry_handler = EnhancedRetryHandler(
@@ -176,9 +179,23 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         Raises:
             ConnectionError: 当达到最大重试次数仍无法连接时
         """
-        if self.channel and self.stub:
+        if self.channel and self.stub and await self._is_channel_healthy():
             return
 
+        # 如果 channel 存在但不健康，记录日志
+        if self.channel and self.stub:
+            logger.warning(
+                "Channel exists but unhealthy, will recreate",
+                extra={
+                    "log_type": "channel_recreate", 
+                    "data": {
+                        "channel_error_count": self._channel_error_count,
+                        "time_since_last_error": time.time() - self._last_channel_error_time if self._last_channel_error_time else None
+                    }
+                }
+            )
+            await self._recreate_channel()
+
         retry_count = 0
         options = self.build_channel_options()
 
@@ -228,6 +245,111 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                 await asyncio.sleep(self.retry_delay * retry_count)
 
         raise ConnectionError(f"Failed to connect to {self.server_address} after {self.max_retries} retries")
+    
+    async def _is_channel_healthy(self) -> bool:
+        """
+        检查 channel 是否健康
+        
+        Returns:
+            bool: True 如果 channel 健康，False 如果需要重建
+        """
+        if not self.channel:
+            return False
+            
+        try:
+            # 检查 channel 状态
+            state = self.channel.get_state()
+            
+            # 如果处于关闭或失败状态，需要重建
+            if state in [grpc.ChannelConnectivity.SHUTDOWN, 
+                        grpc.ChannelConnectivity.TRANSIENT_FAILURE]:
+                logger.warning(f"Channel in unhealthy state: {state}",
+                             extra={"log_type": "info", 
+                                   "data": {"channel_state": str(state)}})
+                return False
+                
+            # 如果最近有多次错误，也需要重建
+            if self._channel_error_count > 3 and self._last_channel_error_time:
+                if time.time() - self._last_channel_error_time < 60:  # 60秒内
+                    logger.warning("Too many channel errors recently, marking as unhealthy",
+                                 extra={"log_type": "info",
+                                       "data": {"error_count": self._channel_error_count}})
+                    return False
+                    
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error checking channel health: {e}",
+                        extra={"log_type": "info", 
+                              "data": {"error": str(e)}})
+            return False
+    
+    async def _recreate_channel(self):
+        """
+        重建 gRPC channel
+        
+        关闭旧的 channel 并创建新的连接
+        """
+        async with self._channel_lock:
+            # 关闭旧 channel
+            if self.channel:
+                try:
+                    await self.channel.close()
+                    logger.info("Closed unhealthy channel",
+                              extra={"log_type": "info"})
+                except Exception as e:
+                    logger.warning(f"Error closing channel: {e}",
+                                 extra={"log_type": "info"})
+                    
+            # 清空引用
+            self.channel = None
+            self.stub = None
+            
+            # 重置错误计数
+            self._channel_error_count = 0
+            self._last_channel_error_time = None
+            
+            logger.info("Recreating gRPC channel...",
+                       extra={"log_type": "info"})
+    
+    def _record_channel_error(self, error: grpc.RpcError):
+        """
+        记录 channel 错误，用于健康检查
+        
+        Args:
+            error: gRPC 错误
+        """
+        self._channel_error_count += 1
+        self._last_channel_error_time = time.time()
+        
+        # 获取当前 channel 状态
+        channel_state = None
+        if self.channel:
+            try:
+                channel_state = self.channel.get_state()
+            except:
+                channel_state = "UNKNOWN"
+        
+        # 对于严重错误，增加错误权重
+        if error.code() in [grpc.StatusCode.INTERNAL, 
+                           grpc.StatusCode.UNAVAILABLE]:
+            self._channel_error_count += 2
+            
+        # 记录详细的错误信息
+        logger.warning(
+            f"Channel error recorded: {error.code().name}",
+            extra={
+                "log_type": "channel_error",
+                "data": {
+                    "error_code": error.code().name,
+                    "error_count": self._channel_error_count,
+                    "channel_state": str(channel_state) if channel_state else "NO_CHANNEL",
+                    "time_since_last_error": time.time() - self._last_channel_error_time if self._last_channel_error_time else 0,
+                    "error_details": error.details() if hasattr(error, 'details') else "",
+                    "debug_string": error.debug_error_string() if hasattr(error, 'debug_error_string') else ""
+                }
+            }
+        )
 
     async def _retry_request(self, func, *args, **kwargs):
         """
@@ -315,7 +437,33 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                     elif retryable == 'conditional':
                         # 条件重试，特殊处理 CANCELLED
                         if error_code == grpc.StatusCode.CANCELLED:
-                            should_retry = error_context.is_network_cancelled()
+                            # 获取 channel 状态信息
+                            channel_state = None
+                            if self.channel:
+                                try:
+                                    channel_state = self.channel.get_state()
+                                except:
+                                    channel_state = "UNKNOWN"
+                            
+                            is_network_cancelled = error_context.is_network_cancelled()
+                            
+                            logger.warning(
+                                f"CANCELLED error in stream, channel state: {channel_state}",
+                                extra={
+                                    "log_type": "cancelled_debug",
+                                    "request_id": context.get('request_id'),
+                                    "data": {
+                                        "channel_state": str(channel_state) if channel_state else "NO_CHANNEL",
+                                        "channel_error_count": self._channel_error_count,
+                                        "time_since_last_error": time.time() - self._last_channel_error_time if self._last_channel_error_time else None,
+                                        "channel_healthy": await self._is_channel_healthy(),
+                                        "is_network_cancelled": is_network_cancelled,
+                                        "debug_string": e.debug_error_string() if hasattr(e, 'debug_error_string') else ""
+                                    }
+                                }
+                            )
+                            
+                            should_retry = is_network_cancelled
                         else:
                             should_retry = self._check_error_details_for_retry(e)
                     else:
@@ -363,6 +511,8 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                     )
                     context['duration'] = current_duration
                     last_exception = self.error_handler.handle_error(e, context)
+                    # 记录 channel 错误
+                    self._record_channel_error(e)
                     break
                     
                 last_exception = e
@@ -674,6 +824,10 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                              )
                          })
             
+            # 记录 channel 错误
+            if isinstance(e, grpc.RpcError):
+                self._record_channel_error(e)
+            
             # 记录失败并尝试降级（如果启用了熔断）
             if self.resilient_enabled and self.circuit_breaker:
                 # 将错误码传递给熔断器，用于智能失败统计

{tamar_model_client-0.1.23 → tamar_model_client-0.1.25}/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.23 → tamar_model_client-0.1.25}/tamar_model_client/sync_client.py

@@ -22,6 +22,7 @@ Tamar Model Client 同步客户端实现
 import json
 import logging
 import random
+import threading
 import time
 from typing import Optional, Union, Iterator
 
@@ -95,6 +96,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         # === gRPC 通道和连接管理 ===
         self.channel: Optional[grpc.Channel] = None
         self.stub: Optional[model_service_pb2_grpc.ModelServiceStub] = None
+        self._channel_error_count = 0
+        self._last_channel_error_time = None
+        self._channel_lock = threading.Lock()  # 线程安全的channel操作
 
     def close(self):
         """
@@ -143,8 +147,22 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         Raises:
             ConnectionError: 当达到最大重试次数仍无法连接时
         """
-        if self.channel and self.stub:
+        if self.channel and self.stub and self._is_channel_healthy():
             return
+            
+        # 如果 channel 存在但不健康，记录日志
+        if self.channel and self.stub:
+            logger.warning(
+                "Channel exists but unhealthy, will recreate",
+                extra={
+                    "log_type": "channel_recreate",
+                    "data": {
+                        "channel_error_count": self._channel_error_count,
+                        "time_since_last_error": time.time() - self._last_channel_error_time if self._last_channel_error_time else None
+                    }
+                }
+            )
+            self._recreate_channel()
 
         retry_count = 0
         options = self.build_channel_options()
@@ -196,6 +214,111 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 time.sleep(self.retry_delay * retry_count)
 
         raise ConnectionError(f"Failed to connect to {self.server_address} after {self.max_retries} retries")
+    
+    def _is_channel_healthy(self) -> bool:
+        """
+        检查 channel 是否健康
+        
+        Returns:
+            bool: True 如果 channel 健康，False 如果需要重建
+        """
+        if not self.channel:
+            return False
+            
+        try:
+            # 检查 channel 状态
+            state = self.channel._channel.check_connectivity_state(False)
+            
+            # 如果处于关闭或失败状态，需要重建
+            if state in [grpc.ChannelConnectivity.SHUTDOWN, 
+                        grpc.ChannelConnectivity.TRANSIENT_FAILURE]:
+                logger.warning(f"Channel in unhealthy state: {state}",
+                             extra={"log_type": "info", 
+                                   "data": {"channel_state": str(state)}})
+                return False
+                
+            # 如果最近有多次错误，也需要重建
+            if self._channel_error_count > 3 and self._last_channel_error_time:
+                if time.time() - self._last_channel_error_time < 60:  # 60秒内
+                    logger.warning("Too many channel errors recently, marking as unhealthy",
+                                 extra={"log_type": "info",
+                                       "data": {"error_count": self._channel_error_count}})
+                    return False
+                    
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error checking channel health: {e}",
+                        extra={"log_type": "info", 
+                              "data": {"error": str(e)}})
+            return False
+    
+    def _recreate_channel(self):
+        """
+        重建 gRPC channel
+        
+        关闭旧的 channel 并创建新的连接
+        """
+        with self._channel_lock:
+            # 关闭旧 channel
+            if self.channel:
+                try:
+                    self.channel.close()
+                    logger.info("Closed unhealthy channel",
+                              extra={"log_type": "info"})
+                except Exception as e:
+                    logger.warning(f"Error closing channel: {e}",
+                                 extra={"log_type": "info"})
+                    
+            # 清空引用
+            self.channel = None
+            self.stub = None
+            
+            # 重置错误计数
+            self._channel_error_count = 0
+            self._last_channel_error_time = None
+            
+            logger.info("Recreating gRPC channel...",
+                       extra={"log_type": "info"})
+    
+    def _record_channel_error(self, error: grpc.RpcError):
+        """
+        记录 channel 错误，用于健康检查
+        
+        Args:
+            error: gRPC 错误
+        """
+        self._channel_error_count += 1
+        self._last_channel_error_time = time.time()
+        
+        # 获取当前 channel 状态
+        channel_state = None
+        if self.channel:
+            try:
+                channel_state = self.channel._channel.check_connectivity_state(False)
+            except:
+                channel_state = "UNKNOWN"
+        
+        # 对于严重错误，增加错误权重
+        if error.code() in [grpc.StatusCode.INTERNAL, 
+                           grpc.StatusCode.UNAVAILABLE]:
+            self._channel_error_count += 2
+            
+        # 记录详细的错误信息
+        logger.warning(
+            f"Channel error recorded: {error.code().name}",
+            extra={
+                "log_type": "channel_error",
+                "data": {
+                    "error_code": error.code().name,
+                    "error_count": self._channel_error_count,
+                    "channel_state": str(channel_state) if channel_state else "NO_CHANNEL",
+                    "time_since_last_error": time.time() - self._last_channel_error_time if self._last_channel_error_time else 0,
+                    "error_details": error.details() if hasattr(error, 'details') else "",
+                    "debug_string": error.debug_error_string() if hasattr(error, 'debug_error_string') else ""
+                }
+            }
+        )
 
     def _retry_request(self, func, *args, **kwargs):
         """
@@ -237,6 +360,30 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 # 计算当前的耗时
                 current_duration = time.time() - method_start_time
                 
+                # 特殊处理 CANCELLED 错误
+                if e.code() == grpc.StatusCode.CANCELLED:
+                    channel_state = None
+                    if self.channel:
+                        try:
+                            channel_state = self.channel._channel.check_connectivity_state(False)
+                        except:
+                            channel_state = "UNKNOWN"
+                    
+                    logger.warning(
+                        f"CANCELLED error detected, channel state: {channel_state}",
+                        extra={
+                            "log_type": "cancelled_debug",
+                            "request_id": context.get('request_id'),
+                            "data": {
+                                "channel_state": str(channel_state) if channel_state else "NO_CHANNEL",
+                                "channel_error_count": self._channel_error_count,
+                                "time_since_last_error": time.time() - self._last_channel_error_time if self._last_channel_error_time else None,
+                                "channel_healthy": self._is_channel_healthy(),
+                                "debug_string": e.debug_error_string() if hasattr(e, 'debug_error_string') else ""
+                            }
+                        }
+                    )
+                
                 # 记录重试日志
                 log_data = {
                     "log_type": "info",
@@ -261,6 +408,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
 
                 context['duration'] = current_duration
                 last_exception = self.error_handler.handle_error(e, context)
+                
+                # 记录 channel 错误
+                self._record_channel_error(e)
 
             except Exception as e:
                 # 非 gRPC 错误，直接包装抛出
@@ -742,6 +892,10 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                              )
                          })
             
+            # 记录 channel 错误
+            if isinstance(e, grpc.RpcError):
+                self._record_channel_error(e)
+            
             # 记录失败并尝试降级（如果启用了熔断）
             if self.resilient_enabled and self.circuit_breaker:
                 # 将错误码传递给熔断器，用于智能失败统计

{tamar_model_client-0.1.23 → tamar_model_client-0.1.25}/tamar_model_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.23
+Version: 0.1.25
 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.23 → tamar_model_client-0.1.25}/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.23 → tamar_model_client-0.1.25}/tests/test_google_azure_final.py

@@ -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"
                 ),
@@ -645,10 +645,10 @@ async def main():
         # await asyncio.wait_for(test_batch_requests(), timeout=120.0)
 
         # 同步并发测试
-        #test_concurrent_requests(150)  # 测试150个并发请求
+        test_concurrent_requests(150)  # 测试150个并发请求
 
         # 异步并发测试
-        await test_async_concurrent_requests(2)  # 测试150个异步并发请求
+        await test_async_concurrent_requests(150)  # 测试150个异步并发请求
 
         print("\n✅ 测试完成")
 

tamar_model_client-0.1.23/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.23/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.23/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())