mdbq 4.0.21__py3-none-any.whl → 4.0.23__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '4.0.21'
+VERSION = '4.0.23'

mdbq/myconf/myconf2.py

@@ -1,24 +1,10 @@
 import re
-from typing import Dict, Any, Optional, Union, List, Tuple, Type, TypeVar, Callable
+from typing import Dict, Any, Optional, Union, List, Tuple, Type, TypeVar
 from pathlib import Path
 from mdbq.log import mylogger
 from dataclasses import dataclass, field
 from enum import Enum
 import time
-import json
-import yaml
-import toml
-import os
-from jsonschema import validate, ValidationError
-from cryptography.fernet import Fernet
-import base64
-from typing_extensions import TypedDict
-import threading
-import queue
-import watchdog.observers
-import watchdog.events
-import jinja2
-from datetime import datetime
 
 logger = mylogger.MyLogger(
     logging_mode='both',
@@ -36,14 +22,7 @@ T = TypeVar('T')  # 类型变量
 
 
 class ConfigError(Exception):
-    """配置相关的基础异常类
-    
-    Attributes:
-        message: 错误消息
-        file_path: 配置文件路径
-        section: 配置节名称
-        key: 配置键名称
-    """
+    """配置相关的基础异常类"""
     def __init__(self, message: str, file_path: Optional[Union[str, Path]] = None, 
                  section: Optional[str] = None, key: Optional[str] = None):
         self.message = message
@@ -65,17 +44,13 @@ class ConfigError(Exception):
 
 
 class ConfigFileNotFoundError(ConfigError):
-    """当指定的配置文件不存在时抛出的异常"""
+    """配置文件不存在异常"""
     def __init__(self, file_path: Union[str, Path]):
         super().__init__("配置文件不存在", file_path=file_path)
 
 
 class ConfigReadError(ConfigError):
-    """当读取配置文件失败时抛出的异常
-    
-    Attributes:
-        original_error: 原始错误对象
-    """
+    """读取配置文件失败异常"""
     def __init__(self, file_path: Union[str, Path], original_error: Exception):
         super().__init__(
             f"读取配置文件失败: {str(original_error)}",
@@ -85,11 +60,7 @@ class ConfigReadError(ConfigError):
 
 
 class ConfigWriteError(ConfigError):
-    """当写入配置文件失败时抛出的异常
-    
-    Attributes:
-        original_error: 原始错误对象
-    """
+    """写入配置文件失败异常"""
     def __init__(self, file_path: Union[str, Path], original_error: Exception):
         super().__init__(
             f"写入配置文件失败: {str(original_error)}",
@@ -99,14 +70,14 @@ class ConfigWriteError(ConfigError):
 
 
 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"配置节不存在",
@@ -116,7 +87,7 @@ class ConfigSectionNotFoundError(ConfigError):
 
 
 class ConfigKeyNotFoundError(ConfigError):
-    """当指定的配置键不存在时抛出的异常"""
+    """配置键不存在异常"""
     def __init__(self, file_path: Union[str, Path], section: str, key: str):
         super().__init__(
             f"配置键不存在",
@@ -133,32 +104,9 @@ class CommentStyle(Enum):
     SEMICOLON = ';'  # INI风格注释
 
 
+@dataclass
 class ConfigOptions:
-    """配置解析器的选项类
-    
-    Attributes:
-        comment_styles: 支持的注释风格列表
-        encoding: 文件编码
-        auto_create: 是否自动创建不存在的配置文件
-        strip_values: 是否去除配置值的首尾空白
-        preserve_comments: 是否保留注释
-        default_section: 默认配置节名称
-        separators: 支持的分隔符列表
-        cache_ttl: 缓存过期时间（秒）
-        validate_keys: 是否验证键名
-        key_pattern: 键名正则表达式模式
-        case_sensitive: 是否区分大小写
-        schema_validation: 是否启用模式验证
-        schema: JSON Schema 模式定义
-        format_handlers: 自定义格式处理器
-        env_prefix: 环境变量前缀
-        env_override: 是否允许环境变量覆盖配置
-        encryption_key: 加密密钥
-        inherit_from: 继承的配置文件路径
-        watch_changes: 是否监视配置文件变化
-        template_vars: 模板变量
-        template_loader: 模板加载器
-    """
+    """配置解析器选项"""
     comment_styles: List[CommentStyle] = field(default_factory=lambda: [CommentStyle.HASH, CommentStyle.DOUBLE_SLASH])
     encoding: str = 'utf-8'
     auto_create: bool = False
@@ -166,80 +114,14 @@ class ConfigOptions:
     preserve_comments: bool = True
     default_section: str = 'DEFAULT'
     separators: List[str] = field(default_factory=lambda: ['=', ':', '：'])
-    cache_ttl: int = 300
+    cache_ttl: int = 300  # 5分钟缓存过期
     validate_keys: bool = True
     key_pattern: str = r'^[a-zA-Z0-9_\-\.]+$'
     case_sensitive: bool = False
-    schema_validation: bool = False
-    schema: Optional[Dict[str, Any]] = None
-    format_handlers: Dict[str, Callable] = field(default_factory=dict)
-    env_prefix: str = 'CONFIG_'
-    env_override: bool = True
-    encryption_key: Optional[bytes] = None
-    inherit_from: Optional[Union[str, Path]] = None
-    watch_changes: bool = False
-    template_vars: Dict[str, Any] = field(default_factory=dict)
-    template_loader: Optional[jinja2.Environment] = None
-
-
-class ConfigValue(TypedDict):
-    """配置值类型定义"""
-    value: Any
-    encrypted: bool
-    source: str  # 'file', 'env', 'default'
-
-
-class ConfigChangeEvent:
-    """配置变更事件"""
-    def __init__(self, file_path: Path, event_type: str, timestamp: float):
-        self.file_path = file_path
-        self.event_type = event_type
-        self.timestamp = timestamp
-
-
-class ConfigChangeHandler(watchdog.events.FileSystemEventHandler):
-    """配置文件变更处理器"""
-    def __init__(self, parser: 'ConfigParser'):
-        self.parser = parser
-        self.event_queue = queue.Queue()
-
-    def on_modified(self, event):
-        if not event.is_directory:
-            self.event_queue.put(ConfigChangeEvent(
-                Path(event.src_path),
-                'modified',
-                time.time()
-            ))
-
-    def on_created(self, event):
-        if not event.is_directory:
-            self.event_queue.put(ConfigChangeEvent(
-                Path(event.src_path),
-                'created',
-                time.time()
-            ))
-
-    def on_deleted(self, event):
-        if not event.is_directory:
-            self.event_queue.put(ConfigChangeEvent(
-                Path(event.src_path),
-                'deleted',
-                time.time()
-            ))
 
 
 class ConfigParser:
-    """配置文件解析器，用于读取和写入配置文件
-    
-    Attributes:
-        options: 解析器配置选项
-        _config_cache: 配置缓存，用于存储已读取的配置
-        _cache_timestamps: 缓存时间戳，用于管理缓存过期
-        _comments_cache: 注释缓存，用于存储每个配置节的注释
-        _section_map: 用于存储大小写映射
-        _current_file: 当前正在处理的文件路径
-        _format_handlers: 自定义格式处理器
-    """
+    """配置文件解析器"""
     
     def __init__(self, options: Optional[ConfigOptions] = None):
         self.options = options or ConfigOptions()
@@ -248,62 +130,17 @@ class ConfigParser:
         self._comments_cache: Dict[str, Dict[str, List[str]]] = {}
         self._section_map: Dict[str, Dict[str, str]] = {}
         self._current_file: Optional[Path] = None
-        self._format_handlers = {
-            'json': self._handle_json,
-            'yaml': self._handle_yaml,
-            'toml': self._handle_toml,
-            **self.options.format_handlers
-        }
-        self._fernet = None
-        if self.options.encryption_key:
-            self._fernet = Fernet(self.options.encryption_key)
-        
-        # 配置监听相关
-        self._observer = None
-        self._change_handler = None
-        self._watch_thread = None
-        self._stop_watching = threading.Event()
-        self._change_callbacks: List[Callable[[ConfigChangeEvent], None]] = []
-        
-        # 模板相关
-        if self.options.template_loader is None:
-            self.options.template_loader = jinja2.Environment(
-                loader=jinja2.FileSystemLoader('.'),
-                autoescape=True
-            )
-
+    
     def __enter__(self) -> 'ConfigParser':
-        """进入上下文管理器
-        
-        Returns:
-            ConfigParser: 返回当前实例
-        """
         return self
 
     def __exit__(self, exc_type: Optional[Type[BaseException]], 
                  exc_val: Optional[BaseException], 
                  exc_tb: Optional[Any]) -> None:
-        """退出上下文管理器
-        
-        Args:
-            exc_type: 异常类型
-            exc_val: 异常值
-            exc_tb: 异常追踪信息
-        """
         self._current_file = None
 
     def open(self, file_path: Union[str, Path]) -> 'ConfigParser':
-        """打开配置文件
-        
-        Args:
-            file_path: 配置文件路径
-            
-        Returns:
-            ConfigParser: 返回当前实例，支持链式调用
-            
-        Raises:
-            ConfigFileNotFoundError: 当配置文件不存在且未启用自动创建时
-        """
+        """打开配置文件"""
         file_path = Path(file_path)
         if not file_path.exists() and not self.options.auto_create:
             raise ConfigFileNotFoundError(file_path)
@@ -311,25 +148,17 @@ class ConfigParser:
         return self
 
     def _ensure_file_open(self) -> None:
-        """确保文件已打开
-        
-        Raises:
-            ConfigError: 当文件未打开时
-        """
+        """确保文件已打开"""
         if self._current_file is None:
             raise ConfigError("未打开任何配置文件，请先调用 open() 方法")
 
     def _is_comment_line(self, line: str) -> bool:
-        """判断一行是否为注释行"""
+        """判断是否为注释行"""
         stripped = line.strip()
         return any(stripped.startswith(style.value) for style in self.options.comment_styles)
     
     def _extract_comment(self, line: str) -> Tuple[str, str]:
-        """从行中提取注释
-        
-        Returns:
-            Tuple[str, str]: (去除注释后的行内容, 注释内容)
-        """
+        """从行中提取注释"""
         for style in self.options.comment_styles:
             comment_match = re.search(fr'\s+{re.escape(style.value)}.*$', line)
             if comment_match:
@@ -337,14 +166,7 @@ class ConfigParser:
         return line.strip(), ''
     
     def _split_key_value(self, line: str) -> Optional[Tuple[str, str]]:
-        """分割配置行为键值对
-        
-        Args:
-            line: 要分割的配置行
-            
-        Returns:
-            Optional[Tuple[str, str]]: 键值对元组，如果无法分割则返回None
-        """
+        """分割配置行为键值对"""
         for sep in self.options.separators:
             if sep in line:
                 key_part, value_part = line.split(sep, 1)
@@ -366,11 +188,8 @@ class ConfigParser:
         return bool(re.match(self.options.key_pattern, key))
     
     def _get_cached_config(self, file_path: str) -> Optional[Dict[str, Any]]:
-        """获取缓存的配置，如果过期则返回None"""
-        if file_path not in self._config_cache:
-            return None
-        
-        if file_path not in self._cache_timestamps:
+        """获取缓存的配置"""
+        if file_path not in self._config_cache or file_path not in self._cache_timestamps:
             return None
         
         if time.time() - self._cache_timestamps[file_path] > self.options.cache_ttl:
@@ -384,10 +203,8 @@ class ConfigParser:
         self._cache_timestamps[file_path] = time.time()
     
     def _normalize_section(self, section: str) -> str:
-        """标准化节名称（处理大小写）"""
-        if self.options.case_sensitive:
-            return section
-        return section.lower()
+        """标准化节名称"""
+        return section if self.options.case_sensitive else section.lower()
     
     def _get_original_section(self, file_path: str, normalized_section: str) -> Optional[str]:
         """获取原始节名称"""
@@ -416,73 +233,50 @@ class ConfigParser:
             self._comments_cache.clear()
             self._section_map.clear()
     
-    def _convert_value(self, value: str, target_type: Type[T]) -> T:
-        """转换配置值到指定类型
-        
-        Args:
-            value: 要转换的值
-            target_type: 目标类型
-            
-        Returns:
-            T: 转换后的值
-            
-        Raises:
-            ConfigValueError: 当值无法转换为指定类型时
-        """
+    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:
                 return bool(value.lower() in ('true', 'yes', '1', 'on'))
             elif target_type == list:
-                # 支持多种分隔符的列表
                 if not value.strip():
                     return []
-                # 尝试不同的分隔符
                 for sep in [',', ';', '|', ' ']:
                     if sep in value:
                         return [item.strip() for item in value.split(sep) if item.strip()]
-                # 如果没有分隔符，则作为单个元素返回
                 return [value.strip()]
             elif target_type == tuple:
-                # 支持元组类型
                 if not value.strip():
                     return ()
-                # 尝试不同的分隔符
                 for sep in [',', ';', '|', ' ']:
                     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:
-                # 支持字典类型，格式：key1=value1,key2=value2
                 if not value.strip():
                     return {}
                 result = {}
-                # 尝试不同的分隔符
                 for sep in [',', ';', '|']:
                     if sep in value:
                         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()
                 if value.startswith('0x'):
                     return int(value, 16)
@@ -499,12 +293,7 @@ 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:
-                # 支持 range 类型，格式：start:stop:step 或 start:stop
                 parts = value.split(':')
                 if len(parts) == 2:
                     return range(int(parts[0]), int(parts[1]))
@@ -515,79 +304,41 @@ class ConfigParser:
         except (ValueError, TypeError) as e:
             raise ConfigValueError(
                 f"无法将值 '{value}' 转换为类型 {target_type.__name__}",
-                file_path=None,
-                key=None
+                file_path=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:
-        """获取指定配置项的值
-        
-        Args:
-            file_path: 配置文件路径，如果为None则使用当前打开的文件
-            key: 配置键
-            section: 配置节名称，如果为None则使用默认节
-            default: 当配置项不存在时返回的默认值
-            value_type: 期望的值的类型
-            
-        Returns:
-            T: 配置值
-            
-        Raises:
-            ConfigSectionNotFoundError: 当指定的节不存在且未提供默认值时
-            ConfigKeyNotFoundError: 当指定的键不存在且未提供默认值时
-            ConfigValueError: 当值无法转换为指定类型时
-        """
+        """获取指定配置项的值"""
         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)
-            
         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)
-            
         if key not in config[original_section]:
             if default is not None:
                 return default
             raise ConfigKeyNotFoundError(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,
                   defaults: Optional[Dict[str, Any]] = None,
                   value_types: Optional[Dict[str, Type]] = None) -> Dict[str, Any]:
-        """批量获取多个配置项的值
-        
-        Args:
-            keys: 配置项列表，每个元素为 (section, key) 元组
-            file_path: 配置文件路径，如果为None则使用当前打开的文件
-            defaults: 默认值字典，格式为 {key: default_value}
-            value_types: 值类型字典，格式为 {key: type}
-            
-        Returns:
-            Dict[str, Any]: 配置值字典，格式为 {key: value}
-            
-        Raises:
-            ConfigSectionNotFoundError: 当指定的节不存在且未提供默认值时
-            ConfigKeyNotFoundError: 当指定的键不存在且未提供默认值时
-            ConfigValueError: 当值无法转换为指定类型时
-        """
+        """批量获取多个配置项的值"""
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -618,23 +369,7 @@ class ConfigParser:
                           file_path: Optional[Union[str, Path]] = None,
                           defaults: Optional[Dict[str, Any]] = None,
                           value_types: Optional[Dict[str, Type]] = None) -> Tuple[Any, ...]:
-        """获取指定节点下多个键的值元组
-        
-        Args:
-            keys: 要获取的键列表
-            section: 配置节名称，默认为 DEFAULT
-            file_path: 配置文件路径，如果为None则使用当前打开的文件
-            defaults: 默认值字典，格式为 {key: default_value}
-            value_types: 值类型字典，格式为 {key: type}
-            
-        Returns:
-            Tuple[Any, ...]: 按键列表顺序返回的值元组
-            
-        Raises:
-            ConfigSectionNotFoundError: 当指定的节不存在且未提供默认值时
-            ConfigKeyNotFoundError: 当指定的键不存在且未提供默认值时
-            ConfigValueError: 当值无法转换为指定类型时
-        """
+        """获取指定节点下多个键的值元组"""
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -664,37 +399,20 @@ class ConfigParser:
                  section: Optional[str] = None,
                  file_path: Optional[Union[str, Path]] = None,
                  value_type: Optional[Type] = None) -> None:
-        """设置指定配置项的值，保持原始文件的格式和注释
-        
-        Args:
-            key: 配置键
-            value: 要设置的值
-            section: 配置节名称，如果为None则使用默认节
-            file_path: 配置文件路径，如果为None则使用当前打开的文件
-            value_type: 值的类型，用于验证和转换
-            
-        Raises:
-            ConfigValueError: 当值无法转换为指定类型时
-            ConfigError: 当其他配置错误发生时
-        """
+        """设置指定配置项的值"""
         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)
-            
-        # 读取原始文件內容
+        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:
@@ -711,576 +429,165 @@ class ConfigParser:
                     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 = {}  # 用于存储每个section使用的分隔符
-                
-                # 解析原始文件，提取格式信息
+                section_separators = {}
                 for line in original_lines:
                     stripped_line = line.strip()
-                    
                     if not stripped_line:
-                        file.write(line)  # 保持空行
+                        file.write(line)
                         continue
-                        
                     if stripped_line.startswith('[') and stripped_line.endswith(']'):
                         current_section = stripped_line[1:-1]
-                        file.write(line)  # 保持节标记的原始格式
+                        file.write(line)
                         continue
-                        
                     if self._is_comment_line(stripped_line):
-                        file.write(line)  # 保持注释的原始格式
+                        file.write(line)
                         continue
-                        
                     key_value = self._split_key_value(stripped_line)
                     if key_value:
                         orig_key, orig_value = key_value
-                        # 检测使用的分隔符
                         for sep in self.options.separators:
                             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 = ''
                             for style in self.options.comment_styles:
                                 comment_match = re.search(fr'\s+{re.escape(style.value)}.*$', line)
                                 if comment_match:
                                     comment = comment_match.group(0)
                                     break
-                            # 写入新值并保留注释
                             file.write(f'{key}{separator}{value}{comment}\n')
                         else:
-                            file.write(line)  # 保持其他行的原始格式
+                            file.write(line)
                     else:
-                        file.write(line)  # 保持无法解析的行的原始格式
-                
-                # 如果section不存在，则添加新的section
+                        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)
     
-    def _handle_json(self, content: str) -> Dict[str, Any]:
-        """处理 JSON 格式的配置"""
-        return json.loads(content)
-
-    def _handle_yaml(self, content: str) -> Dict[str, Any]:
-        """处理 YAML 格式的配置"""
-        return yaml.safe_load(content)
-
-    def _handle_toml(self, content: str) -> Dict[str, Any]:
-        """处理 TOML 格式的配置"""
-        return toml.loads(content)
-
-    def _validate_schema(self, config: Dict[str, Any]) -> None:
-        """验证配置是否符合模式定义"""
-        if not self.options.schema_validation or not self.options.schema:
-            return
-        try:
-            validate(instance=config, schema=self.options.schema)
-        except ValidationError as e:
-            raise ConfigValueError(
-                f"配置验证失败: {str(e)}",
-                file_path=self._current_file
-            )
-
-    def _encrypt_value(self, value: str) -> str:
-        """加密配置值"""
-        if not self._fernet:
-            return value
-        return base64.b64encode(self._fernet.encrypt(value.encode())).decode()
-
-    def _decrypt_value(self, value: str) -> str:
-        """解密配置值"""
-        if not self._fernet:
-            return value
-        try:
-            return self._fernet.decrypt(base64.b64decode(value)).decode()
-        except Exception:
-            return value
-
-    def _get_env_value(self, section: str, key: str) -> Optional[str]:
-        """从环境变量获取配置值"""
-        env_key = f"{self.options.env_prefix}{section}_{key}".upper()
-        return os.environ.get(env_key)
-
-    def _merge_configs(self, base_config: Dict[str, Any], override_config: Dict[str, Any]) -> Dict[str, Any]:
-        """合并配置，支持深度合并"""
-        result = base_config.copy()
-        for section, items in override_config.items():
-            if section not in result:
-                result[section] = {}
-            for key, value in items.items():
-                if isinstance(value, dict) and isinstance(result[section].get(key), dict):
-                    result[section][key] = self._merge_configs(result[section][key], value)
-                else:
-                    result[section][key] = value
-        return result
-
-    def _process_template(self, content: str) -> str:
-        """处理配置模板"""
-        template = self.options.template_loader.from_string(content)
-        return template.render(
-            **self.options.template_vars,
-            now=datetime.now,
-            env=os.environ
-        )
-
-    def watch(self, callback: Callable[[ConfigChangeEvent], None]) -> None:
-        """开始监视配置文件变化
-        
-        Args:
-            callback: 配置变更回调函数
-        """
-        if not self.options.watch_changes:
-            return
-
-        self._change_callbacks.append(callback)
-        
-        if self._observer is None:
-            self._observer = watchdog.observers.Observer()
-            self._change_handler = ConfigChangeHandler(self)
-            
-            if self._current_file:
-                self._observer.schedule(
-                    self._change_handler,
-                    str(self._current_file.parent),
-                    recursive=False
-                )
-            
-            self._observer.start()
-            
-            def watch_loop():
-                while not self._stop_watching.is_set():
-                    try:
-                        event = self._change_handler.event_queue.get(timeout=1)
-                        if event.file_path == self._current_file:
-                            self._clear_cache(str(event.file_path))
-                            for callback in self._change_callbacks:
-                                callback(event)
-                    except queue.Empty:
-                        continue
-            
-            self._watch_thread = threading.Thread(target=watch_loop, daemon=True)
-            self._watch_thread.start()
-
-    def stop_watching(self) -> None:
-        """停止监视配置文件变化"""
-        if self._observer:
-            self._stop_watching.set()
-            self._observer.stop()
-            self._observer.join()
-            self._observer = None
-            self._change_handler = None
-            if self._watch_thread:
-                self._watch_thread.join()
-                self._watch_thread = None
-            self._change_callbacks.clear()
-
     def read(self, file_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
-        """读取配置文件内容，支持继承、环境变量覆盖和模板处理"""
+        """读取配置文件内容"""
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
         else:
             file_path = Path(file_path)
-
-        # 检查缓存
+        
         cached_config = self._get_cached_config(str(file_path))
         if cached_config is not None:
             return cached_config
-
-        # 读取基础配置
-        base_config = {}
-        if self.options.inherit_from:
-            base_config = self.read(self.options.inherit_from)
-
+        
         if not file_path.exists():
             if not self.options.auto_create:
                 raise ConfigFileNotFoundError(file_path)
             logger.info(f'配置文件不存在，将创建: {file_path}')
             file_path.parent.mkdir(parents=True, exist_ok=True)
             file_path.touch()
-            return base_config
-
+            return {}
+        
         try:
             with open(file_path, 'r', encoding=self.options.encoding) as file:
-                content = file.read()
-                
-                # 处理模板
-                content = self._process_template(content)
+                config = {}
+                current_section = self.options.default_section
+                section_comments = []
                 
-                # 根据文件扩展名选择处理器
-                suffix = file_path.suffix.lower()
-                if suffix in self._format_handlers:
-                    config = self._format_handlers[suffix](content)
-                else:
-                    # 默认使用 INI 格式处理
-                    config = {}
-                    current_section = self.options.default_section
-                    section_comments = []
-
-                    for line in content.splitlines():
-                        stripped_line = line.strip()
+                for line in file:
+                    stripped_line = line.strip()
+                    
+                    if not stripped_line or self._is_comment_line(stripped_line):
+                        if self.options.preserve_comments:
+                            section_comments.append(line.rstrip())
+                        continue
+                    
+                    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
+                            )
+                        self._update_section_map(str(file_path), current_section)
+                        if current_section not in config:
+                            config[current_section] = {}
+                        if self.options.preserve_comments:
+                            self._comments_cache.setdefault(str(file_path), {}).setdefault(current_section, []).extend(section_comments)
+                            section_comments = []
+                        continue
+                    
+                    key_value = self._split_key_value(stripped_line)
+                    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
+                            )
+                        value, comment = self._extract_comment(value)
                         
-                        if not stripped_line or self._is_comment_line(stripped_line):
-                            if self.options.preserve_comments:
-                                section_comments.append(line.rstrip())
-                            continue
+                        if self.options.strip_values:
+                            value = value.strip()
                         
-                        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
-                                )
-                            self._update_section_map(str(file_path), current_section)
-                            if current_section not in config:
-                                config[current_section] = {}
-                            if self.options.preserve_comments:
-                                self._comments_cache.setdefault(str(file_path), {}).setdefault(current_section, []).extend(section_comments)
-                                section_comments = []
-                            continue
+                        if current_section not in config:
+                            config[current_section] = {}
                         
-                        key_value = self._split_key_value(stripped_line)
-                        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
-                                )
-                            value, comment = self._extract_comment(value)
-                            
-                            if self.options.strip_values:
-                                value = value.strip()
-                            
-                            if current_section not in config:
-                                config[current_section] = {}
-                            
-                            # 检查是否是加密值
-                            if value.startswith('ENC(') and value.endswith(')'):
-                                value = self._decrypt_value(value[4:-1])
-                            
-                            config[current_section][key] = value
-                            if self.options.preserve_comments and comment:
-                                self._comments_cache.setdefault(str(file_path), {}).setdefault(current_section, []).append(comment)
-
-                # 合并基础配置
-                config = self._merge_configs(base_config, config)
-
-                # 应用环境变量覆盖
-                if self.options.env_override:
-                    for section in config:
-                        for key in config[section]:
-                            env_value = self._get_env_value(section, key)
-                            if env_value is not None:
-                                config[section][key] = env_value
-
-                self._validate_schema(config)
+                        config[current_section][key] = value
+                        if self.options.preserve_comments and comment:
+                            self._comments_cache.setdefault(str(file_path), {}).setdefault(current_section, []).append(comment)
+                
                 self._update_cache(str(file_path), config)
                 return config
-
+                
         except Exception as e:
             raise ConfigReadError(file_path, e)
 
-    def write(self, config: Dict[str, Any], file_path: Optional[Union[str, Path]] = None,
-             format: Optional[str] = None, encrypt_values: bool = False) -> None:
-        """写入配置到文件，支持加密敏感值"""
-        if file_path is None:
-            self._ensure_file_open()
-            file_path = self._current_file
-        else:
-            file_path = Path(file_path)
-
-        self._validate_schema(config)
-
-        try:
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-            
-            if format is None:
-                format = file_path.suffix.lower()[1:]
-
-            # 处理需要加密的值
-            if encrypt_values and self._fernet:
-                for section in config:
-                    for key, value in config[section].items():
-                        if isinstance(value, str) and any(sensitive in key.lower() for sensitive in ['password', 'secret', 'key', 'token']):
-                            config[section][key] = f"ENC({self._encrypt_value(value)})"
-            
-            with open(file_path, 'w', encoding=self.options.encoding) as file:
-                if format == 'json':
-                    json.dump(config, file, indent=2, ensure_ascii=False)
-                elif format == 'yaml':
-                    yaml.dump(config, file, allow_unicode=True)
-                elif format == 'toml':
-                    toml.dump(config, file)
-                else:  # 默认使用 INI 格式
-                    for section, items in config.items():
-                        file.write(f'[{section}]\n')
-                        for key, value in items.items():
-                            file.write(f'{key} = {value}\n')
-                        file.write('\n')
-
-            self._clear_cache(str(file_path))
-
-        except Exception as e:
-            raise ConfigWriteError(file_path, e)
-
-    def __del__(self):
-        """析构函数，确保停止监视"""
-        self.stop_watching()
-
 
 def main() -> None:
-    """配置解析器使用示例"""
-    
-    # 示例1：基本使用
-    print("\n=== 示例1：基本使用 ===")
+    """示例用法"""
     config_file = Path('/Users/xigua/spd.txt')
-    
-    with ConfigParser() as parser:
-        parser.open(config_file)
-        host, port, username, password = parser.get_section_values(
+    try:
+        # 方式1：使用上下文管理器
+        with ConfigParser() as parser:
+            parser.open(config_file)
+            host, port, username, password = parser.get_section_values(
+                keys=['host', 'port', 'username', 'password'],
+                section='mysql'
+            )
+            print("方式1结果:", host, port, username, password)
+            parser.set_value('username', 'root', section='mysql')
+            parser.set_value('port', 3306, section='mysql')
+        # 方式2：链式调用
+        parser = ConfigParser()
+        host, port, username, password = parser.open(config_file).get_section_values(
             keys=['host', 'port', 'username', 'password'],
             section='mysql'
         )
-        print("基本配置:", host, port, username, password)
-    
-    # 示例2：使用JSON Schema验证
-    print("\n=== 示例2：使用JSON Schema验证 ===")
-    schema = {
-        "type": "object",
-        "properties": {
-            "database": {
-                "type": "object",
-                "required": ["host", "port", "username", "password"],
-                "properties": {
-                    "host": {"type": "string"},
-                    "port": {"type": "integer"},
-                    "username": {"type": "string"},
-                    "password": {"type": "string"}
-                }
-            }
-        }
-    }
-    
-    options = ConfigOptions(
-        schema_validation=True,
-        schema=schema
-    )
-    
-    with ConfigParser(options) as parser:
-        try:
-            config = parser.read(config_file)
-            print("配置验证通过")
-        except ConfigValueError as e:
-            print(f"配置验证失败: {e}")
-    
-    # 示例3：使用环境变量
-    print("\n=== 示例3：使用环境变量 ===")
-    os.environ['CONFIG_MYSQL_HOST'] = 'env_host'
-    os.environ['CONFIG_MYSQL_PORT'] = '3307'
-    
-    options = ConfigOptions(
-        env_prefix='CONFIG_',
-        env_override=True
-    )
-    
-    with ConfigParser(options) as parser:
-        config = parser.read(config_file)
-        print("环境变量覆盖后的配置:", config['mysql'])
-    
-    # 示例4：配置继承
-    print("\n=== 示例4：配置继承 ===")
-    base_config = Path('/Users/xigua/base_config.ini')
-    child_config = Path('/Users/xigua/child_config.ini')
-    
-    # 创建基础配置
-    with ConfigParser() as parser:
-        parser.write({
-            'database': {
-                'host': 'base_host',
-                'port': '3306',
-                'username': 'base_user'
-            }
-        }, base_config)
-    
-    # 创建子配置
-    options = ConfigOptions(inherit_from=base_config)
-    with ConfigParser(options) as parser:
-        parser.write({
-            'database': {
-                'host': 'child_host',
-                'password': 'child_pass'
-            }
-        }, child_config)
-        
-        # 读取子配置
-        config = parser.read(child_config)
-        print("继承后的配置:", config['database'])
-    
-    # 示例5：配置加密
-    print("\n=== 示例5：配置加密 ===")
-    encryption_key = Fernet.generate_key()
-    options = ConfigOptions(encryption_key=encryption_key)
-    
-    with ConfigParser(options) as parser:
-        # 写入加密配置
-        parser.write({
-            'database': {
-                'host': 'localhost',
-                'port': '3306',
-                'username': 'admin',
-                'password': 'secret123'
-            }
-        }, config_file, encrypt_values=True)
-        
-        # 读取加密配置
-        config = parser.read(config_file)
-        print("解密后的配置:", config['database'])
-    
-    # 示例6：配置模板
-    print("\n=== 示例6：配置模板 ===")
-    template_content = """
-    [database]
-    host = {{ env.DATABASE_HOST | default('localhost') }}
-    port = {{ env.DATABASE_PORT | default(3306) }}
-    username = {{ env.DATABASE_USER | default('root') }}
-    password = {{ env.DATABASE_PASS | default('password') }}
-    
-    [app]
-    name = {{ app_name }}
-    version = {{ version }}
-    debug = {{ debug | default(false) }}
-    """
-    
-    options = ConfigOptions(
-        template_vars={
-            'app_name': 'MyApp',
-            'version': '1.0.0',
-            'debug': True
-        }
-    )
-    
-    with ConfigParser(options) as parser:
-        # 写入模板配置
-        with open(config_file, 'w') as f:
-            f.write(template_content)
-        
-        # 读取处理后的配置
-        config = parser.read(config_file)
-        print("模板处理后的配置:", config)
-    
-    # 示例7：配置监听
-    print("\n=== 示例7：配置监听 ===")
-    options = ConfigOptions(watch_changes=True)
-    
-    def on_config_change(event):
-        print(f"配置已更新: {event.file_path}")
-        print(f"事件类型: {event.event_type}")
-        print(f"时间戳: {event.timestamp}")
-    
-    with ConfigParser(options) as parser:
-        parser.open(config_file)
-        parser.watch(on_config_change)
-        
-        # 模拟配置更新
-        time.sleep(1)
-        with open(config_file, 'a') as f:
-            f.write("\n[new_section]\nkey = value\n")
-        
-        # 等待事件处理
-        time.sleep(2)
-        parser.stop_watching()
-    
-    # 示例8：多格式支持
-    print("\n=== 示例8：多格式支持 ===")
-    config_data = {
-        'database': {
-            'host': 'localhost',
-            'port': 3306,
-            'username': 'admin',
-            'password': 'secret123'
-        }
-    }
-    
-    with ConfigParser() as parser:
-        # 写入不同格式
-        formats = ['json', 'yaml', 'toml', 'ini']
-        for fmt in formats:
-            file_path = config_file.with_suffix(f'.{fmt}')
-            parser.write(config_data, file_path, format=fmt)
-            print(f"\n{fmt.upper()} 格式配置:")
-            print(parser.read(file_path))
-    
-    # 示例9：自定义格式处理器
-    print("\n=== 示例9：自定义格式处理器 ===")
-    def handle_custom(content: str) -> Dict[str, Any]:
-        """自定义格式处理器示例"""
-        result = {}
-        for line in content.splitlines():
-            if ':' in line:
-                key, value = line.split(':', 1)
-                result[key.strip()] = value.strip()
-        return result
-    
-    options = ConfigOptions(
-        format_handlers={'custom': handle_custom}
-    )
-    
-    with ConfigParser(options) as parser:
-        # 写入自定义格式
-        custom_content = """
-        host: localhost
-        port: 3306
-        username: admin
-        password: secret123
-        """
-        
-        custom_file = config_file.with_suffix('.custom')
-        with open(custom_file, 'w') as f:
-            f.write(custom_content)
-        
-        # 读取自定义格式
-        config = parser.read(custom_file)
-        print("自定义格式配置:", config)
-    
-    # 清理测试文件
-    for fmt in ['json', 'yaml', 'toml', 'ini', 'custom']:
-        test_file = config_file.with_suffix(f'.{fmt}')
-        if test_file.exists():
-            test_file.unlink()
-    
-    if base_config.exists():
-        base_config.unlink()
-    if child_config.exists():
-        child_config.unlink()
+        print("\n方式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']
+        )
+        print("\n方式3结果:", host, port, username, password)
+    except Exception as e:
+        print(f"配置文件操作异常: {e}")
 
 
 if __name__ == '__main__':

{mdbq-4.0.21.dist-info → mdbq-4.0.23.dist-info}/METADATA

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

{mdbq-4.0.21.dist-info → mdbq-4.0.23.dist-info}/RECORD

@@ -1,12 +1,12 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=POcSq32A6Q7oc-1rHdGErwirhk3WzNRY2_p6GmzXs2k,18
+mdbq/__version__.py,sha256=DL1LeguYb9YeIqFpwczMwHkRTX7qAUfv5A5WC00M-Po,18
 mdbq/aggregation/__init__.py,sha256=EeDqX2Aml6SPx8363J-v1lz0EcZtgwIBYyCJV6CcEDU,40
 mdbq/aggregation/query_data.py,sha256=hdaB0vPh5BcTu9kLViRvM7OAE0b07D4jzAIipqxGI-I,166757
 mdbq/log/__init__.py,sha256=Mpbrav0s0ifLL7lVDAuePEi1hJKiSHhxcv1byBKDl5E,15
 mdbq/log/mylogger.py,sha256=9w_o5mYB3FooIxobq_lSa6oCYTKIhPxDFox-jeLtUHI,21714
 mdbq/myconf/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/myconf/myconf.py,sha256=39tLUBVlWQZzQfrwk7YoLEfipo11fpwWjaLBHcUt2qM,33341
-mdbq/myconf/myconf2.py,sha256=m9c_12hCuO93vhOGTArl8DUFbOawC34qLddnfI0Ho50,50110
+mdbq/myconf/myconf2.py,sha256=LQPNO5c9uATglZ1IrOgGslj6aSuAfpBXgHnPwvCrHmA,25482
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
 mdbq/mysql/deduplicator.py,sha256=kAnkI_vnN8CchgDQAFzeh0M0vLXE2oWq9SfDPNZZ3v0,73215
 mdbq/mysql/mysql.py,sha256=pDg771xBugCMSTWeskIFTi3pFLgaqgyG3smzf-86Wn8,56772
@@ -25,7 +25,7 @@ mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
 mdbq/redis/getredis.py,sha256=vpBuNc22uj9Vr-_Dh25_wpwWM1e-072EAAIBdB_IpL0,23494
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
 mdbq/spider/aikucun.py,sha256=juOqpr_dHeE1RyjCu67VcpzoJAWMO7FKv0i8KiH8WUo,21552
-mdbq-4.0.21.dist-info/METADATA,sha256=yGoEmdb_8T9J-IZkRJeAq3Ka9-m-PsK2XQ5oX_Yxi3Q,364
-mdbq-4.0.21.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mdbq-4.0.21.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-4.0.21.dist-info/RECORD,,
+mdbq-4.0.23.dist-info/METADATA,sha256=Dx9QagRQoN_ttdDOi6RnTKDgSzfqBqn0bp7ozDrZq7Q,364
+mdbq-4.0.23.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mdbq-4.0.23.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-4.0.23.dist-info/RECORD,,