mdbq 4.0.3__tar.gz → 4.0.5__tar.gz

{mdbq-4.0.3 → mdbq-4.0.5}/PKG-INFO

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

mdbq-4.0.5/mdbq/__version__.py

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

{mdbq-4.0.3 → mdbq-4.0.5}/mdbq/aggregation/query_data.py

@@ -14,7 +14,8 @@ import platform
 import os
 import time
 import calendar
-import concurrent.futures
+from collections.abc import Mapping, Sequence
+import inspect
 
 dir_path = os.path.expanduser("~")
 config_file = os.path.join(dir_path, 'spd.txt')
@@ -36,6 +37,47 @@ logger = mylogger.MyLogger(
 )
 
 
+def reorder_columns(df: pd.DataFrame, set_type) -> pd.DataFrame:
+    """
+    调整DataFrame的列顺序，按照set_type中的顺序排列，忽略大小写，set_type中不存在的列自动跳过。
+    set_type可以是列表或字典（此时用字典的键名作为顺序）。
+    不改变数据和数据类型。
+    如果 set_type 为 None、空列表或空字典，则直接返回原 df，不做任何调整。
+    """
+    # 直接返回原 df 的情况
+    if set_type is None:
+        return df
+    if isinstance(set_type, Mapping) and len(set_type) == 0:
+        return df
+    if isinstance(set_type, Sequence) and not isinstance(set_type, str) and len(set_type) == 0:
+        return df
+
+    # 如果set_type是字典，提取其键名
+    if isinstance(set_type, Mapping):
+        col_order = list(set_type.keys())
+    elif isinstance(set_type, Sequence) and not isinstance(set_type, str):
+        col_order = list(set_type)
+    else:
+        raise ValueError("set_type must be a list or a dict (or other mapping type)")
+
+    # 构建原始列名的映射（小写->原始名）
+    col_map = {col.lower(): col for col in df.columns}
+    # 生成新顺序的列名（只保留df中存在的列，且顺序按set_type）
+    new_cols = []
+    used = set()
+    for col in col_order:
+        key = col.lower()
+        if key in col_map and key not in used:
+            new_cols.append(col_map[key])
+            used.add(key)
+    # 添加剩余未在set_type中出现的列，保持原顺序
+    for col in df.columns:
+        if col.lower() not in used:
+            new_cols.append(col)
+    # 返回新顺序的DataFrame
+    return df[new_cols]
+
+
 def upload_data_decorator(**upload_kwargs):
     """
     数据上传装饰器
@@ -45,82 +87,90 @@ def upload_data_decorator(**upload_kwargs):
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
+            db_name = None
+            table_name = None
             try:
+                # 获取函数签名和参数
+                sig = inspect.signature(func)
+                bound_args = sig.bind(*args, **kwargs)
+                args_dict = bound_args.arguments
+
+                # 获取所需参数
+                def get_param_value(param_name, alternatives=None):
+                    if alternatives is None:
+                        alternatives = [param_name]
+                    # 从 kwargs 或 args_dict 中获取参数值
+                    for key in alternatives:
+                        if key in kwargs:
+                            return kwargs[key]
+                        if key in args_dict:
+                            return args_dict[key]
+                    return None
+
+                # 获取参数值
+                set_type = get_param_value('set_type', ['set_type', 'set_typ'])
+                db_name = get_param_value('db_name')
+                table_name = get_param_value('table_name')
+
                 # 执行原始函数
                 result = func(*args, **kwargs)
                 
-                # 如果返回 None，直接返回
                 if result is None:
                     return None
-                
-                # 如果返回的是 DataFrame
+
+                # 处理 DataFrame 结果
                 if isinstance(result, pd.DataFrame):
-                    # 设置默认值
-                    default_kwargs = {
+                    if set_type is not None:
+                        result = reorder_columns(result, set_type)
+                    
+                    # 合并参数
+                    merged_kwargs = {
                         'check_duplicate': False,
                         'update_on_duplicate': True,
                         'allow_null': False,
-                        'transaction_mode': 'batch'
+                        'transaction_mode': 'batch',
+                        **upload_kwargs
                     }
-                    # 更新参数，优先使用装饰器参数
-                    merged_kwargs = {**default_kwargs, **upload_kwargs}
                     
-                    # 上传数据
-                    uld.upload_data(
-                        data=result,
-                        **merged_kwargs
-                    )
+                    uld.upload_data(data=result, **merged_kwargs)
                     return True
-                
-                # 如果返回的是元组
+
+                # 处理元组结果
                 elif isinstance(result, tuple):
-                    # 检查元组长度
                     if len(result) < 2:
-                        logger.warning('函数返回的元组长度小于2，直接返回原结果，不执行上传', {'函数': func.__name__})
+                        logger.warning('函数返回的元组长度小于2，直接返回原结果，不执行上传', {'函数': func.__name__, '库': db_name, '表': table_name})
                         return result
-                        
-                    # 获取前两个元素
+
                     df, extra_kwargs = result[0], result[1]
                     
-                    # 检查第一个元素是否为DataFrame
                     if not isinstance(df, pd.DataFrame):
-                        logger.warning('函数返回的元组第一个元素不是DataFrame，直接返回原结果，不执行上传', {'函数': func.__name__})
+                        logger.warning('函数返回的元组第一个元素不是DataFrame，直接返回原结果，不执行上传', {'函数': func.__name__, '库': db_name, '表': table_name})
                         return result
-                        
-                    # 合并装饰器参数和函数参数
-                    merged_kwargs = {**upload_kwargs}
-                    merged_kwargs.update(extra_kwargs)
-                    
-                    # 设置默认值
-                    default_kwargs = {
+
+                    if set_type is not None:
+                        df = reorder_columns(df, set_type)
+                        result = (df, extra_kwargs) + result[2:]
+
+                    # 合并参数
+                    merged_kwargs = {
                         'check_duplicate': False,
                         'update_on_duplicate': True,
                         'allow_null': False,
-                        'transaction_mode': 'batch'
+                        'transaction_mode': 'batch',
+                        **upload_kwargs,
+                        **extra_kwargs
                     }
-                    # 更新参数，优先使用装饰器参数
-                    for key, value in default_kwargs.items():
-                        if key not in merged_kwargs:
-                            merged_kwargs[key] = value
                     
-                    # 上传数据
-                    uld.upload_data(
-                        data=df,
-                        **merged_kwargs
-                    )
+                    uld.upload_data(data=df, **merged_kwargs)
                     
-                    # 如果元组长度大于2，返回完整元组
-                    if len(result) > 2:
-                        return result
-                    return True
-                
-                # 其他情况直接返回结果
+                    return result if len(result) > 2 else True
+
                 return result
-                
+
             except Exception as e:
-                logger.error('数据上传失败', {'函数': func.__name__, '错误': str(e)})
+                logger.error('数据上传失败', {'函数': func.__name__, '库': db_name, '表': table_name, '错误': str(e)})
                 return False
-                
+
         return wrapper
     return decorator
 
@@ -1951,7 +2001,7 @@ class MysqlDatasQuery:
             'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
             'indexes': [],  # 普通索引列
             'transaction_mode': 'batch',  # 事务模式
-            'unique_keys': [['日期', '店铺名称', '产品线', '触发sku_id', '跟单sku_id']],  # 唯一约束列表
+            'unique_keys': [['日期', '店铺名称', '产品线', '触发sku_id', '跟单sku_id', '花费']],  # 唯一约束列表
         }
 
     @try_except
@@ -2119,7 +2169,7 @@ class MysqlDatasQuery:
             'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
             'indexes': [],  # 普通索引列
             'transaction_mode': 'batch',  # 事务模式
-            'unique_keys': [['日期', '产品线', '搜索词', '计划id', '搜索词', '关键词']],  # 唯一约束列表
+            'unique_keys': [['日期', '产品线', '计划id', '搜索词', '关键词']],  # 唯一约束列表
         }
 
     @try_except
@@ -3032,7 +3082,7 @@ class MysqlDatasQuery:
             'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
             'indexes': [],  # 普通索引列
             'transaction_mode': 'batch',  # 事务模式
-            'unique_keys': [['日期', '店铺名称', '营销场景']],  # 唯一约束列表
+            'unique_keys': [['日期', '店铺名称', '商品款号', 'spuid']],  # 唯一约束列表
         }
 
     @upload_data_decorator()
@@ -3661,7 +3711,6 @@ def date_table():
     df = df.reset_index(drop=False)
     df.rename(columns={'index': 'id'}, inplace=True)
     df['id'] = df['id'].apply(lambda x: x + 1)
-
     set_typ = {
         '日期': 'date',
         '年': 'varchar(50)',
@@ -3676,6 +3725,7 @@ def date_table():
         '索引': 'int',
         '月索引': 'int',
     }
+
     return df, {
         'db_name': '聚合数据',
         'table_name': '日期表',
@@ -3693,12 +3743,7 @@ def date_table():
     }
 
 
-def query1(months=1, less_dict=None, download_manager=None):
-    if less_dict is None:
-        less_dict = []
-    if months == 0:
-        logger.info('months 不建议为 0')
-        return
+def query1(months=1, download_manager=None):
     sdq = MysqlDatasQuery(download_manager=download_manager)  # 实例化数据处理类
     sdq.months = months  # 设置数据周期， 1 表示近 2 个月
 
@@ -3725,12 +3770,7 @@ def query1(months=1, less_dict=None, download_manager=None):
     sdq.performance_concat(bb_tg=False, db_name='聚合数据', table_name='天猫_推广汇总')  # _推广商品销售
 
 
-def query2(months=1, less_dict=None, download_manager=None):
-    if less_dict is None:
-        less_dict = []
-    if months == 0:
-        logger.info('months 不建议为 0')
-        return
+def query2(months=1, download_manager=None):
     sdq = MysqlDatasQuery(download_manager=download_manager)  # 实例化数据处理类
     sdq.months = months  # 设置数据周期， 1 表示近 2 个月
     sdq.dplyd(db_name='聚合数据', table_name='店铺流量来源构成')
@@ -3743,18 +3783,13 @@ def query2(months=1, less_dict=None, download_manager=None):
     sdq.deeplink(db_name='聚合数据', table_name='达摩盘_deeplink人群洞察')
 
 
-def query3(months=1, less_dict=None, download_manager=None):
-    if less_dict is None:
-        less_dict = []
-    if months == 0:
-        logger.info('months 不建议为 0')
-        return
+def query3(months=1, download_manager=None):
     sdq = MysqlDatasQuery(download_manager=download_manager)  # 实例化数据处理类
     sdq.months = months  # 设置数据周期， 1 表示近 2 个月
     sdq.spph(db_name='聚合数据', table_name='天猫_商品排行')
 
 
-def main(days=150, months=3):
+def main(months=3):
     # 1. 更新日期表  更新货品年份基准表， 属性设置 3 - 货品年份基准
     date_table()
 
@@ -3772,9 +3807,6 @@ def main(days=150, months=3):
 
 
 if __name__ == '__main__':
-    main(
-        days=150,  # 清理聚合数据的日期长度
-        months=3  # 生成聚合数据的长度
-    )
+    # main(months=3)
 
-    # date_table()
+    pass

{mdbq-4.0.3 → mdbq-4.0.5}/mdbq/mysql/s_query.py

@@ -762,6 +762,21 @@ class QueryDatas:
             finally:
                 self.pool = None
 
+    def _adjust_page_size(self, last_duration, current_page_size, min_size=1000, max_size=10000, target_time=2.0):
+        """
+        根据上一次批次耗时自动调整下一次的 page_size。
+        - last_duration: 上一批次查询耗时（秒）
+        - current_page_size: 当前批次大小
+        - min_size, max_size: 允许的最小/最大批次
+        - target_time: 期望每批耗时（秒）
+        """
+        if last_duration < target_time / 2 and current_page_size < max_size:
+            return min(current_page_size * 2, max_size)
+        elif last_duration > target_time * 2 and current_page_size > min_size:
+            return max(current_page_size // 2, min_size)
+        else:
+            return current_page_size
+
     def data_to_df(
             self, 
             db_name: str, 
@@ -890,18 +905,20 @@ class QueryDatas:
                     # 分页查询
                     offset = 0
                     all_results = []
-                    
+                    min_size, max_size = 1000, 10000
+                    target_time = 1.0  # 期望每批1秒
+
                     while offset < total_count:
+                        start_time = time.time()
                         # 添加分页参数
                         page_sql = f"{base_sql} LIMIT %s OFFSET %s"
                         page_params = list(params) + [page_size, offset]
-                        
                         cursor.execute(page_sql, tuple(page_params))
                         page_results = cursor.fetchall()
-                        
+
                         if not page_results:
                             break
-                            
+
                         if return_format == 'list_dict':
                             all_results.extend(page_results)
                         else:
@@ -909,14 +926,18 @@ class QueryDatas:
                                 all_results = pd.DataFrame(page_results)
                             else:
                                 all_results = pd.concat([all_results, pd.DataFrame(page_results)], ignore_index=True)
-                        
-                        offset += page_size
+
+                        duration = time.time() - start_time
+                        page_size = self._adjust_page_size(duration, page_size, min_size, max_size, target_time)
+                        offset += len(page_results)
                         logger.debug('分页查询进度', {
                             '库': db_name,
                             '表': table_name,
-                            '当前偏移量': offset,
+                            # '当前偏移量': offset,
                             '总记录数': total_count,
-                            '已获取记录数': len(all_results) if return_format == 'list_dict' else len(all_results.index)
+                            '已获取记录数': len(all_results) if return_format == 'list_dict' else len(all_results.index),
+                            '本批耗时': f'{duration:.2f}',
+                            '下批page_size': page_size
                         })
 
                     if return_format == 'df' and isinstance(all_results, pd.DataFrame) and not all_results.empty:

{mdbq-4.0.3 → mdbq-4.0.5}/mdbq/mysql/uploader.py

@@ -14,6 +14,7 @@ from dbutils.pooled_db import PooledDB
 import json
 import sys
 from decimal import Decimal, InvalidOperation
+import math
 
 warnings.filterwarnings('ignore')
 logger = mylogger.MyLogger(
@@ -240,8 +241,16 @@ class MySQLUploader:
             conn = self.pool.connection()
             return conn
         except Exception as e:
-            logger.error('从连接池获取数据库连接失败', {'error': str(e)})
-            raise ConnectionError(f'连接数据库失败: {str(e)}')
+            logger.error('从连接池获取数据库连接失败，尝试重建连接池', {'error': str(e)})
+            # 强制重建连接池
+            try:
+                self.pool = self._create_connection_pool()
+                conn = self.pool.connection()
+                logger.info('重建连接池后获取连接成功')
+                return conn
+            except Exception as e2:
+                logger.error('重建连接池后依然获取连接失败', {'error': str(e2)})
+                raise ConnectionError(f'连接数据库失败: {str(e2)}')
 
     @_execute_with_retry
     def _check_database_exists(self, db_name: str) -> bool:
@@ -407,31 +416,36 @@ class MySQLUploader:
                 col_def += " NOT NULL"
             column_defs.append(col_def)
         # 主键处理逻辑调整
+        def _index_col_sql(col):
+            col_type = set_typ.get(col, '').lower()
+            if 'varchar' in col_type or 'text' in col_type:
+                return f"`{self._normalize_col(col)}`(100)"
+            return f"`{self._normalize_col(col)}`"
         if primary_keys and len(primary_keys) > 0:
-            safe_primary_keys = [self._normalize_col(pk) for pk in primary_keys]
-            primary_key_sql = f"PRIMARY KEY (`{'`,`'.join(safe_primary_keys)}`)"
+            safe_primary_keys = [_index_col_sql(pk) for pk in primary_keys]
+            primary_key_sql = f"PRIMARY KEY ({','.join(safe_primary_keys)})"
         else:
-            safe_primary_keys = [self._normalize_col('id')]
+            safe_primary_keys = [_index_col_sql('id')]
             primary_key_sql = f"PRIMARY KEY (`id`)"
         # 索引统一在CREATE TABLE中定义
         index_defs = []
         if date_column and date_column in set_typ:
-            safe_date_col = self._normalize_col(date_column)
-            index_defs.append(f"INDEX `idx_{safe_date_col}` (`{safe_date_col}`)")
+            safe_date_col = _index_col_sql(date_column)
+            index_defs.append(f"INDEX `idx_{self._normalize_col(date_column)}` ({safe_date_col})")
         if indexes:
             for idx_col in indexes:
                 if idx_col in set_typ:
-                    safe_idx_col = self._normalize_col(idx_col)
-                    index_defs.append(f"INDEX `idx_{safe_idx_col}` (`{safe_idx_col}`)")
+                    safe_idx_col = _index_col_sql(idx_col)
+                    index_defs.append(f"INDEX `idx_{self._normalize_col(idx_col)}` ({safe_idx_col})")
         # UNIQUE KEY定义
         unique_defs = []
         if unique_keys:
             for unique_cols in unique_keys:
                 if not unique_cols:
                     continue
-                safe_unique_cols = [self._normalize_col(col) for col in unique_cols]
-                unique_name = f"uniq_{'_'.join(safe_unique_cols)}"
-                unique_defs.append(f"UNIQUE KEY `{unique_name}` (`{'`,`'.join(safe_unique_cols)}`)")
+                safe_unique_cols = [_index_col_sql(col) for col in unique_cols]
+                unique_name = f"uniq_{'_'.join([self._normalize_col(c) for c in unique_cols])}"
+                unique_defs.append(f"UNIQUE KEY `{unique_name}` ({','.join(safe_unique_cols)})")
         index_defs = list(set(index_defs))
         all_defs = column_defs + [primary_key_sql] + index_defs + unique_defs
         sql = f"""
@@ -447,7 +461,7 @@ class MySQLUploader:
                 conn.commit()
                 logger.info('数据表及索引已创建', {'库': db_name, '表': table_name, '索引': indexes, '唯一约束': unique_keys})
         except Exception as e:
-            logger.error('建表失败', {'库': db_name, '表': table_name, '错误': str(e)})
+            logger.error('建表失败', {'库': db_name, '表': table_name, '错误': str(e), '异常类型': type(e).__name__})
             if conn is not None:
                 conn.rollback()
             raise
@@ -491,34 +505,53 @@ class MySQLUploader:
     def _validate_value(self, value: Any, column_type: str, allow_null: bool, db_name: str = None, table_name: str = None, col_name: str = None) -> Any:
         """
         根据列类型验证并转换数据值
-
-        :param value: 要验证的值
-        :param column_type: 列的数据类型
-        :param allow_null: 是否允许空值
-        :param db_name: 数据库名（用于日志）
-        :param table_name: 表名（用于日志）
-        :param col_name: 列名（用于日志）
-        :return: 转换后的值
-        :raises ValueError: 当值转换失败时抛出
         """
+        column_type_lower = column_type.lower() if column_type else ''
+        # 统一判断None/NaN
+        is_nan = False
         if value is None:
+            is_nan = True
+        elif isinstance(value, float) and math.isnan(value):
+            is_nan = True
+        elif str(value).lower() in ['nan', 'none']:
+            is_nan = True
+        if is_nan:
             if not allow_null:
-                logger.warning('字段值为None但不允许空值, 已填充为none', {
-                    '库': db_name, '表': table_name, '列': col_name, '字段类型': column_type
-                })
-                return 'none'
+                if 'int' in column_type_lower:
+                    logger.debug('字段值为None/NaN但不允许空值, 已填充为0', {
+                        '库': db_name, '表': table_name, '列': col_name, '字段类型': column_type
+                    })
+                    return 0
+                elif any(t in column_type_lower for t in ['float', 'double', 'decimal']):
+                    logger.debug('字段值为None/NaN但不允许空值, 已填充为0.0', {
+                        '库': db_name, '表': table_name, '列': col_name, '字段类型': column_type
+                    })
+                    return 0.0
+                elif 'date' in column_type_lower or 'time' in column_type_lower:
+                    if 'datetime' in column_type_lower or 'timestamp' in column_type_lower:
+                        default_date = '2000-01-01 00:00:00'
+                    else:
+                        default_date = '2000-01-01'
+                    logger.debug('字段值为None/NaN但不允许空值, 已填充为默认日期', {
+                        '库': db_name, '表': table_name, '列': col_name, '字段类型': column_type, '默认值': default_date
+                    })
+                    return default_date
+                else:
+                    logger.debug('字段值为None/NaN但不允许空值, 已填充为none字符串', {
+                        '库': db_name, '表': table_name, '列': col_name, '字段类型': column_type
+                    })
+                    return 'none'
             return None
         try:
-            column_type_lower = column_type.lower()
             if isinstance(value, str) and value.strip().endswith('%'):
-                try:
+                if re.match(r'^\d+(\.\d+)?%$', value.strip()):
                     percent_str = value.strip().replace('%', '')
                     percent_value = float(percent_str)
                     decimal_value = percent_value / 100
                     logger.debug('百分比字符串转小数', {'原始': value, '结果': decimal_value})
                     return decimal_value
-                except ValueError:
-                    logger.warning('百分比字符串转小数失败', {
+                else:
+                    logger.warning('百分比字符串不符合格式，跳过转换', {
                         '库': db_name, '表': table_name, '列': col_name, '原始': value
                     })
             elif 'int' in column_type_lower:
@@ -548,10 +581,18 @@ class MySQLUploader:
                         })
                         raise ValueError(f"无效日期格式: `{value}` -> {str(e)}")
                 return str(value)
-            elif 'char' in column_type_lower or 'text' in column_type_lower:
+            elif 'varchar' in column_type_lower:
                 if isinstance(value, str):
                     return value.replace('\\', '\\\\').replace("'", "\\'")
-                return str(value)
+            elif 'text' in column_type_lower:
+                if isinstance(value, str):
+                    max_length = 65535
+                    if len(value) > max_length:
+                        logger.warning(f'TEXT字符串长度不允许超过 {max_length}，已截断', {
+                            '库': db_name, '表': table_name, '列': col_name, '原始值': f'{value[:50]}...', '截断后值': f'{value[:50]}...'
+                        })
+                        value = value[:max_length]
+                return value.replace('\\', '\\\\').replace("'", "\\'")
             elif 'json' in column_type_lower:
                 return json.dumps(value) if value is not None else None
             else:
@@ -881,22 +922,21 @@ class MySQLUploader:
         # set_typ的键清洗
         set_typ = {self._normalize_col(k): v for k, v in set_typ.items()}
 
-        # 获取数据中实际存在的列名
-        data_columns = set()
-        if data and len(data) > 0:
-            data_columns = set(data[0].keys())
-
-        # 过滤set_typ，只保留数据中存在的列
+        # 新实现：严格按set_typ顺序过滤，后补充data中有但set_typ没有的列
         filtered_set_typ = {}
-        for col in data_columns:
-            if col in set_typ:
+        data_columns = list(data[0].keys()) if data and len(data) > 0 else []
+        # 先按set_typ顺序
+        for col in set_typ:
+            if col in data_columns:
                 filtered_set_typ[col] = set_typ[col]
-            else:
-                # 如果列不在set_typ中，采样多个非None值推断类型
+        # 再补充data中有但set_typ没有的列
+        for col in data_columns:
+            if col not in filtered_set_typ:
+                # 推断类型
                 sample_values = [row[col] for row in data if col in row and row[col] is not None][:5]
                 inferred_type = None
                 for val in sample_values:
-                    inferred_type = self._infer_data_type(val, no_log=True)  # 推断日期类型不记录日志, 避免日志噪音过多
+                    inferred_type = self._infer_data_type(val, no_log=True)
                     if inferred_type:
                         break
                 if not inferred_type:
@@ -1326,8 +1366,7 @@ class MySQLUploader:
         if cached:
             return cached
         # 获取所有列名（排除id）
-        all_columns = [col for col in set_typ.keys()
-                       if col.lower() != 'id']
+        all_columns = [col for col in set_typ.keys() if col.lower() != 'id']
         if not check_duplicate:
             sql = self._build_simple_insert_sql(db_name, table_name, all_columns,
                                                  update_on_duplicate)
@@ -1364,7 +1403,6 @@ class MySQLUploader:
         - 只有遇到严重的数据库错误（如所有行都因唯一约束冲突且没有ON DUPLICATE KEY UPDATE），才会整体回滚。
         - 返回值为(插入行数, 跳过行数, 失败行数)。
         """
-        import pymysql  # 确保异常类型可用
         def get_optimal_batch_size(total_rows: int) -> int:
             if total_rows <= 100:
                 return total_rows
@@ -1612,5 +1650,5 @@ def main():
 
 
 if __name__ == '__main__':
-    main()
+    # main()
     pass

{mdbq-4.0.3 → mdbq-4.0.5}/mdbq.egg-info/PKG-INFO

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

mdbq-4.0.3/mdbq/__version__.py

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