mdbq 4.2.9__tar.gz → 4.2.10__tar.gz

{mdbq-4.2.9 → mdbq-4.2.10}/PKG-INFO

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

mdbq-4.2.10/mdbq/__version__.py

@@ -0,0 +1 @@
+VERSION = '4.2.10'

{mdbq-4.2.9 → mdbq-4.2.10}/mdbq/redis/redis_cache.py

@@ -879,4 +879,286 @@ 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
+            
+            # 检查数据部分（支持多种数据字段名）
+            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 → mdbq-4.2.10}/mdbq.egg-info/PKG-INFO

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

mdbq-4.2.9/mdbq/__version__.py

@@ -1 +0,0 @@
-VERSION = '4.2.9'