mdbq 4.1.2__py3-none-any.whl → 4.1.3__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '4.1.2'
+VERSION = '4.1.3'

mdbq/myconf/myconf.py

@@ -1,22 +1,22 @@
 import re
 from typing import Dict, Any, Optional, Union, List, Tuple, Type, TypeVar
 from pathlib import Path
-from mdbq.log import mylogger
+# from mdbq.log import mylogger
 from dataclasses import dataclass, field
 from enum import Enum
 import time
 
-logger = mylogger.MyLogger(
-    logging_mode='both',
-    log_level='info',
-    log_format='json',
-    max_log_size=50,
-    backup_count=5,
-    enable_async=False,  # 是否启用异步日志
-    sample_rate=1,  # 采样DEBUG/INFO日志
-    sensitive_fields=[],  #  敏感字段过滤
-    enable_metrics=False,  # 是否启用性能指标
-)
+# logger = mylogger.MyLogger(
+#     logging_mode='both',
+#     log_level='info',
+#     log_format='json',
+#     max_log_size=50,
+#     backup_count=5,
+#     enable_async=False,  # 是否启用异步日志
+#     sample_rate=1,  # 采样DEBUG/INFO日志
+#     sensitive_fields=[],  #  敏感字段过滤
+#     enable_metrics=False,  # 是否启用性能指标
+# )
 
 T = TypeVar('T')  # 类型变量
 
@@ -151,12 +151,10 @@ class ConfigParser:
     def open(self, file_path: Union[str, Path]) -> 'ConfigParser':
         """打开配置文件"""
         file_path = Path(file_path)
-        logger.debug(f'尝试打开配置文件: {file_path}')
         if not file_path.exists() and not self.options.auto_create:
-            logger.error(f'配置文件不存在: {file_path}')
+            # logger.error(f'配置文件不存在: {file_path}')
             raise ConfigException.file_not_found(file_path)
         self._current_file = file_path
-        logger.debug(f'配置文件已打开: {file_path}')
         return self
 
     def _ensure_file_open(self) -> None:
@@ -211,7 +209,6 @@ class ConfigParser:
     
     def _update_cache(self, file_path: str, config: Dict[str, Any]) -> None:
         """更新配置缓存"""
-        logger.debug(f'更新配置缓存: {file_path}')
         self._config_cache[file_path] = config
         self._cache_timestamps[file_path] = time.time()
     
@@ -236,13 +233,11 @@ class ConfigParser:
     def _clear_cache(self, file_path: Optional[str] = None) -> None:
         """清除配置缓存"""
         if file_path:
-            logger.debug(f'清除指定文件的缓存: {file_path}')
             self._config_cache.pop(file_path, None)
             self._cache_timestamps.pop(file_path, None)
             self._comments_cache.pop(file_path, None)
             self._section_map.pop(file_path, None)
         else:
-            logger.debug('清除所有配置缓存')
             self._config_cache.clear()
             self._cache_timestamps.clear()
             self._comments_cache.clear()
@@ -323,12 +318,11 @@ class ConfigParser:
                  default: Any = None, value_type: Optional[Type[T]] = None,
                  file_path: Optional[Union[str, Path]] = None) -> T:
         """获取指定配置项的值"""
-        logger.debug(f'获取配置项: section={section}, key={key}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
         if not self._validate_key(key):
-            logger.error(f'无效的键名: {key}')
+            # logger.error(f'无效的键名: {key}')
             raise ConfigException.invalid_key_error(key, file_path, section)
         config = self.read(file_path)
         section = section or self.options.default_section
@@ -336,15 +330,15 @@ class ConfigParser:
         original_section = self._get_original_section(str(file_path), normalized_section)
         if original_section is None:
             if default is not None:
-                logger.warning(f'节不存在，返回默认值: section={section}, key={key}, default={default}')
+                # logger.warning(f'节不存在，返回默认值: section={section}, key={key}, default={default}')
                 return default
-            logger.error(f'配置节不存在: {section}')
+            # logger.error(f'配置节不存在: {section}')
             raise ConfigException.section_not_found(file_path, section)
         if key not in config[original_section]:
             if default is not None:
-                logger.warning(f'键不存在，返回默认值: section={section}, key={key}, default={default}')
+                # logger.warning(f'键不存在，返回默认值: section={section}, key={key}, default={default}')
                 return default
-            logger.error(f'配置键不存在: {key}')
+            # logger.error(f'配置键不存在: {key}')
             raise ConfigException.key_not_found(file_path, original_section, key)
         value = config[original_section][key]
         if value_type is not None:
@@ -356,7 +350,6 @@ class ConfigParser:
                   value_types: Optional[Dict[str, Type]] = None,
                   file_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
         """批量获取多个配置项的值"""
-        logger.debug(f'批量获取配置项: section={section}, keys={keys}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -375,7 +368,7 @@ class ConfigParser:
                 )
                 result[key] = value
             except ConfigException as e:
-                logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
+                # logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
                 if key in defaults:
                     result[key] = defaults[key]
                 else:
@@ -388,7 +381,6 @@ class ConfigParser:
                           value_types: Optional[Dict[str, Type]] = None,
                           file_path: Optional[Union[str, Path]] = None) -> Tuple[Any, ...]:
         """获取指定节点下多个键的值元组"""
-        logger.debug(f'获取节下多个键的值: section={section}, keys={keys}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -407,7 +399,7 @@ class ConfigParser:
                 )
                 result.append(value)
             except ConfigException as e:
-                logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
+                # logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
                 if key in defaults:
                     result.append(defaults[key])
                 else:
@@ -419,7 +411,6 @@ class ConfigParser:
                  value_type: Optional[Type] = None,
                  file_path: Optional[Union[str, Path]] = None) -> None:
         """设置指定配置项的值"""
-        logger.debug(f'准备写入配置项: section={section}, key={key}, value={value}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -427,7 +418,7 @@ class ConfigParser:
             file_path = Path(file_path)
             
         if not self._validate_key(key):
-            logger.error(f'无效的键名: {key}')
+            # logger.error(f'无效的键名: {key}')
             raise ConfigException.invalid_key_error(key, file_path, section)
             
         section = section or self.options.default_section
@@ -452,7 +443,7 @@ class ConfigParser:
                     else:
                         value = value_type(value)
                 except (ValueError, TypeError) as e:
-                    logger.error(f'类型转换失败: value={value}, type={value_type}, error={e}')
+                    # logger.error(f'类型转换失败: value={value}, type={value_type}, error={e}')
                     raise ConfigException.conversion_error(value, value_type, file_path, section=section, key=key)
                     
             if isinstance(value, bool):
@@ -509,21 +500,20 @@ class ConfigParser:
                     file.write(f'{key}={value}\n')
                     
             self._clear_cache(str(file_path))
-            logger.info(f'配置项写入成功: section={section}, key={key}, value={value}, file_path={file_path}')
+            # logger.info(f'配置项写入成功: section={section}, key={key}, value={value}, file_path={file_path}')
             
         except Exception as e:
-            logger.error(f'写入配置项失败: section={section}, key={key}, value={value}, file_path={file_path}, error={e}')
+            # logger.error(f'写入配置项失败: section={section}, key={key}, value={value}, file_path={file_path}, error={e}')
             raise ConfigException.write_error(file_path, e)
 
     def set_values(self, section: Optional[str] = None, values: Dict[str, Any] = None,
                   value_types: Optional[Dict[str, Type]] = None,
                   file_path: Optional[Union[str, Path]] = None) -> None:
         """批量设置多个配置项的值"""
-        logger.debug(f'批量写入配置项: section={section}, keys={list(values.keys())}, file_path={file_path}')
         for key, value in values.items():
             value_type = value_types.get(key) if value_types else None
             self.set_value(section, key, value, value_type, file_path)
-        logger.info(f'批量写入配置项完成: section={section}, file_path={file_path}')
+        # logger.info(f'批量写入配置项完成: section={section}, file_path={file_path}')
 
     def validate_config(self, section: Optional[str] = None, schema: Dict[str, Type] = None,
                        file_path: Optional[Union[str, Path]] = None) -> bool:
@@ -560,17 +550,15 @@ class ConfigParser:
         else:
             file_path = Path(file_path)
         
-        logger.debug(f'开始读取配置文件: {file_path}')
         cached_config = self._get_cached_config(str(file_path))
         if cached_config is not None:
-            logger.debug(f'命中配置缓存: {file_path}')
             return cached_config
         
         if not file_path.exists():
             if not self.options.auto_create:
-                logger.error(f'配置文件不存在: {file_path}')
+                # logger.error(f'配置文件不存在: {file_path}')
                 raise ConfigException.file_not_found(file_path)
-            logger.info(f'配置文件不存在，将创建: {file_path}')
+            # logger.info(f'配置文件不存在，将创建: {file_path}')
             file_path.parent.mkdir(parents=True, exist_ok=True)
             file_path.touch()
             return {}
@@ -592,7 +580,7 @@ class ConfigParser:
                     if stripped_line.startswith('[') and stripped_line.endswith(']'):
                         current_section = stripped_line[1:-1]
                         if not self._validate_key(current_section):
-                            logger.error(f'无效的节名: {current_section}')
+                            # logger.error(f'无效的节名: {current_section}')
                             raise ConfigException.invalid_section_error(current_section, file_path)
                         self._update_section_map(str(file_path), current_section)
                         if current_section not in config:
@@ -606,7 +594,7 @@ class ConfigParser:
                     if key_value:
                         key, value = key_value
                         if not self._validate_key(key):
-                            logger.error(f'无效的键名: {key}')
+                            # logger.error(f'无效的键名: {key}')
                             raise ConfigException.invalid_key_error(key, file_path, current_section)
                         value, comment = self._extract_comment(value)
                         
@@ -621,11 +609,10 @@ class ConfigParser:
                             self._comments_cache.setdefault(str(file_path), {}).setdefault(current_section, []).append(comment)
                 
                 self._update_cache(str(file_path), config)
-                logger.debug(f'配置文件读取成功: {file_path}')
                 return config
                 
         except Exception as e:
-            logger.error(f'读取配置文件失败: {file_path}, error={e}')
+            # logger.error(f'读取配置文件失败: {file_path}, error={e}')
             raise ConfigException.read_error(file_path, e)
 
 

mdbq/mysql/s_query.py

@@ -16,7 +16,7 @@ from functools import wraps
 warnings.filterwarnings('ignore')
 logger = mylogger.MyLogger(
     logging_mode='file',
-    log_level='info',
+    log_level='error',
     log_format='json',
     max_log_size=50,
     backup_count=5,

mdbq/redis/getredis.py

@@ -5,21 +5,21 @@ import numpy as np
 import json
 import datetime
 import threading
-from mdbq.log import mylogger
+# from mdbq.log import mylogger
 from decimal import Decimal
 import orjson
 
-logger = mylogger.MyLogger(
-    logging_mode='file',
-    log_level='info',
-    log_format='json',
-    max_log_size=50,
-    backup_count=5,
-    enable_async=False,  # 是否启用异步日志
-    sample_rate=1,  # 采样DEBUG/INFO日志
-    sensitive_fields=[],  #  敏感字段过滤
-    enable_metrics=False,  # 是否启用性能指标
-)
+# logger = mylogger.MyLogger(
+#     logging_mode='file',
+#     log_level='info',
+#     log_format='json',
+#     max_log_size=50,
+#     backup_count=5,
+#     enable_async=False,  # 是否启用异步日志
+#     sample_rate=1,  # 采样DEBUG/INFO日志
+#     sensitive_fields=[],  #  敏感字段过滤
+#     enable_metrics=False,  # 是否启用性能指标
+# )
 
 
 class RedisData(object):
@@ -61,7 +61,8 @@ class RedisData(object):
 
         combined_df = pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
         if combined_df.empty:
-            logger.info(f"警告: {db_name}.{table_name} 未读取到数据")
+            # logger.info(f"警告: {db_name}.{table_name} 未读取到数据")
+            pass
         else:
             combined_df = self._convert_date_columns(combined_df)
         return combined_df
@@ -86,7 +87,7 @@ class RedisData(object):
             ttl = self.redis_engine.ttl(cache_key)
             cache_data = self._fetch_redis_data(cache_key)
         except Exception as e:
-            logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
+            # logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
 
         # 缓存失效处理逻辑
@@ -134,11 +135,11 @@ class RedisData(object):
             self.redis_engine.set(cache_key, serialized_data)
             self.redis_engine.expire(cache_key, self.cache_ttl)
 
-            logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
+            # logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
             return combined_data
 
         except Exception as e:
-            logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
+            # logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
             return pd.DataFrame()
 
     # Helper Methods ------------------------------------------------
@@ -160,7 +161,7 @@ class RedisData(object):
                 projection={}
             )
         except Exception as e:
-            logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
+            # logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
             return pd.DataFrame()
 
     def _fetch_redis_data(self, cache_key: str) -> pd.DataFrame:
@@ -173,7 +174,7 @@ class RedisData(object):
             df = pd.DataFrame(json.loads(data.decode("utf-8")))
             return self._convert_date_columns(df)
         except Exception as e:
-            logger.error(f"Redis 数据解析失败 {cache_key}: {e}")
+            # logger.error(f"Redis 数据解析失败 {cache_key}: {e}")
             return pd.DataFrame()
 
     def _convert_date_columns(self, df: pd.DataFrame) -> pd.DataFrame:
@@ -278,7 +279,8 @@ class RedisDataHash(object):
 
         combined_df = pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
         if combined_df.empty:
-            logger.warn(f"warning: {db_name}.{table_name} 未读取到数据")
+            # logger.warn(f"warning: {db_name}.{table_name} 未读取到数据")
+            pass
         else:
             combined_df = self._convert_date_columns(combined_df)
         return combined_df
@@ -293,7 +295,7 @@ class RedisDataHash(object):
             projection={}
     ) -> pd.DataFrame:
         if not self.redis_engine.ping():
-            logger.error(f"Redis ping异常，直接访问 MySQL")
+            # logger.error(f"Redis ping异常，直接访问 MySQL")
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
         start_dt = pd.to_datetime(start_date).floor('D')
         end_dt = pd.to_datetime(end_date).floor('D')
@@ -335,7 +337,7 @@ class RedisDataHash(object):
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
         except Exception as e:
-            logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
+            # logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
     def set_redis(
@@ -385,9 +387,10 @@ class RedisDataHash(object):
                         serialized_data = self._serialize_data(group)
                         self.redis_engine.hset(cache_key, month_str, serialized_data)
                     self.redis_engine.expire(cache_key, self.cache_ttl + random.randint(0, 1800))
-                logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
+                # logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
         except Exception as e:
-            logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
+            # logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
+            pass
 
     def _fetch_table_data(
             self,
@@ -406,7 +409,7 @@ class RedisDataHash(object):
                 projection=projection
             )
         except Exception as e:
-            logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
+            # logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
             return pd.DataFrame()
 
     def _fetch_redis_data(self, cache_key: str, months: list = None) -> pd.DataFrame:
@@ -441,7 +444,8 @@ class RedisDataHash(object):
                             df = self._convert_date_columns(df)
                             dfs.append(df)
                         except Exception as e:
-                            logger.error(f"月份数据解析失败 {field}: {e}")
+                            # logger.error(f"月份数据解析失败 {field}: {e}")
+                            pass
 
             # 处理分片数据（优化后的批处理逻辑）
             cursor, shard_data = results[result_index]
@@ -459,7 +463,8 @@ class RedisDataHash(object):
                             df = pd.DataFrame(orjson.loads(value))
                             dfs.append(self._convert_date_columns(df))
                         except Exception as e:
-                            logger.error(f"分片数据解析失败: {e}")
+                            # logger.error(f"分片数据解析失败: {e}")
+                            pass
 
                 # 继续获取后续分片
                 if cursor == 0:
@@ -475,7 +480,7 @@ class RedisDataHash(object):
             return pd.DataFrame()
 
         except Exception as e:
-            logger.error(f"Redis 数据获取失败 {cache_key}: {e}")
+            # logger.error(f"Redis 数据获取失败 {cache_key}: {e}")
             return pd.DataFrame()
 
     def _convert_date_columns(self, df: pd.DataFrame) -> pd.DataFrame:
@@ -562,7 +567,7 @@ class RedisDataHash(object):
         try:
             records = temp_df.to_dict(orient='records')
         except Exception as e:
-            logger.error(f"DataFrame转字典失败: {str(e)}")
+            # logger.error(f"DataFrame转字典失败: {str(e)}")
             records = []
 
         # 序列化配置 --------------------------------------------------------

mdbq/redis/redis_cache.py

@@ -26,21 +26,21 @@ from typing import Optional, Dict, Any, List, Callable
 from threading import Event
 from collections import defaultdict, deque
 import redis
-from mdbq.log import mylogger
+# from mdbq.log import mylogger
 
 
-# 全局日志器
-logger = mylogger.MyLogger(
-    logging_mode='file',
-    log_level='info',
-    log_format='json',
-    max_log_size=50,
-    backup_count=5,
-    enable_async=False,
-    sample_rate=1,
-    sensitive_fields=[],
-    enable_metrics=False,
-)
+# # 全局日志器
+# logger = mylogger.MyLogger(
+#     logging_mode='file',
+#     log_level='info',
+#     log_format='json',
+#     max_log_size=50,
+#     backup_count=5,
+#     enable_async=False,
+#     sample_rate=1,
+#     sensitive_fields=[],
+#     enable_metrics=False,
+# )
 
 
 class CacheStatsCollector:
@@ -105,31 +105,28 @@ class CacheStatsCollector:
                     self._check_and_submit()
                 except Exception as submit_error:
                     # 统计提交失败不应影响统计记录
-                    logger.error("统计数据提交检查失败，但统计记录继续", {
-                        'instance_name': self.instance_name,
-                        'process_id': self.process_id,
-                        'operation': operation,
-                        'submit_error': str(submit_error)
-                    })
+                    # logger.error("统计数据提交检查失败，但统计记录继续", {
+                    #     'instance_name': self.instance_name,
+                    #     'process_id': self.process_id,
+                    #     'operation': operation,
+                    #     'submit_error': str(submit_error)
+                    # })
+                    pass
         except Exception as e:
             # 统计记录失败不应影响缓存操作
-            logger.error("统计记录失败，但缓存操作继续", {
-                'instance_name': self.instance_name,
-                'process_id': self.process_id,
-                'operation': operation,
-                'error': str(e)
-            })
+            # logger.error("统计记录失败，但缓存操作继续", {
+            #     'instance_name': self.instance_name,
+            #     'process_id': self.process_id,
+            #     'operation': operation,
+            #     'error': str(e)
+            # })
+            pass
     
     def _start_background_timer(self):
         """启动后台定时提交线程"""
         if self._timer is not None:
             return  # 已经启动
         
-        logger.debug("启动后台定时提交", {
-            'instance_name': self.instance_name,
-            'submit_interval': self.submit_interval
-        })
-        
         self._timer = threading.Timer(self.submit_interval, self._background_submit)
         self._timer.daemon = True  # 设置为守护线程
         self._timer.start()
@@ -147,22 +144,22 @@ class CacheStatsCollector:
             
         except Exception as e:
             self._error_count += 1
-            logger.error("后台定时提交失败", {
-                'instance_name': self.instance_name,
-                'process_id': self.process_id,
-                'error': str(e),
-                'error_type': type(e).__name__,
-                'error_count': self._error_count,
-                'max_errors': self._max_errors
-            })
+            # logger.error("后台定时提交失败", {
+            #     'instance_name': self.instance_name,
+            #     'process_id': self.process_id,
+            #     'error': str(e),
+            #     'error_type': type(e).__name__,
+            #     'error_count': self._error_count,
+            #     'max_errors': self._max_errors
+            # })
             
             # 如果连续错误次数过多，停止定时器
             if self._error_count >= self._max_errors:
-                logger.error("后台定时器连续错误过多，停止定时提交", {
-                    'instance_name': self.instance_name,
-                    'process_id': self.process_id,
-                    'error_count': self._error_count
-                })
+                # logger.error("后台定时器连续错误过多，停止定时提交", {
+                #     'instance_name': self.instance_name,
+                #     'process_id': self.process_id,
+                #     'error_count': self._error_count
+                # })
                 return  # 不再安排下一次定时器
                 
         finally:
@@ -198,27 +195,22 @@ class CacheStatsCollector:
                     self.last_submit_time = current_time
                     self.last_operation_count = self.stats['total_operations']
                     
-                    logger.info("统计数据提交成功", {
-                        'instance_name': self.instance_name,
-                        'total_operations': self.stats['total_operations'],
-                        'new_operations': new_operations,
-                        'trigger_type': 'background_timer' if force_check else 'operation_triggered'
-                    })
+                    # logger.info("统计数据提交成功", {
+                    #     'instance_name': self.instance_name,
+                    #     'total_operations': self.stats['total_operations'],
+                    #     'new_operations': new_operations,
+                    #     'trigger_type': 'background_timer' if force_check else 'operation_triggered'
+                    # })
                 except Exception as e:
-                    logger.error("统计数据提交失败", {
-                        'instance_name': self.instance_name,
-                        'error': str(e),
-                        'trigger_type': 'background_timer' if force_check else 'operation_triggered'
-                    })
+                    # logger.error("统计数据提交失败", {
+                    #     'instance_name': self.instance_name,
+                    #     'error': str(e),
+                    #     'trigger_type': 'background_timer' if force_check else 'operation_triggered'
+                    # })
+                    pass
             else:
                 # 无新操作，跳过提交但更新时间
                 self.last_submit_time = current_time
-                if force_check:  # 仅在后台定时器触发时记录
-                    logger.debug("后台检查：无新操作，跳过提交", {
-                        'instance_name': self.instance_name,
-                        'total_operations': self.stats['total_operations']
-                    })
-    
     def _submit_to_mysql(self):
         """同步提交统计数据到MySQL"""
         if not self.mysql_pool:
@@ -270,12 +262,12 @@ class CacheStatsCollector:
             connection.close()
             
         except Exception as e:
-            logger.error("MySQL提交失败", {
-                'instance_name': self.instance_name,
-                'database': db_name,
-                'table': table_name,
-                'error': str(e)
-            })
+            # logger.error("MySQL提交失败", {
+            #     'instance_name': self.instance_name,
+            #     'database': db_name,
+            #     'table': table_name,
+            #     'error': str(e)
+            # })
             raise
     
     def get_stats(self) -> Dict[str, Any]:
@@ -307,9 +299,9 @@ class CacheStatsCollector:
     
     def shutdown(self):
         """关闭统计收集器，停止后台定时器"""
-        logger.info("关闭统计收集器", {
-            'instance_name': self.instance_name
-        })
+        # logger.info("关闭统计收集器", {
+        #     'instance_name': self.instance_name
+        # })
         
         # 设置关闭标志
         self._shutdown_event.set()
@@ -417,18 +409,19 @@ class SmartCacheSystem:
                 try:
                     self._create_simple_stats_table()
                     self._state = CacheSystemState.MYSQL_READY
-                    logger.info("统计功能已启用", {
-                        'instance_name': self.instance_name,
-                        'process_id': os.getpid()
-                    })
+                    # logger.info("统计功能已启用", {
+                    #     'instance_name': self.instance_name,
+                    #     'process_id': os.getpid()
+                    # })
                 except Exception as e:
-                    logger.error("统计表创建失败", {
-                        'instance_name': self.instance_name,
-                        'error': str(e)
-                    })
+                    # logger.error("统计表创建失败", {
+                    #     'instance_name': self.instance_name,
+                    #     'error': str(e)
+                    # })
+                    pass
         else:
             self._state = CacheSystemState.ERROR
-            logger.error("Redis连接失败", {'instance_name': self.instance_name})
+            # logger.error("Redis连接失败", {'instance_name': self.instance_name})
     
     def _test_redis_connection(self) -> bool:
         """测试Redis连接"""
@@ -436,7 +429,7 @@ class SmartCacheSystem:
             self.redis_client.ping()
             return True
         except Exception as e:
-            logger.error("Redis连接测试失败", {'error': str(e)})
+            # logger.error("Redis连接测试失败", {'error': str(e)})
             return False
     
     def _create_simple_stats_table(self):
@@ -493,7 +486,7 @@ class SmartCacheSystem:
             connection.close()
             
         except Exception as e:
-            logger.error("统计表初始化失败", {'error': str(e)})
+            # logger.error("统计表初始化失败", {'error': str(e)})
             raise
     
     @property
@@ -539,11 +532,11 @@ class SmartCacheSystem:
             response_time = (time.time() - start_time) * 1000
             if self.stats_collector:
                 self.stats_collector.record_operation('errors', response_time, namespace)
-            logger.error("缓存获取失败", {
-                'key': key,
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("缓存获取失败", {
+            #     'key': key,
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return default
     
     def set(self, key: str, value: Any, ttl: Optional[int] = None, namespace: str = "") -> bool:
@@ -574,11 +567,11 @@ class SmartCacheSystem:
             if value_size > self.config.max_value_size:
                 if self.stats_collector:
                     self.stats_collector.record_operation('errors', 0, namespace)
-                logger.warning("缓存值过大，跳过设置", {
-                    'key': key,
-                    'size': len(serialized_value),
-                    'max_size': self.config.max_value_size
-                })
+                # logger.warning("缓存值过大，跳过设置", {
+                #     'key': key,
+                #     'size': len(serialized_value),
+                #     'max_size': self.config.max_value_size
+                # })
                 return False
             
             result = self.redis_client.setex(cache_key, ttl, serialized_value)
@@ -592,11 +585,11 @@ class SmartCacheSystem:
             response_time = (time.time() - start_time) * 1000
             if self.stats_collector:
                 self.stats_collector.record_operation('errors', response_time, namespace)
-            logger.error("缓存设置失败", {
-                'key': key,
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("缓存设置失败", {
+            #     'key': key,
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return False
     
     def delete(self, key: str, namespace: str = "") -> bool:
@@ -621,11 +614,11 @@ class SmartCacheSystem:
             response_time = (time.time() - start_time) * 1000
             if self.stats_collector:
                 self.stats_collector.record_operation('errors', response_time, namespace)
-            logger.error("缓存删除失败", {
-                'key': key,
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("缓存删除失败", {
+            #     'key': key,
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return False
     
     def clear_namespace(self, namespace: str) -> int:
@@ -643,10 +636,10 @@ class SmartCacheSystem:
             return 0
             
         except Exception as e:
-            logger.error("清除命名空间失败", {
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("清除命名空间失败", {
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return 0
     
     def _generate_cache_key(self, key: str, namespace: str = "") -> str:
@@ -760,18 +753,6 @@ class SmartCacheSystem:
         # 7. TTL边界限制（使用配置值）
         final_ttl = max(self.config.ttl_min, min(self.config.ttl_max, final_ttl))
         
-        # 8. 记录智能TTL决策（使用配置开关）
-        if self.config.debug_ttl:
-            logger.debug("智能TTL计算", {
-                'namespace': namespace,
-                'key': key[:50] + "..." if len(key) > 50 else key,
-                'data_size': data_size,
-                'base_ttl': base_ttl,
-                'key_factor': key_factor,
-                'size_factor': size_factor,
-                'final_ttl': final_ttl
-            })
-        
         return final_ttl
     
     def get_stats(self) -> Dict[str, Any]:
@@ -779,11 +760,7 @@ class SmartCacheSystem:
         # 确保统计系统已初始化
         if self.stats_collector:
             return self.stats_collector.get_stats()
-        
-        logger.debug("统计系统未初始化，返回空统计信息", {
-            'instance_name': self.instance_name,
-            'process_id': os.getpid()
-        })
+
         return {
             'enabled': False,
             'message': '统计系统未初始化',
@@ -828,14 +805,6 @@ class SmartCacheSystem:
         if not self.config.enable_stats:
             return
             
-        logger.debug("调用操作记录", {
-            'operation': operation,
-            'response_time_ms': round(response_time, 2),
-            'namespace': namespace,
-            'key': key[:50] + "..." if len(key) > 50 else key,
-            'instance_name': self.instance_name
-        })
-        
     def shutdown(self):
         """关闭缓存系统"""
         self._state = CacheSystemState.SHUTDOWN
@@ -844,7 +813,7 @@ class SmartCacheSystem:
             # 关闭统计收集器（包括后台定时器）
             self.stats_collector.shutdown()
         
-        logger.info("缓存系统已关闭", {'instance_name': self.instance_name})
+        # logger.info("缓存系统已关闭", {'instance_name': self.instance_name})
 
 
 class CacheManager:
@@ -868,10 +837,10 @@ class CacheManager:
     def initialize(self, redis_client: redis.Redis, mysql_pool=None, instance_name: str = "default", **config):
         """初始化缓存系统"""
         if self.cache_instance is not None:
-            logger.warning("缓存系统已初始化，跳过重复初始化", {
-                'existing_instance': self.cache_instance.instance_name,
-                'new_instance': instance_name
-            })
+            # logger.warning("缓存系统已初始化，跳过重复初始化", {
+            #     'existing_instance': self.cache_instance.instance_name,
+            #     'new_instance': instance_name
+            # })
             return
         
         self.cache_instance = SmartCacheSystem(

mdbq/route/monitor.py

@@ -21,7 +21,7 @@ from typing import Dict, Any
 from urllib.parse import urlparse
 from dbutils.pooled_db import PooledDB # type: ignore
 from mdbq.myconf import myconf # type: ignore
-from mdbq.log import mylogger
+# from mdbq.log import mylogger
 from flask import request, g
 import re
 import ipaddress
@@ -33,17 +33,17 @@ host, port, username, password = parser.get_section_values(
     keys=['host', 'port', 'username', 'password'],
 )
 
-logger = mylogger.MyLogger(
-    logging_mode='file',
-    log_level='info',
-    log_format='json',
-    max_log_size=50,
-    backup_count=5,
-    enable_async=False,  # 是否启用异步日志
-    sample_rate=1,  # 采样DEBUG/INFO日志
-    sensitive_fields=[],  #  敏感字段过滤
-    enable_metrics=False,  # 是否启用性能指标
-)
+# logger = mylogger.MyLogger(
+#     logging_mode='file',
+#     log_level='info',
+#     log_format='json',
+#     max_log_size=50,
+#     backup_count=5,
+#     enable_async=False,  # 是否启用异步日志
+#     sample_rate=1,  # 采样DEBUG/INFO日志
+#     sensitive_fields=[],  #  敏感字段过滤
+#     enable_metrics=False,  # 是否启用性能指标
+# )
 
 
 class RouteMonitor:
@@ -83,10 +83,10 @@ class RouteMonitor:
                 connection.close()
                 
         except Exception as e:
-            logger.error("❌ 数据库连接池初始化失败", {
-                "错误信息": str(e),
-                "数据库": self.database
-            })
+            # logger.error("数据库连接池初始化失败", {
+            #     "错误信息": str(e),
+            #     "数据库": self.database
+            # })
             raise
     
     def ensure_database_context(self, cursor):
@@ -94,22 +94,16 @@ class RouteMonitor:
         try:
             cursor.execute(f"USE `{self.database}`")
         except Exception as e:
-            logger.warning("切换数据库上下文失败，尝试重新创建", {
-                "数据库": self.database,
-                "错误": str(e)
-            })
+            # logger.warning("切换数据库上下文失败，尝试重新创建", {
+            #     "数据库": self.database,
+            #     "错误": str(e)
+            # })
             cursor.execute(f"CREATE DATABASE IF NOT EXISTS `{self.database}` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci")
             cursor.execute(f"USE `{self.database}`")
         
     def init_database_tables(self):
         """初始化数据库表结构"""
         try:
-            logger.debug("🗄️ 开始创建/验证数据库表结构", {
-                "操作": "表结构初始化",
-                "预期表数": 4,
-                "数据库": self.database
-            })
-            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
@@ -244,23 +238,17 @@ class RouteMonitor:
                         COMMENT='系统性能统计表';
                     """)
                 connection.commit()
-                logger.debug("🎯 所有数据库表结构初始化完成", {
-                    "创建表数": 4,
-                    "操作状态": "成功",
-                    "数据库": self.database,
-                    "数据库引擎": "InnoDB"
-                })
                 
             finally:
                 connection.close()
                 
         except Exception as e:
-            logger.error("❌ 数据库表结构初始化失败", {
-                "错误信息": str(e),
-                "错误类型": type(e).__name__,
-                "数据库": self.database,
-                "影响": "监控系统可能无法正常工作"
-            })
+            # logger.error("数据库表结构初始化失败", {
+            #     "错误信息": str(e),
+            #     "错误类型": type(e).__name__,
+            #     "数据库": self.database,
+            #     "影响": "监控系统可能无法正常工作"
+            # })
             # 静默处理初始化错误，避免影响主应用
             pass
     
@@ -434,25 +422,9 @@ class RouteMonitor:
         
         # 设置请求ID到全局变量中，供后续使用
         g.request_id = request_id
-        
-        logger.debug("📋 开始收集请求数据", {
-            "请求ID": request_id,
-            "请求方法": request.method,
-            "端点": request.endpoint or request.path,
-            "客户端IP": request.remote_addr
-        })
-        
         # 获取真实IP
         real_ip, forwarded_ips = self.get_real_ip(request)
         
-        if real_ip != request.remote_addr:
-            logger.debug("🔍 检测到IP转发", {
-                "请求ID": request_id,
-                "原始IP": request.remote_addr,
-                "真实IP": real_ip,
-                "转发链长度": len(forwarded_ips) if forwarded_ips else 0
-            })
-        
         # 获取请求头信息
         headers = dict(request.headers)
         sanitized_headers = self.sanitize_data(headers)
@@ -479,25 +451,15 @@ class RouteMonitor:
                             request_body = body_data.decode('utf-8')
                         except UnicodeDecodeError:
                             request_body = f"[BINARY_DATA:{len(body_data)}_bytes]"
-                            logger.debug("📁 检测到二进制数据", {
-                                "请求ID": request_id,
-                                "数据大小": len(body_data),
-                                "处理方式": "标记为二进制"
-                            })
                 
                 if request_body:
                     request_size = len(str(request_body).encode('utf-8'))
-                    logger.debug("📊 请求体信息", {
-                        "请求ID": request_id,
-                        "数据类型": "JSON" if request.is_json else "表单" if request.form else "文本",
-                        "大小": f"{request_size} bytes"
-                    })
         except Exception as e:
             request_body = "[ERROR_READING_BODY]"
-            logger.warning("⚠️ 读取请求体失败", {
-                "请求ID": request_id,
-                "错误": str(e)
-            })
+            # logger.warning("读取请求体失败", {
+            #     "请求ID": request_id,
+            #     "错误": str(e)
+            # })
         
         # 清理敏感数据
         sanitized_body = self.sanitize_data(request_body)
@@ -506,21 +468,6 @@ class RouteMonitor:
         # 设备信息提取
         user_agent = request.headers.get('User-Agent', '')
         device_info = self.extract_device_info(user_agent)
-        
-        if device_info['is_bot']:
-            logger.debug("🤖 检测到机器人请求", {
-                "请求ID": request_id,
-                "用户代理": user_agent[:100] + "..." if len(user_agent) > 100 else user_agent,
-                "IP": real_ip
-            })
-        
-        if device_info['is_mobile']:
-            logger.debug("📱 检测到移动设备请求", {
-                "请求ID": request_id,
-                "操作系统": device_info['os_name'],
-                "浏览器": device_info['browser_name']
-            })
-        
         # URL解析
         parsed_url = urlparse(request.url)
         
@@ -559,14 +506,6 @@ class RouteMonitor:
             'os_version': device_info['os_version'],
         }
         
-        logger.debug("✅ 请求数据收集完成", {
-            "请求ID": request_id,
-            "数据字段数": len(request_data),
-            "请求大小": f"{request_size} bytes",
-            "设备类型": "移动" if device_info['is_mobile'] else "桌面",
-            "是否机器人": device_info['is_bot']
-        })
-        
         return request_data
     
     def mask_token(self, token: str) -> str:
@@ -591,13 +530,6 @@ class RouteMonitor:
             if response_data:
                 request_data.update(response_data)
             
-            logger.debug("💾 保存请求日志到数据库", {
-                "请求ID": request_id,
-                "端点": request_data.get('endpoint', ''),
-                "状态码": request_data.get('response_status', '未知'),
-                "处理时间": f"{request_data.get('process_time', 0)}ms"
-            })
-            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
@@ -616,39 +548,26 @@ class RouteMonitor:
                     cursor.execute(sql, list(request_data.values()))
                 connection.commit()
                 
-                logger.debug("✅ 请求日志保存成功", {
-                    "请求ID": request_id,
-                    "写入状态": "成功",
-                    "数据库表": "api_request_logs"
-                })
-                
             finally:
                 connection.close()
                 
         except Exception as e:
-            logger.error("❌ 保存请求日志失败", {
-                "请求ID": request_id,
-                "错误信息": str(e),
-                "错误类型": type(e).__name__,
-                "影响": "日志丢失，但不影响主业务"
-            })
+            # logger.error("保存请求日志失败", {
+            #     "请求ID": request_id,
+            #     "错误信息": str(e),
+            #     "错误类型": type(e).__name__,
+            #     "影响": "日志丢失，但不影响主业务"
+            # })
             # 静默处理错误，不影响主业务
             pass
     
     def update_statistics(self, request_data: Dict[str, Any]):
         """更新统计数据"""
         request_id = request_data.get('request_id', 'unknown')
-        endpoint = request_data.get('endpoint', '')
-        status_code = request_data.get('response_status', 500)
+        # endpoint = request_data.get('endpoint', '')
+        # status_code = request_data.get('response_status', 500)
         
         try:
-            logger.debug("📈 更新统计数据", {
-                "请求ID": request_id,
-                "端点": endpoint,
-                "状态码": status_code,
-                "统计类型": "API访问统计和IP统计"
-            })
-            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
@@ -705,23 +624,16 @@ class RouteMonitor:
                     
                 connection.commit()
                 
-                logger.debug("✅ 统计数据更新成功", {
-                    "请求ID": request_id,
-                    "更新表": "api_access_statistics, ip_access_statistics",
-                    "日期": str(date),
-                    "小时": hour
-                })
-                
             finally:
                 connection.close()
                 
         except Exception as e:
-            logger.error("❌ 更新统计数据失败", {
-                "请求ID": request_id,
-                "错误信息": str(e),
-                "错误类型": type(e).__name__,
-                "影响": "统计数据缺失，但不影响主业务"
-            })
+            # logger.error("更新统计数据失败", {
+            #     "请求ID": request_id,
+            #     "错误信息": str(e),
+            #     "错误类型": type(e).__name__,
+            #     "影响": "统计数据缺失，但不影响主业务"
+            # })
             # 静默处理错误
             pass
 
@@ -737,14 +649,6 @@ class RouteMonitor:
             request_data = self.collect_request_data(request)
             request_id = request_data.get('request_id', 'unknown')
             
-            logger.debug("🎯 开始监控请求", {
-                "请求ID": request_id,
-                "函数名": func.__name__,
-                "端点": request_data.get('endpoint', ''),
-                "方法": request_data.get('method', ''),
-                "来源IP": request_data.get('real_ip', request_data.get('client_ip'))
-            })
-            
             try:
                 # 执行原函数
                 response = func(*args, **kwargs)
@@ -774,16 +678,6 @@ class RouteMonitor:
                     'process_time': process_time,
                     'response_size': response_size
                 }
-                
-                logger.debug("✅ 请求处理完成", {
-                    "请求ID": request_id,
-                    "函数名": func.__name__,
-                    "状态码": response_status,
-                    "处理时间": f"{process_time}ms",
-                    "响应大小": f"{response_size} bytes",
-                    "结果": "成功"
-                })
-                
                 # 保存日志
                 self.save_request_log(request_data, response_data)
                 
@@ -805,14 +699,14 @@ class RouteMonitor:
                     'response_size': 0
                 }
                 
-                logger.error("❌ 请求处理异常", {
-                    "请求ID": request_id,
-                    "函数名": func.__name__,
-                    "错误信息": str(e),
-                    "错误类型": type(e).__name__,
-                    "处理时间": f"{process_time}ms",
-                    "结果": "异常"
-                })
+                # logger.error("请求处理异常", {
+                #     "请求ID": request_id,
+                #     "函数名": func.__name__,
+                #     "错误信息": str(e),
+                #     "错误类型": type(e).__name__,
+                #     "处理时间": f"{process_time}ms",
+                #     "结果": "异常"
+                # })
                 
                 # 保存错误日志
                 self.save_request_log(request_data, error_data)
@@ -829,11 +723,6 @@ class RouteMonitor:
     def get_statistics_summary(self, days: int = 7) -> Dict[str, Any]:
         """获取统计摘要"""
         try:
-            logger.debug("📊 开始获取统计摘要", {
-                "查询天数": days,
-                "操作": "统计数据查询"
-            })
-            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
@@ -843,12 +732,6 @@ class RouteMonitor:
                     end_date = datetime.now().date()
                     start_date = end_date - timedelta(days=days)
                     
-                    logger.debug("📅 统计查询时间范围", {
-                        "开始日期": str(start_date),
-                        "结束日期": str(end_date),
-                        "查询天数": days
-                    })
-                    
                     # 总体统计
                     cursor.execute("""
                         SELECT 
@@ -862,15 +745,6 @@ class RouteMonitor:
                     """, (start_date, end_date))
                     
                     summary = cursor.fetchone() or {}
-                    
-                    logger.debug("📈 总体统计查询完成", {
-                        "总请求数": summary.get('total_requests', 0) or 0,
-                        "成功请求数": summary.get('success_requests', 0) or 0,
-                        "错误请求数": summary.get('error_requests', 0) or 0,
-                        "平均响应时间": f"{(summary.get('avg_response_time', 0) or 0):.2f}ms",
-                        "唯一端点数": summary.get('unique_endpoints', 0) or 0
-                    })
-                    
                     # 热门端点
                     cursor.execute("""
                         SELECT endpoint, SUM(total_requests) as requests
@@ -883,12 +757,6 @@ class RouteMonitor:
                     
                     top_endpoints = cursor.fetchall()
                     
-                    logger.debug("🔥 热门端点查询完成", {
-                        "查询结果数": len(top_endpoints),
-                        "最热门端点": top_endpoints[0]['endpoint'] if top_endpoints else "无数据",
-                        "最高请求数": top_endpoints[0]['requests'] if top_endpoints else 0
-                    })
-                    
                     # 活跃IP统计
                     cursor.execute("""
                         SELECT COUNT(DISTINCT ip_address) as unique_ips,
@@ -899,11 +767,6 @@ class RouteMonitor:
                     
                     ip_stats = cursor.fetchone() or {}
                     
-                    logger.debug("🌐 IP统计查询完成", {
-                        "唯一IP数": ip_stats.get('unique_ips', 0),
-                        "IP总请求数": ip_stats.get('total_ip_requests', 0)
-                    })
-                    
                     result = {
                         'period': f'{start_date} to {end_date}',
                         'summary': summary,
@@ -911,24 +774,18 @@ class RouteMonitor:
                         'ip_statistics': ip_stats
                     }
                     
-                    logger.debug("✅ 统计摘要获取成功", {
-                        "查询天数": days,
-                        "数据完整性": "完整",
-                        "结果状态": "成功"
-                    })
-                    
                     return result
                     
             finally:
                 connection.close()
                     
         except Exception as e:
-            logger.error("❌ 获取统计摘要失败", {
-                "查询天数": days,
-                "错误信息": str(e),
-                "错误类型": type(e).__name__,
-                "影响": "统计摘要不可用"
-            })
+            # logger.error("获取统计摘要失败", {
+            #     "查询天数": days,
+            #     "错误信息": str(e),
+            #     "错误类型": type(e).__name__,
+            #     "影响": "统计摘要不可用"
+            # })
             return {'error': str(e)}
 
 

{mdbq-4.1.2.dist-info → mdbq-4.1.3.dist-info}/METADATA

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

{mdbq-4.1.2.dist-info → mdbq-4.1.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=t0Fz3FVzbu8dTQm35pWtvOg5K2EJnfXWvbSU90YalwU,17
+mdbq/__version__.py,sha256=Jjk9_jrwEIRLu3zYAhoUXB_8XlsokRJUl6DPuo2urQw,17
 mdbq/auth/__init__.py,sha256=pnPMAt63sh1B6kEvmutUuro46zVf2v2YDAG7q-jV_To,24
 mdbq/auth/auth_backend.py,sha256=u8qwMNjAdDliaaFzfulVqQIoFrIJhe980OdYwTIVKJg,99750
 mdbq/auth/crypto.py,sha256=fcZRFCnrKVVdWDUx_zds51ynFYwS9DBvJOrRQVldrfM,15931
@@ -9,11 +9,11 @@ mdbq/js/jc.py,sha256=6Rgf1WqaJJ1oevpn-pt08gXKbX5hjoQaV6uZGCAGbYw,13177
 mdbq/log/__init__.py,sha256=Mpbrav0s0ifLL7lVDAuePEi1hJKiSHhxcv1byBKDl5E,15
 mdbq/log/mylogger.py,sha256=DyBftCMNLe1pTTXsa830pUtDISJxpJHFIradYtE3lFA,26418
 mdbq/myconf/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
-mdbq/myconf/myconf.py,sha256=rHvQCnQRKhQ49AZBke-Z4v28hyOLmHt4MylIuB0H6yA,33516
+mdbq/myconf/myconf.py,sha256=x_9mS6wOfKVjCVElbruxj2yjzitbyKiTkf59quG-5Zg,32529
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
 mdbq/mysql/deduplicator.py,sha256=2fugLyKs_xkvYvoG0C0hRYbJ_w8-4oa1FJ_vavoD7Qo,73084
 mdbq/mysql/mysql.py,sha256=pDg771xBugCMSTWeskIFTi3pFLgaqgyG3smzf-86Wn8,56772
-mdbq/mysql/s_query.py,sha256=nwhyqbxq-V0sGUJbdjiUDEwjpDxiKrzG0PjV6wkrWU4,50474
+mdbq/mysql/s_query.py,sha256=N2xHJf2CiUXjXIVBemdst-wamIP3908EGAJOFG13fCU,50475
 mdbq/mysql/unique_.py,sha256=MaztT-WIyEQUs-OOYY4pFulgHVcXR1BfCy3QUz0XM_U,21127
 mdbq/mysql/uploader.py,sha256=FG_4btNwTjbCqZFeIigCfar7r-OOA7VkyuJsOOC9WLw,111539
 mdbq/other/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
@@ -26,16 +26,16 @@ mdbq/pbix/__init__.py,sha256=Trtfaynu9RjoTyLLYBN2xdRxTvm_zhCniUkVTAYwcjo,24
 mdbq/pbix/pbix_refresh.py,sha256=JUjKW3bNEyoMVfVfo77UhguvS5AWkixvVhDbw4_MHco,2396
 mdbq/pbix/refresh_all.py,sha256=OBT9EewSZ0aRS9vL_FflVn74d4l2G00wzHiikCC4TC0,5926
 mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
-mdbq/redis/getredis.py,sha256=vpBuNc22uj9Vr-_Dh25_wpwWM1e-072EAAIBdB_IpL0,23494
-mdbq/redis/redis_cache.py,sha256=2uhAmG9FYHjzByZEg7o8fFFxuF6AnOASVvjdAM4Gx5E,35719
+mdbq/redis/getredis.py,sha256=vdg7YQEjhoMp5QzxygNGx5DQKRnePrcwPYgUrDypA6g,23672
+mdbq/redis/redis_cache.py,sha256=hjl-oh1r0ONdMeWN28cTMsdkcjc7HG71NmGZ9H6jWUE,34559
 mdbq/route/__init__.py,sha256=BT_dAY7V-U2o72bevq1B9Mq9QA7GodwtkxyLNdGaoE8,22
 mdbq/route/analytics.py,sha256=dngj5hVwKddEUy59nSYbOoJ9C7OVrtCmCkvW6Uj9RYM,28097
-mdbq/route/monitor.py,sha256=8uscuoJF4eMr5o8cAqywQv868m1yIGCuK1l4ZWN6KPE,42954
+mdbq/route/monitor.py,sha256=lyowGUU8c2GykeZLrdxd7nXpNMqXWcOsuQsbS8l0pwU,36595
 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.1.2.dist-info/METADATA,sha256=PsddxgvUrLRPSZGLVd4b64UA19gU-LjiHkK2FV1_OVM,363
-mdbq-4.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mdbq-4.1.2.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-4.1.2.dist-info/RECORD,,
+mdbq-4.1.3.dist-info/METADATA,sha256=9NMHciONJynTrghvSivIGIOTpBkPaiF4FlS-spIRbXc,363
+mdbq-4.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mdbq-4.1.3.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-4.1.3.dist-info/RECORD,,