mdbq 4.0.22__tar.gz → 4.0.24__tar.gz

{mdbq-4.0.22 → mdbq-4.0.24}/PKG-INFO

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

mdbq-4.0.24/mdbq/__version__.py

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

mdbq-4.0.22/mdbq/myconf/myconf2.py → mdbq-4.0.24/mdbq/myconf/myconf.py

@@ -21,14 +21,16 @@ logger = mylogger.MyLogger(
 T = TypeVar('T')  # 类型变量
 
 
-class ConfigError(Exception):
-    """配置相关的基础异常类"""
+class ConfigException(Exception):
+    """配置异常基类"""
     def __init__(self, message: str, file_path: Optional[Union[str, Path]] = None, 
-                 section: Optional[str] = None, key: Optional[str] = None):
+                 section: Optional[str] = None, key: Optional[str] = None,
+                 original_error: Optional[Exception] = None):
         self.message = message
         self.file_path = str(file_path) if file_path else None
         self.section = section
         self.key = key
+        self.original_error = original_error
         super().__init__(self._format_message())
 
     def _format_message(self) -> str:
@@ -40,62 +42,69 @@ class ConfigError(Exception):
             parts.append(f"节: [{self.section}]")
         if self.key:
             parts.append(f"键: {self.key}")
+        if self.original_error:
+            parts.append(f"原始错误: {str(self.original_error)}")
         return " | ".join(parts)
 
-
-class ConfigFileNotFoundError(ConfigError):
-    """配置文件不存在异常"""
-    def __init__(self, file_path: Union[str, Path]):
-        super().__init__("配置文件不存在", file_path=file_path)
-
-
-class ConfigReadError(ConfigError):
-    """读取配置文件失败异常"""
-    def __init__(self, file_path: Union[str, Path], original_error: Exception):
-        super().__init__(
-            f"读取配置文件失败: {str(original_error)}",
-            file_path=file_path
-        )
-        self.original_error = original_error
-
-
-class ConfigWriteError(ConfigError):
-    """写入配置文件失败异常"""
-    def __init__(self, file_path: Union[str, Path], original_error: Exception):
-        super().__init__(
-            f"写入配置文件失败: {str(original_error)}",
-            file_path=file_path
-        )
-        self.original_error = original_error
-
-
-class ConfigValueError(ConfigError):
-    """配置值无效异常"""
-    def __init__(self, message: str, file_path: Union[str, Path], 
-                 section: Optional[str] = None, key: Optional[str] = None):
-        super().__init__(message, file_path=file_path, section=section, key=key)
-
-
-class ConfigSectionNotFoundError(ConfigError):
-    """配置节不存在异常"""
-    def __init__(self, file_path: Union[str, Path], section: str):
-        super().__init__(
-            f"配置节不存在",
-            file_path=file_path,
-            section=section
-        )
-
-
-class ConfigKeyNotFoundError(ConfigError):
-    """配置键不存在异常"""
-    def __init__(self, file_path: Union[str, Path], section: str, key: str):
-        super().__init__(
-            f"配置键不存在",
+    @classmethod
+    def file_not_found(cls, file_path: Union[str, Path]) -> 'ConfigException':
+        """配置文件不存在异常"""
+        return cls("配置文件不存在", file_path=file_path)
+
+    @classmethod
+    def read_error(cls, file_path: Union[str, Path], error: Exception) -> 'ConfigException':
+        """读取配置文件失败异常"""
+        return cls("读取配置文件失败", file_path=file_path, original_error=error)
+
+    @classmethod
+    def write_error(cls, file_path: Union[str, Path], error: Exception) -> 'ConfigException':
+        """写入配置文件失败异常"""
+        return cls("写入配置文件失败", file_path=file_path, original_error=error)
+
+    @classmethod
+    def value_error(cls, message: str, file_path: Union[str, Path], 
+                   section: Optional[str] = None, key: Optional[str] = None) -> 'ConfigException':
+        """配置值无效异常"""
+        return cls(message, file_path=file_path, section=section, key=key)
+
+    @classmethod
+    def section_not_found(cls, file_path: Union[str, Path], section: str) -> 'ConfigException':
+        """配置节不存在异常"""
+        return cls("配置节不存在", file_path=file_path, section=section)
+
+    @classmethod
+    def key_not_found(cls, file_path: Union[str, Path], section: str, key: str) -> 'ConfigException':
+        """配置键不存在异常"""
+        return cls("配置键不存在", file_path=file_path, section=section, key=key)
+
+    @classmethod
+    def validation_error(cls, message: str, file_path: Union[str, Path],
+                        section: Optional[str] = None, key: Optional[str] = None) -> 'ConfigException':
+        """配置验证失败异常"""
+        return cls(f"配置验证失败: {message}", file_path=file_path, section=section, key=key)
+
+    @classmethod
+    def conversion_error(cls, value: Any, target_type: Type, file_path: Union[str, Path],
+                        section: Optional[str] = None, key: Optional[str] = None) -> 'ConfigException':
+        """类型转换失败异常"""
+        return cls(
+            f"无法将值 '{value}' 转换为类型 {target_type.__name__}",
             file_path=file_path,
             section=section,
             key=key
         )
 
+    @classmethod
+    def invalid_key_error(cls, key: str, file_path: Union[str, Path],
+                         section: Optional[str] = None) -> 'ConfigException':
+        """无效的键名异常"""
+        return cls(f"无效的键名: {key}", file_path=file_path, section=section, key=key)
+
+    @classmethod
+    def invalid_section_error(cls, section: str, file_path: Union[str, Path]) -> 'ConfigException':
+        """无效的节名异常"""
+        return cls(f"无效的节名: {section}", file_path=file_path, section=section)
+
 
 class CommentStyle(Enum):
     """配置文件支持的注释风格"""
@@ -143,14 +152,14 @@ class ConfigParser:
         """打开配置文件"""
         file_path = Path(file_path)
         if not file_path.exists() and not self.options.auto_create:
-            raise ConfigFileNotFoundError(file_path)
+            raise ConfigException.file_not_found(file_path)
         self._current_file = file_path
         return self
 
     def _ensure_file_open(self) -> None:
         """确保文件已打开"""
         if self._current_file is None:
-            raise ConfigError("未打开任何配置文件，请先调用 open() 方法")
+            raise ConfigException("未打开任何配置文件，请先调用 open() 方法")
 
     def _is_comment_line(self, line: str) -> bool:
         """判断是否为注释行"""
@@ -204,7 +213,7 @@ class ConfigParser:
     
     def _normalize_section(self, section: str) -> str:
         """标准化节名称"""
-        return section if self.options.case_sensitive else section.lower()
+        return section.replace(' ', '').lower()
     
     def _get_original_section(self, file_path: str, normalized_section: str) -> Optional[str]:
         """获取原始节名称"""
@@ -233,7 +242,7 @@ class ConfigParser:
             self._comments_cache.clear()
             self._section_map.clear()
     
-    def _convert_value(self, value: str, target_type: Type[T]) -> T:
+    def _convert_value(self, value: str, target_type: Type[T], file_path: Optional[Union[str, Path]] = None, key: Optional[str] = None) -> T:
         """转换配置值到指定类型"""
         try:
             if target_type == bool:
@@ -252,13 +261,14 @@ class ConfigParser:
                     if sep in value:
                         return tuple(item.strip() for item in value.split(sep) if item.strip())
                 return (value.strip(),)
-            elif target_type == set:
+            elif target_type == set or target_type == frozenset:
                 if not value.strip():
-                    return set()
+                    return set() if target_type == set else frozenset()
                 for sep in [',', ';', '|', ' ']:
                     if sep in value:
-                        return {item.strip() for item in value.split(sep) if item.strip()}
-                return {value.strip()}
+                        items = [item.strip() for item in value.split(sep) if item.strip()]
+                        return set(items) if target_type == set else frozenset(items)
+                return set([value.strip()]) if target_type == set else frozenset([value.strip()])
             elif target_type == dict:
                 if not value.strip():
                     return {}
@@ -268,12 +278,12 @@ class ConfigParser:
                         pairs = [pair.strip() for pair in value.split(sep) if pair.strip()]
                         for pair in pairs:
                             if '=' in pair:
-                                key, val = pair.split('=', 1)
-                                result[key.strip()] = val.strip()
+                                key_, val = pair.split('=', 1)
+                                result[key_.strip()] = val.strip()
                         return result
                 if '=' in value:
-                    key, val = value.split('=', 1)
-                    return {key.strip(): val.strip()}
+                    key_, val = value.split('=', 1)
+                    return {key_.strip(): val.strip()}
                 return {}
             elif target_type == int:
                 value = value.strip().lower()
@@ -292,10 +302,6 @@ class ConfigParser:
                 return value.encode('utf-8')
             elif target_type == bytearray:
                 return bytearray(value.encode('utf-8'))
-            elif target_type == set:
-                return set(value.split(','))
-            elif target_type == frozenset:
-                return frozenset(value.split(','))
             elif target_type == range:
                 parts = value.split(':')
                 if len(parts) == 2:
@@ -305,48 +311,38 @@ class ConfigParser:
                 raise ValueError("Invalid range format")
             return target_type(value)
         except (ValueError, TypeError) as e:
-            raise ConfigValueError(
-                f"无法将值 '{value}' 转换为类型 {target_type.__name__}",
-                file_path=None,
-                key=None
-            )
+            raise ConfigException.conversion_error(value, target_type, file_path, key=key)
     
-    def get_value(self, file_path: Optional[Union[str, Path]] = None, key: str = None, 
-                 section: Optional[str] = None, default: Any = None,
-                 value_type: Optional[Type[T]] = None) -> T:
+    def get_value(self, section: Optional[str] = None, key: str = None,
+                 default: Any = None, value_type: Optional[Type[T]] = None,
+                 file_path: Optional[Union[str, Path]] = None) -> T:
         """获取指定配置项的值"""
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
         if not self._validate_key(key):
-            raise ConfigValueError(f"无效的键名: {key}", file_path=file_path, key=key)
-            
+            raise ConfigException.invalid_key_error(key, file_path, section)
         config = self.read(file_path)
         section = section or self.options.default_section
         normalized_section = self._normalize_section(section)
-        
         original_section = self._get_original_section(str(file_path), normalized_section)
         if original_section is None:
             if default is not None:
                 return default
-            raise ConfigSectionNotFoundError(file_path, section)
-            
+            raise ConfigException.section_not_found(file_path, section)
         if key not in config[original_section]:
             if default is not None:
                 return default
-            raise ConfigKeyNotFoundError(file_path, original_section, key)
-            
+            raise ConfigException.key_not_found(file_path, original_section, key)
         value = config[original_section][key]
-        
         if value_type is not None:
-            return self._convert_value(value, value_type)
-            
+            return self._convert_value(value, value_type, file_path=file_path, key=key)
         return value
     
-    def get_values(self, keys: List[Tuple[str, str]], 
-                  file_path: Optional[Union[str, Path]] = None,
+    def get_values(self, section: Optional[str] = None, keys: List[Tuple[str, str]] = None,
                   defaults: Optional[Dict[str, Any]] = None,
-                  value_types: Optional[Dict[str, Type]] = None) -> Dict[str, Any]:
+                  value_types: Optional[Dict[str, Type]] = None,
+                  file_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
         """批量获取多个配置项的值"""
         if file_path is None:
             self._ensure_file_open()
@@ -358,14 +354,15 @@ class ConfigParser:
         for section, key in keys:
             try:
                 value = self.get_value(
-                    file_path=file_path,
-                    key=key,
                     section=section,
+                    key=key,
                     default=defaults.get(key),
-                    value_type=value_types.get(key)
+                    value_type=value_types.get(key),
+                    file_path=file_path
                 )
                 result[key] = value
-            except (ConfigSectionNotFoundError, ConfigKeyNotFoundError) as e:
+            except ConfigException as e:
+                logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
                 if key in defaults:
                     result[key] = defaults[key]
                 else:
@@ -373,11 +370,10 @@ class ConfigParser:
                     
         return result
 
-    def get_section_values(self, keys: List[str],
-                          section: Optional[str] = None,
-                          file_path: Optional[Union[str, Path]] = None,
+    def get_section_values(self, section: Optional[str] = None, keys: List[str] = None,
                           defaults: Optional[Dict[str, Any]] = None,
-                          value_types: Optional[Dict[str, Type]] = None) -> Tuple[Any, ...]:
+                          value_types: Optional[Dict[str, Type]] = None,
+                          file_path: Optional[Union[str, Path]] = None) -> Tuple[Any, ...]:
         """获取指定节点下多个键的值元组"""
         if file_path is None:
             self._ensure_file_open()
@@ -389,14 +385,15 @@ class ConfigParser:
         for key in keys:
             try:
                 value = self.get_value(
-                    file_path=file_path,
-                    key=key,
                     section=section,
+                    key=key,
                     default=defaults.get(key),
-                    value_type=value_types.get(key)
+                    value_type=value_types.get(key),
+                    file_path=file_path
                 )
                 result.append(value)
-            except (ConfigSectionNotFoundError, ConfigKeyNotFoundError) as e:
+            except ConfigException as e:
+                logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
                 if key in defaults:
                     result.append(defaults[key])
                 else:
@@ -404,27 +401,23 @@ class ConfigParser:
                     
         return tuple(result)
     
-    def set_value(self, key: str, value: Any,
-                 section: Optional[str] = None,
-                 file_path: Optional[Union[str, Path]] = None,
-                 value_type: Optional[Type] = None) -> None:
+    def set_value(self, section: Optional[str] = None, key: str = None, value: Any = None,
+                 value_type: Optional[Type] = None,
+                 file_path: Optional[Union[str, Path]] = None) -> None:
         """设置指定配置项的值"""
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
         if not self._validate_key(key):
-            raise ConfigValueError(f"无效的键名: {key}", file_path=file_path, key=key)
-            
+            raise ConfigException.invalid_key_error(key, file_path, section)
+        section = section or self.options.default_section
         original_lines = []
         if file_path.exists():
             with open(file_path, 'r', encoding=self.options.encoding) as file:
                 original_lines = file.readlines()
-        
         config = self.read(file_path)
-        
         if section not in config:
             config[section] = {}
-            
         if value_type is not None:
             try:
                 if value_type == bool:
@@ -435,43 +428,29 @@ class ConfigParser:
                 else:
                     value = value_type(value)
             except (ValueError, TypeError) as e:
-                raise ConfigValueError(
-                    f"无法将值 '{value}' 转换为类型 {value_type.__name__}",
-                    file_path=file_path,
-                    section=section,
-                    key=key
-                )
-        
+                raise ConfigException.conversion_error(value, value_type, file_path, section=section, key=key)
         if isinstance(value, bool):
             value = str(value).lower()
         else:
             value = str(value)
-            
         config[section][key] = value
-        
         try:
             file_path.parent.mkdir(parents=True, exist_ok=True)
-            
             with open(file_path, 'w', encoding=self.options.encoding) as file:
                 current_section = self.options.default_section
                 section_separators = {}
-                
                 for line in original_lines:
                     stripped_line = line.strip()
-                    
                     if not stripped_line:
                         file.write(line)
                         continue
-                        
                     if stripped_line.startswith('[') and stripped_line.endswith(']'):
                         current_section = stripped_line[1:-1]
                         file.write(line)
                         continue
-                        
                     if self._is_comment_line(stripped_line):
                         file.write(line)
                         continue
-                        
                     key_value = self._split_key_value(stripped_line)
                     if key_value:
                         orig_key, orig_value = key_value
@@ -479,7 +458,6 @@ class ConfigParser:
                             if sep in line:
                                 section_separators.setdefault(current_section, {})[orig_key] = sep
                                 break
-                        
                         if current_section == section and orig_key == key:
                             separator = section_separators.get(current_section, {}).get(orig_key, self.options.separators[0])
                             comment = ''
@@ -493,15 +471,47 @@ class ConfigParser:
                             file.write(line)
                     else:
                         file.write(line)
-                
                 if section not in [line.strip()[1:-1] for line in original_lines if line.strip().startswith('[') and line.strip().endswith(']')]:
                     file.write(f'\n[{section}]\n')
                     file.write(f'{key}={value}\n')
-            
             self._clear_cache(str(file_path))
-            
         except Exception as e:
-            raise ConfigWriteError(file_path, 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:
+        """批量设置多个配置项的值"""
+        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)
+
+    def validate_config(self, section: Optional[str] = None, schema: Dict[str, Type] = None,
+                       file_path: Optional[Union[str, Path]] = None) -> bool:
+        """验证配置是否符合指定的模式"""
+        config = self.read(file_path)
+        if section:
+            if section not in config:
+                return False
+            for key, expected_type in schema.items():
+                if key not in config[section]:
+                    return False
+                try:
+                    self._convert_value(config[section][key], expected_type)
+                except ConfigException:
+                    return False
+        else:
+            for section, keys in schema.items():
+                if section not in config:
+                    return False
+                for key, expected_type in keys.items():
+                    if key not in config[section]:
+                        return False
+                    try:
+                        self._convert_value(config[section][key], expected_type)
+                    except ConfigException:
+                        return False
+        return True
     
     def read(self, file_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
         """读取配置文件内容"""
@@ -517,7 +527,7 @@ class ConfigParser:
         
         if not file_path.exists():
             if not self.options.auto_create:
-                raise ConfigFileNotFoundError(file_path)
+                raise ConfigException.file_not_found(file_path)
             logger.info(f'配置文件不存在，将创建: {file_path}')
             file_path.parent.mkdir(parents=True, exist_ok=True)
             file_path.touch()
@@ -540,11 +550,7 @@ class ConfigParser:
                     if stripped_line.startswith('[') and stripped_line.endswith(']'):
                         current_section = stripped_line[1:-1]
                         if not self._validate_key(current_section):
-                            raise ConfigValueError(
-                                f"无效的节名: {current_section}",
-                                file_path=file_path,
-                                section=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:
                             config[current_section] = {}
@@ -557,12 +563,7 @@ class ConfigParser:
                     if key_value:
                         key, value = key_value
                         if not self._validate_key(key):
-                            raise ConfigValueError(
-                                f"无效的键名: {key}",
-                                file_path=file_path,
-                                section=current_section,
-                                key=key
-                            )
+                            raise ConfigException.invalid_key_error(key, file_path, current_section)
                         value, comment = self._extract_comment(value)
                         
                         if self.options.strip_values:
@@ -579,42 +580,141 @@ class ConfigParser:
                 return config
                 
         except Exception as e:
-            raise ConfigReadError(file_path, e)
+            raise ConfigException.read_error(file_path, e)
 
 
 def main() -> None:
     """示例用法"""
-    config_file = Path('/Users/xigua/spd.txt')
-    
+    config_file = Path('/Users/xigua/spd_副本.txt')
+
+    # 创建配置解析器实例
+    parser = ConfigParser()
+    # 设置配置选项
+    options = ConfigOptions(
+        comment_styles=[CommentStyle.HASH, CommentStyle.DOUBLE_SLASH],
+        encoding='utf-8',
+        auto_create=True,
+        strip_values=True,
+        preserve_comments=True,
+        default_section='DEFAULT',
+        separators=['=', ':', '：'],
+        cache_ttl=300,
+        validate_keys=True,
+        key_pattern=r'^[a-zA-Z0-9_\-\.]+$',
+        case_sensitive=False
+    )
+    parser = ConfigParser(options)
+
     # 方式1：使用上下文管理器
     with ConfigParser() as parser:
         parser.open(config_file)
+        # 读取配置 - 最常用的参数放在前面
         host, port, username, password = parser.get_section_values(
-            keys=['host', 'port', 'username', 'password'],
-            section='mysql'
+            section='mysql',  # 最常用的section参数放在前面
+            keys=['host', 'port', 'username', 'password']
         )
-        print("方式1结果:", host, port, username, password)
-        
-        parser.set_value('username', 'root', section='mysql')
-        parser.set_value('port', 3306, section='mysql')
-    
+        print("2.1 使用上下文管理器 读取结果:", host, port, username, password)
+        # 修改配置
+        parser.set_value(
+            section='mysql',
+            key='username',
+            value='root'
+        )
+        parser.set_value(
+            section='mysql',
+            key='port',
+            value=3306,
+            value_type=int
+        )
+
     # 方式2：链式调用
     parser = ConfigParser()
     host, port, username, password = parser.open(config_file).get_section_values(
-        keys=['host', 'port', 'username', 'password'],
-        section='mysql'
+        section='mysql',
+        keys=['host', 'port', 'username', 'password']
     )
-    print("\n方式2结果:", host, port, username, password)
-    
+    print("2.2 链式调用 读取结果:", host, port, username, password)
+
     # 方式3：传统方式
     parser = ConfigParser()
     host, port, username, password = parser.get_section_values(
-        file_path=config_file,
         section='mysql',
-        keys=['host', 'port', 'username', 'password']
+        keys=['host', 'port', 'username', 'password'],
+        file_path=config_file  # 文件路径参数放在最后
+    )
+    print("2.3 传统方式 读取结果:", host, port, username, password)
+
+    # 3.1 读取单个值 - 最常用的参数放在前面
+    value = parser.get_value(
+        section='mysql',
+        key='host',
+        default='localhost',  # 默认值参数放在中间
+        value_type=str,
+        file_path=config_file
+    )
+    print("3.1 单个值读取结果:", value)
+
+    # 3.2 批量读取多个值 - 最常用的参数放在前面
+    values = parser.get_values(
+        section='mysql',
+        keys=[('host', 'host'), ('host', 'port')],
+        defaults={'host': 'localhost', 'port': 3306},
+        value_types={'port': int},
+        file_path=config_file
+    )
+    print("3.2 批量读取多个值结果:", values)
+
+    # 3.3 读取整个配置
+    config = parser.read(config_file)
+    print("3.3 读取完整配置:", config)
+
+    # 4.1 写入单个值 - 最常用的参数放在前面
+    parser.set_value(
+        section='mysql',
+        key='host',
+        value='127.0.0.1',
+        value_type=str,
+        file_path=config_file
+    )
+    print("4.1 写入单个值结果:", config_file)
+
+    # 4.2 写入不同类型的数据 - 最常用的参数放在前面
+    parser.open(config_file)
+    parser.set_value(
+        section='mysql',
+        key='port',
+        value=3306,
+        value_type=int
+    )
+    parser.set_value(
+        section='mysql',
+        key='debug',
+        value=True,
+        value_type=bool
+    )
+    parser.set_value(
+        section='mysql',
+        key='servers',
+        value=['server1', 'server2'],
+        value_type=list
     )
-    print("\n方式3结果:", host, port, username, password)
+    print("4.2 写入不同类型的数据")
+
+    try:
+        # 尝试读取不存在的配置项 - 最常用的参数放在前面
+        parser.get_value(
+            section='mysql',
+            key='nonexistent'
+        )
+    except ConfigException as e:
+        if "配置键不存在" in str(e):
+            print("5.1 错误处理 配置键不存在错误:", e)
+        elif "配置节不存在" in str(e):
+            print("5.2 错误处理 配置节不存在错误:", e)
+        else:
+            print("5.3 错误处理 配置错误:", e)
 
 
 if __name__ == '__main__':
     main()
+

{mdbq-4.0.22 → mdbq-4.0.24}/mdbq.egg-info/PKG-INFO

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

{mdbq-4.0.22 → mdbq-4.0.24}/mdbq.egg-info/SOURCES.txt

@@ -12,7 +12,7 @@ mdbq/log/__init__.py
 mdbq/log/mylogger.py
 mdbq/myconf/__init__.py
 mdbq/myconf/myconf.py
-mdbq/myconf/myconf2.py
+mdbq/myconf/myconf_bak.py
 mdbq/mysql/__init__.py
 mdbq/mysql/deduplicator.py
 mdbq/mysql/mysql.py

mdbq-4.0.22/mdbq/__version__.py

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