mdbq 4.2.9__py3-none-any.whl → 4.2.11__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '4.2.9'
+VERSION = '4.2.11'

mdbq/auth/crypto.py

@@ -175,8 +175,29 @@ class CryptoService:
     def decrypt_token(self, encrypted_token: str) -> Optional[Dict[str, Any]]:
         """解密令牌"""
         try:
+            # 验证输入参数
+            if not encrypted_token or not isinstance(encrypted_token, str):
+                self.logger.error("无效的加密令牌")
+                return None
+            
             # 解析加密数据
-            encrypted_data = json.loads(base64.b64decode(encrypted_token))
+            try:
+                encrypted_data = json.loads(base64.b64decode(encrypted_token))
+            except (json.JSONDecodeError, ValueError, TypeError) as e:
+                self.logger.error(f"解析加密数据失败: {str(e)}")
+                return None
+            
+            # 验证数据类型
+            if not isinstance(encrypted_data, dict):
+                self.logger.error("加密数据格式错误，应为字典类型")
+                return None
+            
+            # 验证必要的字段是否存在
+            required_fields = ['key', 'iv', 'ciphertext']
+            for field in required_fields:
+                if field not in encrypted_data:
+                    self.logger.error(f"加密数据缺少必要字段: {field}")
+                    return None
 
             # 获取私钥
             private_key = self.key_manager.get_private_key()
@@ -185,7 +206,11 @@ class CryptoService:
                 return None
             
             # 解密AES密钥
-            encrypted_aes_key = base64.b64decode(encrypted_data['key'])
+            try:
+                encrypted_aes_key = base64.b64decode(encrypted_data['key'])
+            except (ValueError, TypeError) as e:
+                self.logger.error(f"解码AES密钥失败: {str(e)}")
+                return None
             
             # 使用SHA-512加密算法
             try:
@@ -199,16 +224,25 @@ class CryptoService:
                 )
             except Exception as decrypt_error:
                 self.logger.error("RSA解密失败", {'error': str(decrypt_error)})
+                return None
             
             # 解密数据
-            iv = base64.b64decode(encrypted_data['iv'])
-            ciphertext = base64.b64decode(encrypted_data['ciphertext'])
+            try:
+                iv = base64.b64decode(encrypted_data['iv'])
+                ciphertext = base64.b64decode(encrypted_data['ciphertext'])
+            except (ValueError, TypeError) as e:
+                self.logger.error(f"解码IV或密文失败: {str(e)}")
+                return None
             
             # 检查是否有认证标签（AES-GCM需要）
             if 'tag' in encrypted_data:
-                tag = base64.b64decode(encrypted_data['tag'])
-                # 将tag附加到密文末尾（AES-GCM标准做法）
-                ciphertext_with_tag = ciphertext + tag
+                try:
+                    tag = base64.b64decode(encrypted_data['tag'])
+                    # 将tag附加到密文末尾（AES-GCM标准做法）
+                    ciphertext_with_tag = ciphertext + tag
+                except (ValueError, TypeError) as e:
+                    self.logger.error(f"解码认证标签失败: {str(e)}")
+                    return None
             else:
                 # 如果没有tag，假设密文已经包含tag
                 ciphertext_with_tag = ciphertext

mdbq/redis/redis_cache.py

@@ -879,4 +879,291 @@ class CacheManager:
 
 
 # 全局缓存管理器实例
-cache_manager = CacheManager() 
+cache_manager = CacheManager()
+
+
+# ===== 装饰器功能 =====
+
+def flask_redis_cache(cache_key_func=None, ttl=1200, namespace="default", 
+                data_validator=None, skip_cache_on_error=True):
+    """
+    Flask路由函数的Redis缓存装饰器
+    
+    Args:
+        cache_key_func: 缓存键生成函数，接收请求数据作为参数，返回缓存键字符串
+                       如果为None，则使用默认的键生成策略
+        ttl: 缓存过期时间（秒），默认20分钟
+        namespace: 缓存命名空间，默认为"default"
+        data_validator: 数据验证函数，用于验证数据是否应该被缓存
+        skip_cache_on_error: 当缓存操作出错时是否跳过缓存，默认True
+    
+    Usage:
+        @flask_redis_cache(
+            cache_key_func=lambda data: f"tables_{data.get('database', 'unknown')}",
+            ttl=1200,
+            namespace="sycm_tables"
+        )
+        def my_flask_route():
+            pass
+    """
+    def decorator(func):
+        import functools
+        import hashlib
+        
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # 导入Flask相关模块（延迟导入避免依赖问题）
+            try:
+                from flask import request, jsonify
+            except ImportError:
+                # 如果没有Flask环境，直接执行原函数
+                return func(*args, **kwargs)
+            
+            # 获取缓存系统
+            cache_system = cache_manager.get_cache()
+            
+            # 如果缓存系统不可用，直接执行原函数
+            if not cache_system:
+                return func(*args, **kwargs)
+            
+            try:
+                # 获取请求数据用于生成缓存键
+                request_data = {}
+                if request.method == 'POST':
+                    try:
+                        request_data = request.get_json() or {}
+                    except Exception:
+                        request_data = {}
+                elif request.method == 'GET':
+                    request_data = dict(request.args)
+                
+                # 生成缓存键
+                if cache_key_func:
+                    cache_key = cache_key_func(request_data)
+                else:
+                    # 默认缓存键生成策略
+                    func_name = func.__name__
+                    # 将请求数据转换为字符串并生成哈希
+                    data_str = str(sorted(request_data.items()))
+                    data_hash = hashlib.md5(data_str.encode()).hexdigest()[:8]
+                    cache_key = f"{func_name}_{data_hash}"
+                
+                # 尝试从缓存获取数据
+                try:
+                    cached_result = cache_system.get(cache_key, namespace)
+                    if cached_result is not None:
+                        return jsonify(cached_result)
+                except Exception as e:
+                    if not skip_cache_on_error:
+                        raise
+                
+                # 缓存未命中，执行原函数
+                result = func(*args, **kwargs)
+                
+                # 如果结果是Flask Response对象，提取JSON数据进行缓存
+                if hasattr(result, 'get_json'):
+                    try:
+                        response_data = result.get_json()
+                        if response_data:
+                            # 使用安全缓存写入
+                            _safe_cache_set(
+                                cache_system=cache_system,
+                                cache_key=cache_key,
+                                response_data=response_data,
+                                ttl=ttl,
+                                namespace=namespace,
+                                data_validator=data_validator
+                            )
+                    except Exception as e:
+                        if not skip_cache_on_error:
+                            raise
+                elif isinstance(result, tuple) and len(result) == 2:
+                    # 处理 (response, status_code) 格式的返回值
+                    try:
+                        response_data, status_code = result
+                        if hasattr(response_data, 'get_json'):
+                            json_data = response_data.get_json()
+                        elif isinstance(response_data, dict):
+                            json_data = response_data
+                        else:
+                            json_data = None
+                            
+                        if json_data and status_code == 200:
+                            _safe_cache_set(
+                                cache_system=cache_system,
+                                cache_key=cache_key,
+                                response_data=json_data,
+                                ttl=ttl,
+                                namespace=namespace,
+                                data_validator=data_validator
+                            )
+                    except Exception as e:
+                        if not skip_cache_on_error:
+                            raise
+                
+                return result
+                
+            except Exception as e:
+                if not skip_cache_on_error:
+                    raise
+                return func(*args, **kwargs)
+        
+        return wrapper
+    return decorator
+
+
+def function_redis_cache(cache_key_func=None, ttl=1800, namespace="default", 
+                        skip_cache_on_error=True):
+    """
+    普通函数的Redis缓存装饰器
+    
+    Args:
+        cache_key_func: 缓存键生成函数，接收函数参数作为输入，返回缓存键字符串
+                       如果为None，则使用默认的键生成策略
+        ttl: 缓存过期时间（秒），默认30分钟
+        namespace: 缓存命名空间，默认为"default"
+        skip_cache_on_error: 当缓存操作出错时是否跳过缓存，默认True
+    
+    Usage:
+        @function_redis_cache(
+            cache_key_func=lambda _key, shop_name: f"cookies_{_key}_{shop_name}",
+            ttl=1800,
+            namespace="cookies_cache"
+        )
+        def my_function(_key, shop_name):
+            pass
+    """
+    def decorator(func):
+        import functools
+        import inspect
+        import hashlib
+        
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # 获取缓存系统
+            cache_system = cache_manager.get_cache()
+            
+            # 如果缓存系统不可用，直接执行原函数
+            if not cache_system:
+                return func(*args, **kwargs)
+            
+            try:
+                # 获取函数签名和参数
+                sig = inspect.signature(func)
+                bound_args = sig.bind(*args, **kwargs)
+                bound_args.apply_defaults()
+                
+                # 生成缓存键
+                if cache_key_func:
+                    cache_key = cache_key_func(*args, **kwargs)
+                else:
+                    # 默认缓存键生成策略
+                    func_name = func.__name__
+                    # 将参数转换为字符串并生成哈希
+                    args_str = str(args) + str(sorted(kwargs.items()))
+                    args_hash = hashlib.md5(args_str.encode()).hexdigest()[:8]
+                    cache_key = f"{func_name}_{args_hash}"
+                
+                # 尝试从缓存获取数据
+                try:
+                    cached_result = cache_system.get(cache_key, namespace)
+                    if cached_result is not None:
+                        return cached_result
+                except Exception as e:
+                    if not skip_cache_on_error:
+                        raise
+                
+                # 缓存未命中，执行原函数
+                result = func(*args, **kwargs)
+                
+                # 缓存结果（只缓存非空结果）
+                if result is not None and result != {} and result != []:
+                    try:
+                        cache_system.set(cache_key, result, ttl=ttl, namespace=namespace)
+                    except Exception as e:
+                        if not skip_cache_on_error:
+                            raise
+                
+                return result
+                
+            except Exception as e:
+                if not skip_cache_on_error:
+                    raise
+                return func(*args, **kwargs)
+        
+        return wrapper
+    return decorator
+
+
+def _safe_cache_set(cache_system, cache_key, response_data, ttl, namespace, 
+                   data_validator=None):
+    """
+    安全的缓存写入函数，只有数据有效时才写入缓存。
+    
+    Args:
+        cache_system: 缓存系统实例
+        cache_key: 缓存键
+        response_data: 要缓存的响应数据
+        ttl: 缓存过期时间
+        namespace: 缓存命名空间
+        data_validator: 数据验证函数，返回True表示数据有效
+    
+    Returns:
+        bool: 是否成功写入缓存
+    """
+    if not cache_system:
+        return False
+    
+    # 默认验证逻辑：检查响应数据结构
+    if data_validator is None:
+        def default_validator(data):
+            if not isinstance(data, dict):
+                return False
+            
+            # 更宽松的验证逻辑，支持多种响应格式
+            # 检查状态字段（支持多种成功状态格式）
+            status_ok = (
+                data.get('status') == 'success' or  # 新格式
+                data.get('code') == 0 or            # 旧格式
+                data.get('code') == 200             # HTTP状态码格式
+            )
+            
+            if not status_ok:
+                return False
+            
+            # 检查 message 字段是否包含"失败"字样，如果包含则跳过缓存
+            message = data.get('message', '')
+            if isinstance(message, str) and ('失败' in message or 'error' in message or 'fail' in message):
+                return False
+            
+            # 检查数据部分（支持多种数据字段名）
+            has_data_fields = (
+                'data' in data or           # 标准data字段
+                'logs' in data or           # 更新日志专用
+                'announcements' in data or  # 公告数据
+                'databases' in data or      # 数据库列表
+                'tables' in data or         # 表列表
+                'rows' in data or           # 数据行
+                'message' in data           # 包含消息即认为有数据
+            )
+            
+            # 如果有数据字段，基本认为有效
+            return has_data_fields
+        
+        data_validator = default_validator
+    
+    # 验证数据
+    try:
+        is_valid = data_validator(response_data)
+    except Exception:
+        return False
+    
+    if is_valid:
+        try:
+            cache_system.set(cache_key, response_data, ttl=ttl, namespace=namespace)
+            return True
+        except Exception:
+            return False
+    else:
+        return False
+

{mdbq-4.2.9.dist-info → mdbq-4.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mdbq
-Version: 4.2.9
+Version: 4.2.11
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

{mdbq-4.2.9.dist-info → mdbq-4.2.11.dist-info}/RECORD

@@ -1,8 +1,8 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=PwnDhBzU9vJ8aV1MSozjgkNHRIFbITIJRr0jShLL9sU,17
+mdbq/__version__.py,sha256=MqhMtZv7l-q_wRQzpu6U2VaOi2Ddz7_1SDL7MMVF9vs,18
 mdbq/auth/__init__.py,sha256=pnPMAt63sh1B6kEvmutUuro46zVf2v2YDAG7q-jV_To,24
 mdbq/auth/auth_backend.py,sha256=iLN7AqiSq7fQgFtNtge_TIlVOR1hrCSZXH6oId6uGX4,116924
-mdbq/auth/crypto.py,sha256=fcZRFCnrKVVdWDUx_zds51ynFYwS9DBvJOrRQVldrfM,15931
+mdbq/auth/crypto.py,sha256=M0i4dRljJuE30WH_13ythA2QGKPXZm6TgpnYp6aHOzw,17431
 mdbq/auth/rate_limiter.py,sha256=1m_Paxp8pDNpmyoFGRpFMVOJpbmeIvfVcfiQ2oH72qM,32850
 mdbq/js/__init__.py,sha256=hpMi3_ZKwIWkzc0LnKL-SY9AS-7PYFHq0izYTgEvxjc,30
 mdbq/js/jc.py,sha256=6Rgf1WqaJJ1oevpn-pt08gXKbX5hjoQaV6uZGCAGbYw,13177
@@ -27,7 +27,7 @@ mdbq/pbix/pbix_refresh.py,sha256=JUjKW3bNEyoMVfVfo77UhguvS5AWkixvVhDbw4_MHco,239
 mdbq/pbix/refresh_all.py,sha256=OBT9EewSZ0aRS9vL_FflVn74d4l2G00wzHiikCC4TC0,5926
 mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
 mdbq/redis/getredis.py,sha256=vdg7YQEjhoMp5QzxygNGx5DQKRnePrcwPYgUrDypA6g,23672
-mdbq/redis/redis_cache.py,sha256=hjl-oh1r0ONdMeWN28cTMsdkcjc7HG71NmGZ9H6jWUE,34559
+mdbq/redis/redis_cache.py,sha256=JWarX_l7LvdKyxtUNPANAqd-y20Jg5uqmllCbT-fyv8,45752
 mdbq/route/__init__.py,sha256=BT_dAY7V-U2o72bevq1B9Mq9QA7GodwtkxyLNdGaoE8,22
 mdbq/route/analytics.py,sha256=dngj5hVwKddEUy59nSYbOoJ9C7OVrtCmCkvW6Uj9RYM,28097
 mdbq/route/monitor.py,sha256=lyowGUU8c2GykeZLrdxd7nXpNMqXWcOsuQsbS8l0pwU,36595
@@ -35,7 +35,7 @@ mdbq/route/routes.py,sha256=QVGfTvDgu0CpcKCvk1ra74H8uojgqTLUav1fnVAqLEA,29433
 mdbq/selenium/__init__.py,sha256=AKzeEceqZyvqn2dEDoJSzDQnbuENkJSHAlbHAD0u0ZI,10
 mdbq/selenium/get_driver.py,sha256=1NTlVUE6QsyjTrVVVqTO2LOnYf578ccFWlWnvIXGtic,20903
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
-mdbq-4.2.9.dist-info/METADATA,sha256=YlOb21xslQP4RpPDFfx9kUDhjVR_YrbHA5Pr5BJDXpk,363
-mdbq-4.2.9.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mdbq-4.2.9.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-4.2.9.dist-info/RECORD,,
+mdbq-4.2.11.dist-info/METADATA,sha256=HjK2Bl76B_V2Xpxh0lUkdAfk3thD2VXAmCAgkh23pWk,364
+mdbq-4.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mdbq-4.2.11.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-4.2.11.dist-info/RECORD,,

{mdbq-4.2.9.dist-info → mdbq-4.2.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any