mdbq 4.0.35__py3-none-any.whl → 4.0.37__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '4.0.35'
+VERSION = '4.0.37'

mdbq/log/mylogger.py

@@ -12,6 +12,7 @@ import atexit
 import traceback
 import inspect
 import psutil
+import multiprocessing
 
 
 def get_caller_filename(default='mylogger'):
@@ -70,7 +71,8 @@ class MyLogger:
             enable_metrics: bool = False,
             metrics_interval: int = 300,
             message_limited: int = 1000,
-            flush_interval: int = 5
+            flush_interval: int = 5,
+            enable_multiprocess: bool = False
     ):
         """
         初始化日志器
@@ -90,6 +92,7 @@ class MyLogger:
         :param metrics_interval: 指标采集间隔(秒)
         :param message_limited: 简化日志内容，避免过长
         :param flush_interval: 定时刷新日志器间隔(秒)
+        :param enable_multiprocess: 是否启用多进程安全日志
         """
         log_path = os.path.join(os.path.expanduser("~"), 'logfile')
         if name is None:
@@ -113,8 +116,14 @@ class MyLogger:
         self.filters = filters or []
         self.enable_metrics = enable_metrics
         self.metrics_interval = metrics_interval
-        self.message_limited = message_limited
-        self.flush_interval = flush_interval
+        self.message_limited = max(1, int(message_limited))
+        self.flush_interval = max(1, int(flush_interval))
+        self.enable_multiprocess = enable_multiprocess
+        self._mp_queue = None
+        self._mp_writer_process = None
+        self._is_main_process = multiprocessing.current_process().name == 'MainProcess'
+        self._stop_event = threading.Event()
+        self._flush_thread = None
 
         # 上下文相关
         self._context = threading.local()
@@ -133,7 +142,9 @@ class MyLogger:
         self.logger = logging.getLogger(name)
         self._init_logging()
 
-        if self.enable_async:
+        if self.enable_multiprocess:
+            self._setup_multiprocess_logging()
+        elif self.enable_async:
             self._setup_async_logging()
 
         atexit.register(self.shutdown)
@@ -184,14 +195,18 @@ class MyLogger:
             class SimpleFormatter(logging.Formatter):
                 def format(self, record):
                     msg = super().format(record)
-                    if hasattr(record, 'extra_data') and record.extra_data:
-                        context_data = record.extra_data.get('context_data', {})
+                    # 统一处理 extra_data 字段
+                    extra_data = getattr(record, 'extra_data', None)
+                    if not extra_data and hasattr(record, 'extra'):
+                        extra_data = getattr(record, 'extra', None)
+                    if extra_data:
+                        context_data = extra_data.get('context_data', {})
                         if context_data:
                             msg += f" | Context: {context_data}"
-                        metrics = record.extra_data.get('性能指标', {})
+                        metrics = extra_data.get('性能指标', {})
                         if metrics:
                             msg += f" | Metrics: {metrics}"
-                        extra = {k: v for k, v in record.extra_data.items()
+                        extra = {k: v for k, v in extra_data.items()
                                  if k not in ('context_data', '性能指标')}
                         if extra:
                             msg += f" | Extra: {extra}"
@@ -254,6 +269,39 @@ class MyLogger:
         )
         self._queue_listener.start()
 
+    def _setup_multiprocess_logging(self):
+        """多进程安全日志：主进程写日志，子进程投递消息"""
+        self._mp_queue = multiprocessing.Queue(self.buffer_size)
+        if self._is_main_process:
+            # 主进程：启动写入进程
+            self._mp_writer_process = multiprocessing.Process(
+                target=self._mp_writer_worker,
+                args=(self._mp_queue,),
+                name=f"{self.name}_mp_writer",
+                daemon=True
+            )
+            self._mp_writer_process.start()
+        else:
+            # 子进程：不需要写入进程
+            pass
+
+    def _mp_writer_worker(self, log_queue):
+        """日志写入进程，消费队列并写日志"""
+        # 重新初始化logger和handlers（避免多进程fork后锁混乱）
+        self._init_logging()
+        while True:
+            try:
+                record = log_queue.get()
+                if record is None:
+                    break
+                level, message, extra = record
+                self._sync_log(level, message, extra)
+            except Exception as e:
+                try:
+                    self.logger.error(f"多进程日志写入异常: {e}", extra={'extra_data': {'mp_writer_error': str(e)}})
+                except:
+                    pass
+
     def _get_system_metrics(self) -> Dict[str, Any]:
         """获取系统资源使用指标"""
         if not self.enable_metrics:
@@ -337,7 +385,17 @@ class MyLogger:
 
     @log_error_handler(retry_times=1, fallback_level='warning')
     def _sync_log(self, level: str, message: str, extra: Optional[Dict] = None):
-        """同步日志记录（兼容异步，直接走logger）"""
+        if self.enable_multiprocess and not self._is_main_process:
+            # 子进程：只投递消息
+            try:
+                self._mp_queue.put((level, message, extra), block=False)
+            except Exception as e:
+                # 投递失败降级本地输出
+                logging.basicConfig()
+                fallback_logger = logging.getLogger(f"{getattr(self, 'name', 'mylogger')}_mp_fallback")
+                fallback_logger.warning(f"[多进程投递失败] {message} {e}")
+            return
+        # 主进程/普通模式：正常写日志
         if not hasattr(self.logger, level.lower()):
             return
         if not isinstance(message, str):
@@ -462,7 +520,7 @@ class MyLogger:
     def _format_traceback(self, exc_info):
         """格式化异常堆栈"""
         if exc_info is None:
-            return ""
+            return "No traceback available"
         return ''.join(traceback.format_exception(type(exc_info), exc_info, exc_info.__traceback__))
 
     def timeit(self, message: str = "Execution time"):
@@ -481,8 +539,7 @@ class MyLogger:
 
         def __exit__(self, exc_type, exc_val, exc_tb):
             elapsed = time.time() - self.start_time
-            self.logger.info(f"{self.message}: {elapsed:.3f}s",
-                             extra={'elapsed_seconds': elapsed})
+            self.logger.info(f"{self.message}: {elapsed:.3f}s", extra={'elapsed_seconds': f"{elapsed:.3f}"})
             return False
 
     def _start_flush_thread(self):
@@ -522,13 +579,27 @@ class MyLogger:
 
     def shutdown(self):
         """关闭日志记录器，确保所有日志被刷新"""
+        if self.enable_multiprocess and self._is_main_process and self._mp_writer_process:
+            try:
+                self._mp_queue.put(None)
+                self._mp_writer_process.join(timeout=5)
+            except:
+                pass
+        if self.enable_multiprocess and self._mp_queue is not None:
+            try:
+                self._mp_queue.close()
+                self._mp_queue.join_thread()
+            except:
+                pass
+            self._mp_queue = None
         if self.enable_async and self._queue_listener:
             self._queue_listener.stop()
-        for handler in self.logger.handlers:
+        for handler in self.logger.handlers[:]:
             try:
                 handler.close()
             except:
                 pass
+            self.logger.removeHandler(handler)
         for handler in getattr(self, '_handlers', []):
             try:
                 handler.close()

mdbq/other/error_handler.py

@@ -2,57 +2,222 @@ import traceback
 import sys
 from functools import wraps
 import inspect
+import asyncio
+from typing import Callable, Optional, Any, List
+import logging
+import json
 
 
-def log_on_exception(logger=None):
+class _ErrorHandlerHelper:
+    @staticmethod
+    def get_default_logger():
+        default_logger = logging.getLogger("mdbq.error_handler.default")
+        handler_exists = any(isinstance(h, logging.StreamHandler) for h in default_logger.handlers)
+        if not handler_exists:
+            handler = logging.StreamHandler()
+            handler.setLevel(logging.INFO)
+            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            default_logger.addHandler(handler)
+        default_logger.setLevel(logging.INFO)
+        default_logger.propagate = False
+        return default_logger
+
+    @staticmethod
+    def filter_fields(info: dict, log_fields):
+        if not log_fields:
+            return info
+        return {k: info[k] for k in log_fields if k in info}
+
+    @staticmethod
+    def build_error_info(func, e, args, kwargs, stack_summary):
+        tb = traceback.extract_tb(sys.exc_info()[2])
+        last_tb = tb[-1] if tb else None
+        return {
+            '函数': func.__name__,
+            '模块': func.__module__,
+            '类型': type(e).__name__,
+            '消息': str(e),
+            '签名': str(inspect.signature(func)),
+            'args': [str(arg) for arg in args] if args else [],
+            'kwargs': {k: str(v) for k, v in kwargs.items()} if kwargs else {},
+            '函数文件': func.__code__.co_filename,
+            '函数行号': func.__code__.co_firstlineno,
+            '异常行号': last_tb.lineno if last_tb else None,
+            '异常文件': last_tb.filename if last_tb else None,
+            '堆栈': stack_summary,
+        }
+
+    @staticmethod
+    def build_final_error_info(func, last_exception, max_retries):
+        tb = traceback.extract_tb(sys.exc_info()[2])
+        last_tb = tb[-1] if tb else None
+        return {
+            '函数': func.__name__,
+            '最终错误类型': type(last_exception).__name__,
+            '最终错误消息': str(last_exception),
+            '总尝试次数': max_retries,
+            '堆栈跟踪': traceback.format_exc(),
+            '异常行号': last_tb.lineno if last_tb else None,
+            '异常文件': last_tb.filename if last_tb else None,
+        }
+
+    @staticmethod
+    def get_stack_summary():
+        stack_lines = traceback.format_exc().splitlines(keepends=True)
+        if len(stack_lines) > 40:
+            return ''.join(stack_lines[:20]) + '\n...\n' + ''.join(stack_lines[-20:])
+        else:
+            return ''.join(stack_lines)
+
+
+def log_on_exception(
+    logger=None,
+    *,
+    on_exception: Optional[Callable[[dict], None]] = None,
+    default_return: Any = None,
+    log_fields: Optional[List[str]] = None,
+):
+    """
+    :param logger: 日志对象，需实现 debug/info/warning/error/critical 方法
+    :param on_exception: 异常回调，参数为 error_info 字典
+    :param default_return: 异常时返回的默认值
+    :param log_fields: 只记录 error_info 的部分字段
+    """
+    if logger is not None:
+        for method in ("debug", "info", "warning", "error", "critical"):
+            if not hasattr(logger, method):
+                raise TypeError(
+                    f"logger 参数必须有 {method} 方法，当前类型为: {type(logger)}"
+                )
     def decorator(func):
+        is_async = asyncio.iscoroutinefunction(func)
         @wraps(func)
-        def wrapper(*args, **kwargs):
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                stack_summary = _ErrorHandlerHelper.get_stack_summary()
+                error_info = _ErrorHandlerHelper.build_error_info(func, e, args, kwargs, stack_summary)
+                error_info = _ErrorHandlerHelper.filter_fields(error_info, log_fields)
+                use_logger = logger if logger is not None else _ErrorHandlerHelper.get_default_logger()
+                if use_logger:
+                    if logger is None:
+                        use_logger.error(f"执行失败\n详细信息: {json.dumps(error_info, ensure_ascii=False, indent=2)}")
+                    else:
+                        use_logger.error("执行失败", {'details': error_info})
+                if on_exception:
+                    try:
+                        on_exception(error_info)
+                    except Exception:
+                        pass
+                return default_return
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
             try:
                 return func(*args, **kwargs)
             except Exception as e:
-                stack_lines = traceback.format_exc().splitlines(keepends=True)
-                if len(stack_lines) > 40:
-                    stack_summary = ''.join(stack_lines[:20]) + '\n...\n' + ''.join(stack_lines[-20:])
-                else:
-                    stack_summary = ''.join(stack_lines)
-                error_info = {
-                    '函数': func.__name__,
-                    '模块': func.__module__,
-                    '类型': type(e).__name__,
-                    '消息': str(e),
-                    '签名': str(inspect.signature(func)),
-                    'args': [str(arg) for arg in args] if args else [],
-                    'kwargs': {k: str(v) for k, v in kwargs.items()} if kwargs else {},
-                    '函数文件': func.__code__.co_filename,
-                    '函数行号': func.__code__.co_firstlineno,
-                    '异常行号': traceback.extract_tb(sys.exc_info()[2])[-1].lineno if sys.exc_info()[2] else None,
-                    '异常文件': traceback.extract_tb(sys.exc_info()[2])[-1].filename if sys.exc_info()[2] else None,
-                    '堆栈': stack_summary,
-                }
-                if logger:
-                    logger.error(f"执行失败", {'details': error_info})
-
-                # print(error_info)
-                # raise  # 重新抛出异常
-                
-                return None  # 或者返回其他默认值
-        
-        return wrapper
+                stack_summary = _ErrorHandlerHelper.get_stack_summary()
+                error_info = _ErrorHandlerHelper.build_error_info(func, e, args, kwargs, stack_summary)
+                error_info = _ErrorHandlerHelper.filter_fields(error_info, log_fields)
+                use_logger = logger if logger is not None else _ErrorHandlerHelper.get_default_logger()
+                if use_logger:
+                    if logger is None:
+                        use_logger.error(f"执行失败\n详细信息: {json.dumps(error_info, ensure_ascii=False, indent=2)}")
+                    else:
+                        use_logger.error("执行失败", {'details': error_info})
+                if on_exception:
+                    try:
+                        on_exception(error_info)
+                    except Exception:
+                        pass
+                return default_return
+        return async_wrapper if is_async else sync_wrapper
     return decorator
 
 
-def log_on_exception_with_retry(max_retries=3, delay=1, logger=None):
+def log_on_exception_with_retry(
+    max_retries=3,
+    delay=1,
+    logger=None,
+    *,
+    on_exception: Optional[Callable[[dict], None]] = None,
+    default_return: Any = None,
+    log_fields: Optional[List[str]] = None,
+):
+    """
+    :param logger: 日志对象，需实现 debug/info/warning/error/critical 方法
+    :param on_exception: 异常回调，参数为 error_info 字典
+    :param default_return: 异常时返回的默认值
+    :param log_fields: 只记录 error_info 的部分字段
+    """
+    if logger is not None:
+        for method in ("debug", "info", "warning", "error", "critical"):
+            if not hasattr(logger, method):
+                raise TypeError(
+                    f"logger 参数必须有 {method} 方法，当前类型为: {type(logger)}"
+                )
     def decorator(func):
+        is_async = asyncio.iscoroutinefunction(func)
         @wraps(func)
-        def wrapper(*args, **kwargs):
+        async def async_wrapper(*args, **kwargs):
             last_exception = None
-            
+            import time
+            for attempt in range(max_retries):
+                try:
+                    return await func(*args, **kwargs)
+                except Exception as e:
+                    last_exception = e
+                    error_info = {
+                        '函数': func.__name__,
+                        '重试': attempt + 1,
+                        '最大重试': max_retries,
+                        '类型': type(e).__name__,
+                        '消息': str(e),
+                    }
+                    error_info = _ErrorHandlerHelper.filter_fields(error_info, log_fields)
+                    use_logger = logger if logger is not None else _ErrorHandlerHelper.get_default_logger()
+                    if use_logger:
+                        if logger is None:
+                            use_logger.warning(f"函数 {func.__name__} 第 {attempt + 1} 次尝试失败\n详细信息: {json.dumps(error_info, ensure_ascii=False, indent=2)}")
+                        else:
+                            use_logger.warning(f"函数 {func.__name__} 第 {attempt + 1} 次尝试失败", {'details': error_info})
+                    if on_exception:
+                        try:
+                            on_exception(error_info)
+                        except Exception:
+                            pass
+                    if attempt < max_retries - 1:
+                        await asyncio.sleep(delay)
+                        if use_logger:
+                            use_logger.info(f"第 {attempt + 1} 次尝试失败，{delay}秒后重试...")
+                    else:
+                        if use_logger:
+                            if logger is None:
+                                use_logger.error(f"函数 {func.__name__} 在 {max_retries} 次尝试后仍然失败\n详细信息: {json.dumps(error_info, ensure_ascii=False, indent=2)}")
+                            else:
+                                use_logger.error(f"函数 {func.__name__} 在 {max_retries} 次尝试后仍然失败", {'details': error_info})
+            final_error_info = _ErrorHandlerHelper.build_final_error_info(func, last_exception, max_retries)
+            final_error_info = _ErrorHandlerHelper.filter_fields(final_error_info, log_fields)
+            if use_logger:
+                if logger is None:
+                    use_logger.error(f"最终执行失败\n详细信息: {json.dumps(final_error_info, ensure_ascii=False, indent=2)}")
+                else:
+                    use_logger.error("最终执行失败", {'details': final_error_info})
+            if on_exception:
+                try:
+                    on_exception(final_error_info)
+                except Exception:
+                    pass
+            return default_return
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            last_exception = None
+            import time
             for attempt in range(max_retries):
                 try:
                     return func(*args, **kwargs)
                 except Exception as e:
-                    import time
                     last_exception = e
                     error_info = {
                         '函数': func.__name__,
@@ -61,59 +226,50 @@ def log_on_exception_with_retry(max_retries=3, delay=1, logger=None):
                         '类型': type(e).__name__,
                         '消息': str(e),
                     }
-                    
-                    if logger:
-                        logger.warning(f"函数 {func.__name__} 第 {attempt + 1} 次尝试失败", {'details': error_info})
-                    
+                    error_info = _ErrorHandlerHelper.filter_fields(error_info, log_fields)
+                    use_logger = logger if logger is not None else _ErrorHandlerHelper.get_default_logger()
+                    if use_logger:
+                        if logger is None:
+                            use_logger.warning(f"函数 {func.__name__} 第 {attempt + 1} 次尝试失败\n详细信息: {json.dumps(error_info, ensure_ascii=False, indent=2)}")
+                        else:
+                            use_logger.warning(f"函数 {func.__name__} 第 {attempt + 1} 次尝试失败", {'details': error_info})
+                    if on_exception:
+                        try:
+                            on_exception(error_info)
+                        except Exception:
+                            pass
                     if attempt < max_retries - 1:
                         time.sleep(delay)
-                        if logger:
-                            logger.info(f"⏳ 第 {attempt + 1} 次尝试失败，{delay}秒后重试...")
+                        if use_logger:
+                            use_logger.info(f"第 {attempt + 1} 次尝试失败，{delay}秒后重试...")
                     else:
-                        if logger:
-                            logger.error(f"❌ 函数 {func.__name__} 在 {max_retries} 次尝试后仍然失败")
-            
-            final_error_info = {
-                '函数': func.__name__,
-                '最终错误类型': type(last_exception).__name__,
-                '最终错误消息': str(last_exception),
-                '总尝试次数': max_retries,
-                '堆栈跟踪': traceback.format_exc(),
-            }
-            
-            if logger:
-                logger.error(f"函数 {func.__name__} 最终执行失败", {'details': final_error_info})
-            
-            return None
-            
-        return wrapper
+                        if use_logger:
+                            if logger is None:
+                                use_logger.error(f"函数 {func.__name__} 在 {max_retries} 次尝试后仍然失败\n详细信息: {json.dumps(error_info, ensure_ascii=False, indent=2)}")
+                            else:
+                                use_logger.error(f"函数 {func.__name__} 在 {max_retries} 次尝试后仍然失败", {'details': error_info})
+            final_error_info = _ErrorHandlerHelper.build_final_error_info(func, last_exception, max_retries)
+            final_error_info = _ErrorHandlerHelper.filter_fields(final_error_info, log_fields)
+            if use_logger:
+                if logger is None:
+                    use_logger.error(f"最终执行失败\n详细信息: {json.dumps(final_error_info, ensure_ascii=False, indent=2)}")
+                else:
+                    use_logger.error("最终执行失败", {'details': final_error_info})
+            if on_exception:
+                try:
+                    on_exception(final_error_info)
+                except Exception:
+                    pass
+            return default_return
+        return async_wrapper if is_async else sync_wrapper
     return decorator
 
 
 if __name__ == "__main__":
-    import logging
-    test_logger = logging.getLogger(__name__)
-    test_logger.setLevel(logging.INFO)
-    
-    @log_on_exception(logger=test_logger)
+    @log_on_exception(logger=None)
     def divide_numbers(a, b):
         """测试函数：除法运算"""
         return a / b
-    
-    @log_on_exception_with_retry(max_retries=2, delay=0.5, logger=test_logger)
-    def fetch_data(url):
-        import random
-        """测试函数：模拟数据获取"""
-        if random.random() < 0.7:  # 70% 概率失败
-            raise ConnectionError("网络连接失败")
-        return "数据获取成功"
-    
-    # 测试基本错误处理
-    print("=== 测试基本错误处理 ===")
+
     result1 = divide_numbers(10, 0)
-    result2 = divide_numbers(10, 2)
-    print(f"结果: {result2}")
-    
-    print("\n=== 测试重试机制 ===")
-    result3 = fetch_data("http://example.com")
-    print(f"最终结果: {result3}") 
+   

{mdbq-4.0.35.dist-info → mdbq-4.0.37.dist-info}/METADATA

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

{mdbq-4.0.35.dist-info → mdbq-4.0.37.dist-info}/RECORD

@@ -1,9 +1,9 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=B_ZDOEojo89VxQM2P_TRRgrJ65zx2UcvpOaQkIohFPI,18
+mdbq/__version__.py,sha256=1IAdkcLTP6Byg2amV6TPLMYX4EWf_WqqMKyIUbVRCfc,18
 mdbq/aggregation/__init__.py,sha256=EeDqX2Aml6SPx8363J-v1lz0EcZtgwIBYyCJV6CcEDU,40
 mdbq/aggregation/query_data.py,sha256=WtTFMN78jn43Y-nBTPAXhAK56w3wDuv_cj4YtzzGbZk,169797
 mdbq/log/__init__.py,sha256=Mpbrav0s0ifLL7lVDAuePEi1hJKiSHhxcv1byBKDl5E,15
-mdbq/log/mylogger.py,sha256=uC_KHsoCkxKKMVZTKYhe06Y5g6nUYuQYSEmK7YHLtlc,21754
+mdbq/log/mylogger.py,sha256=iDhWkTY6I9T3IJuERWqiXKq1sNf0VuraSEq33ZxLqdw,24930
 mdbq/myconf/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/myconf/myconf.py,sha256=rHvQCnQRKhQ49AZBke-Z4v28hyOLmHt4MylIuB0H6yA,33516
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
@@ -14,7 +14,7 @@ mdbq/mysql/unique_.py,sha256=MaztT-WIyEQUs-OOYY4pFulgHVcXR1BfCy3QUz0XM_U,21127
 mdbq/mysql/uploader.py,sha256=SVlrLxoYBEpTu_I771wAehJQVFWOCqXp-lNk2JNYFOE,81881
 mdbq/other/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/other/download_sku_picture.py,sha256=X66sVdvVgzoNzmgVJyPtd7bjEvctEKtLPblEPF65EWc,46940
-mdbq/other/error_handler.py,sha256=ZeuvQM4qRYGA1a9gCijwYZ-NbA4coijMkbC2tqTNBU0,4590
+mdbq/other/error_handler.py,sha256=4p5haAXSY-P78stp4Xwo_MwAngWYqyKj5ogWIuYXMeY,12631
 mdbq/other/otk.py,sha256=iclBIFbQbhlqzUbcMMoePXBpcP1eZ06ZtjnhcA_EbmE,7241
 mdbq/other/pov_city.py,sha256=AEOmCOzOwyjHi9LLZWPKi6DUuSC-_M163664I52u9qw,21050
 mdbq/other/ua_sj.py,sha256=JuVYzc_5QZ9s_oQSrTHVKkQv4S_7-CWx4oIKOARn_9U,22178
@@ -25,7 +25,7 @@ mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
 mdbq/redis/getredis.py,sha256=vpBuNc22uj9Vr-_Dh25_wpwWM1e-072EAAIBdB_IpL0,23494
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
 mdbq/spider/aikucun.py,sha256=XptHjGzbout9IYzWAOQUpMMV5qEgLTU8pL1ZGt8oNEA,21868
-mdbq-4.0.35.dist-info/METADATA,sha256=okq1WCntJO--DHv5eIqIAwDggX6rHeFRfIR2xZQqnGs,364
-mdbq-4.0.35.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mdbq-4.0.35.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-4.0.35.dist-info/RECORD,,
+mdbq-4.0.37.dist-info/METADATA,sha256=PUJcSDuxE3fJkdK9-9ovfVDiCmFnwpd5HNuxblXBJC0,364
+mdbq-4.0.37.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mdbq-4.0.37.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-4.0.37.dist-info/RECORD,,