tamar-model-client 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

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/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/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/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.dist-info → tamar_model_client-0.1.24.dist-info}/METADATA

@@ -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.dist-info → tamar_model_client-0.1.24.dist-info}/RECORD

@@ -1,12 +1,12 @@
 tamar_model_client/__init__.py,sha256=4DEIUGlLTeiaECjJQbGYik7C0JO6hHwwfbLYpYpMdzg,444
-tamar_model_client/async_client.py,sha256=8BbzeYX735xIaPJPF0oI3g-8oDKyl6GugxxCdBEGi5s,34400
+tamar_model_client/async_client.py,sha256=H6IhGI415DGXoeNAd4A0anw1oL4Ss3LYdcEVeG_Co68,34416
 tamar_model_client/auth.py,sha256=gbwW5Aakeb49PMbmYvrYlVx1mfyn1LEDJ4qQVs-9DA4,438
 tamar_model_client/circuit_breaker.py,sha256=0XHJXBYA4O8vwsDGwqNrae9zxNJphY5Rfucc9ytVFGA,5419
-tamar_model_client/error_handler.py,sha256=eEuwMcecJvQbFkIieri60uLoQX5sBMawnxxedxzxj5I,12745
-tamar_model_client/exceptions.py,sha256=D6G8igA-YO4AroeCa-9CDDPt4hSqBFX5C_4w-NCIL1w,13063
+tamar_model_client/error_handler.py,sha256=oI_jUTjnq4OXu8fwJoGXNmQpddEgOFF9ZUhbytq7H6c,12384
+tamar_model_client/exceptions.py,sha256=o1SxCiHVPsJwqP3bWIVPPDFcJOKFRg7zdp8oy9eaV3A,13073
 tamar_model_client/json_formatter.py,sha256=IyBv_pEEzjF-KaMF-7rxRpNc_fxRYK2A-pu_2n4Liow,1990
 tamar_model_client/logging_icons.py,sha256=MRTZ1Xvkep9ce_jdltj54_XZUXvIpQ95soRNmLdJ4qw,1837
-tamar_model_client/sync_client.py,sha256=mpWc6T9RjKnNDiETE8UYtKu2Zu0U6AME1kQMnDwnfMI,36225
+tamar_model_client/sync_client.py,sha256=RDM-ptIL0cNIie-2qpkTEFh60XTks8p2Wdz0Q5YHA1Q,36241
 tamar_model_client/utils.py,sha256=Kn6pFz9GEC96H4eejEax66AkzvsrXI3WCSDtgDjnVTI,5238
 tamar_model_client/core/__init__.py,sha256=bJRJllrp4Xc0g_qu1pW9G-lsXNB7c1r0NBIfb2Ypxe0,832
 tamar_model_client/core/base_client.py,sha256=sYvJZsDu_66akddAMowSnihFtgOoVKaQJxxnVruF9Ms,8995
@@ -27,10 +27,10 @@ tamar_model_client/schemas/inputs.py,sha256=dz1m8NbUIxA99JXZc8WlyzbKpDuz1lEzx3Vg
 tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
 tests/__init__.py,sha256=kbmImddLDwdqlkkmkyKtl4bQy_ipe-R8eskpaBylU9w,38
 tests/stream_hanging_analysis.py,sha256=W3W48IhQbNAR6-xvMpoWZvnWOnr56CTaH4-aORNBuD4,14807
-tests/test_google_azure_final.py,sha256=YFhjx2mQlFijcuHqOVnnS7ZD8mQWCf2Uv1oiqOFxASs,26393
+tests/test_google_azure_final.py,sha256=7SaVv8l0n5OXLdzzVOLgK8wC_kFFVx0tULZ8Y9_QAAw,26380
 tests/test_logging_issue.py,sha256=JTMbotfHpAEPMBj73pOwxPn-Zn4QVQJX6scMz48FRDQ,2427
 tests/test_simple.py,sha256=Xf0U-J9_xn_LzUsmYu06suK0_7DrPeko8OHoHldsNxE,7169
-tamar_model_client-0.1.22.dist-info/METADATA,sha256=jEEq8UTzqVcutF26FefqaxZ08WhNW58xiyEWZgDO7WA,23453
-tamar_model_client-0.1.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tamar_model_client-0.1.22.dist-info/top_level.txt,sha256=f1I-S8iWN-cgv4gB8gxRg9jJOTJMumvm4oGKVPfGg6A,25
-tamar_model_client-0.1.22.dist-info/RECORD,,
+tamar_model_client-0.1.24.dist-info/METADATA,sha256=ilgWWWLCU-vEJe1BmIBXrwGUvG3cnaVh-z49nbIIXcg,23453
+tamar_model_client-0.1.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tamar_model_client-0.1.24.dist-info/top_level.txt,sha256=f1I-S8iWN-cgv4gB8gxRg9jJOTJMumvm4oGKVPfGg6A,25
+tamar_model_client-0.1.24.dist-info/RECORD,,

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✅ 测试完成")