auto-coder 0.1.397__py3-none-any.whl → 0.1.399__py3-none-any.whl

autocoder/common/conversations/config.py

@@ -0,0 +1,195 @@
+"""
+PersistConversationManager 配置类定义
+"""
+
+import os
+import json
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+from copy import deepcopy
+
+
+@dataclass
+class ConversationManagerConfig:
+    """对话管理器配置类"""
+    
+    storage_path: str = "./.auto-coder/conversations"
+    max_cache_size: int = 100
+    cache_ttl: float = 300.0
+    lock_timeout: float = 10.0
+    backup_enabled: bool = True
+    backup_interval: float = 3600.0
+    max_backups: int = 10
+    enable_compression: bool = False
+    log_level: str = "INFO"
+    
+    def __post_init__(self):
+        """配置验证"""
+        self._validate()
+    
+    def _validate(self):
+        """验证配置数据"""
+        # 验证存储路径
+        if not self.storage_path or not isinstance(self.storage_path, str):
+            raise ValueError("存储路径不能为空")
+        
+        # 验证缓存大小
+        if not isinstance(self.max_cache_size, int) or self.max_cache_size <= 0:
+            raise ValueError("缓存大小必须是正整数")
+        
+        # 验证缓存TTL
+        if not isinstance(self.cache_ttl, (int, float)) or self.cache_ttl <= 0:
+            raise ValueError("缓存TTL必须是正数")
+        
+        # 验证锁超时
+        if not isinstance(self.lock_timeout, (int, float)) or self.lock_timeout <= 0:
+            raise ValueError("锁超时时间必须是正数")
+        
+        # 验证备份间隔
+        if not isinstance(self.backup_interval, (int, float)) or self.backup_interval <= 0:
+            raise ValueError("备份间隔必须是正数")
+        
+        # 验证最大备份数
+        if not isinstance(self.max_backups, int) or self.max_backups <= 0:
+            raise ValueError("最大备份数必须是正整数")
+        
+        # 验证日志级别
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if self.log_level not in valid_levels:
+            raise ValueError(f"无效的日志级别: {self.log_level}，有效级别: {valid_levels}")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return {
+            "storage_path": self.storage_path,
+            "max_cache_size": self.max_cache_size,
+            "cache_ttl": self.cache_ttl,
+            "lock_timeout": self.lock_timeout,
+            "backup_enabled": self.backup_enabled,
+            "backup_interval": self.backup_interval,
+            "max_backups": self.max_backups,
+            "enable_compression": self.enable_compression,
+            "log_level": self.log_level
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ConversationManagerConfig":
+        """从字典创建配置"""
+        # 创建默认配置
+        config = cls()
+        
+        # 更新配置字段
+        for key, value in data.items():
+            if hasattr(config, key):
+                setattr(config, key, value)
+        
+        # 重新验证
+        config._validate()
+        
+        return config
+    
+    @classmethod
+    def from_env(cls, prefix: str = "CONVERSATION_") -> "ConversationManagerConfig":
+        """从环境变量创建配置"""
+        config = cls()
+        
+        # 环境变量映射
+        env_mapping = {
+            f"{prefix}STORAGE_PATH": "storage_path",
+            f"{prefix}MAX_CACHE_SIZE": "max_cache_size",
+            f"{prefix}CACHE_TTL": "cache_ttl",
+            f"{prefix}LOCK_TIMEOUT": "lock_timeout",
+            f"{prefix}BACKUP_ENABLED": "backup_enabled",
+            f"{prefix}BACKUP_INTERVAL": "backup_interval",
+            f"{prefix}MAX_BACKUPS": "max_backups",
+            f"{prefix}ENABLE_COMPRESSION": "enable_compression",
+            f"{prefix}LOG_LEVEL": "log_level"
+        }
+        
+        for env_key, attr_name in env_mapping.items():
+            env_value = os.environ.get(env_key)
+            if env_value is not None:
+                # 类型转换
+                try:
+                    if attr_name in ["max_cache_size", "max_backups"]:
+                        value = int(env_value)
+                    elif attr_name in ["cache_ttl", "lock_timeout", "backup_interval"]:
+                        value = float(env_value)
+                    elif attr_name in ["backup_enabled", "enable_compression"]:
+                        value = env_value.lower() in ["true", "1", "yes", "on"]
+                    else:
+                        value = env_value
+                    
+                    setattr(config, attr_name, value)
+                except (ValueError, TypeError) as e:
+                    raise ValueError(f"环境变量 {env_key} 的值 '{env_value}' 无效: {e}")
+        
+        # 重新验证
+        config._validate()
+        
+        return config
+    
+    def save_to_file(self, file_path: str):
+        """保存配置到文件"""
+        # 确保目录存在
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(self.to_dict(), f, indent=2, ensure_ascii=False)
+    
+    @classmethod
+    def load_from_file(cls, file_path: str) -> "ConversationManagerConfig":
+        """从文件加载配置"""
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"配置文件不存在: {file_path}")
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            return cls.from_dict(data)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"配置文件格式错误: {e}")
+    
+    def copy(self) -> "ConversationManagerConfig":
+        """创建配置的深拷贝"""
+        return ConversationManagerConfig.from_dict(self.to_dict())
+    
+    def update(self, **kwargs):
+        """更新配置字段"""
+        # 先备份当前配置
+        backup_values = {}
+        for key in kwargs.keys():
+            if hasattr(self, key):
+                backup_values[key] = getattr(self, key)
+            else:
+                raise AttributeError(f"配置类没有属性: {key}")
+        
+        # 尝试更新
+        try:
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+            # 重新验证
+            self._validate()
+        except Exception:
+            # 如果验证失败，恢复原值
+            for key, value in backup_values.items():
+                setattr(self, key, value)
+            raise
+    
+    def __repr__(self) -> str:
+        """字符串表示"""
+        return (f"ConversationManagerConfig("
+                f"storage_path='{self.storage_path}', "
+                f"max_cache_size={self.max_cache_size}, "
+                f"cache_ttl={self.cache_ttl}, "
+                f"lock_timeout={self.lock_timeout}, "
+                f"backup_enabled={self.backup_enabled}, "
+                f"log_level='{self.log_level}')")
+    
+    def __eq__(self, other) -> bool:
+        """相等性比较"""
+        if not isinstance(other, ConversationManagerConfig):
+            return False
+        
+        return self.to_dict() == other.to_dict() 

autocoder/common/conversations/exceptions.py

@@ -0,0 +1,72 @@
+"""
+PersistConversationManager 异常类定义
+"""
+
+
+class ConversationManagerError(Exception):
+    """对话管理器基础异常类"""
+    
+    def __init__(self, message="对话管理器发生错误", error_code="GENERAL_ERROR"):
+        super().__init__(message)
+        self.error_code = error_code
+
+
+class ConversationNotFoundError(ConversationManagerError):
+    """对话不存在异常"""
+    
+    def __init__(self, conversation_id):
+        # 检查是否是类似ID的字符串（不包含中文等）
+        if (isinstance(conversation_id, str) and len(conversation_id) > 0 and 
+            not any(ord(c) > 127 or c.isspace() for c in conversation_id)):
+            message = f"对话未找到: {conversation_id}"
+        else:
+            message = conversation_id  # 自定义消息
+        super().__init__(message, error_code="CONVERSATION_NOT_FOUND")
+
+
+class MessageNotFoundError(ConversationManagerError):
+    """消息不存在异常"""
+    
+    def __init__(self, message_id):
+        # 检查是否是类似ID的字符串（不包含中文等）
+        if (isinstance(message_id, str) and len(message_id) > 0 and 
+            not any(ord(c) > 127 or c.isspace() for c in message_id)):
+            message = f"消息未找到: {message_id}"
+        else:
+            message = message_id  # 自定义消息
+        super().__init__(message, error_code="MESSAGE_NOT_FOUND")
+
+
+class ConcurrencyError(ConversationManagerError):
+    """并发访问异常"""
+    
+    def __init__(self, message="并发访问冲突"):
+        super().__init__(message, error_code="CONCURRENCY_ERROR")
+
+
+class DataIntegrityError(ConversationManagerError):
+    """数据完整性异常"""
+    
+    def __init__(self, message="数据完整性检查失败"):
+        super().__init__(message, error_code="DATA_INTEGRITY_ERROR")
+
+
+class LockTimeoutError(ConversationManagerError):
+    """锁超时异常"""
+    
+    def __init__(self, message="锁获取超时"):
+        super().__init__(message, error_code="LOCK_TIMEOUT_ERROR")
+
+
+class BackupError(ConversationManagerError):
+    """备份操作异常"""
+    
+    def __init__(self, message="备份操作失败"):
+        super().__init__(message, error_code="BACKUP_ERROR")
+
+
+class RestoreError(ConversationManagerError):
+    """恢复操作异常"""
+    
+    def __init__(self, message="恢复操作失败"):
+        super().__init__(message, error_code="RESTORE_ERROR") 

autocoder/common/conversations/file_locker.py

@@ -0,0 +1,145 @@
+"""
+PersistConversationManager 跨平台文件锁实现
+"""
+
+import os
+import sys
+import time
+import contextlib
+from typing import Generator
+from .exceptions import LockTimeoutError
+
+
+# 跨平台文件锁实现
+if sys.platform == "win32":
+    import msvcrt
+    
+    class FileLocker:
+        """Windows 平台文件锁实现"""
+        
+        def __init__(self, lock_file: str, timeout: float = 10.0):
+            self.lock_file = lock_file
+            self.timeout = timeout
+            self.lock_fd = None
+        
+        @contextlib.contextmanager
+        def acquire_read_lock(self) -> Generator[None, None, None]:
+            """获取读锁（共享锁）- Windows 实现"""
+            self._acquire_lock(shared=True)
+            try:
+                yield
+            finally:
+                self._release_lock()
+        
+        @contextlib.contextmanager
+        def acquire_write_lock(self) -> Generator[None, None, None]:
+            """获取写锁（排他锁）- Windows 实现"""
+            self._acquire_lock(shared=False)
+            try:
+                yield
+            finally:
+                self._release_lock()
+        
+        def _acquire_lock(self, shared: bool = False):
+            """Windows 文件锁实现"""
+            start_time = time.time()
+            while True:
+                try:
+                    # 确保锁文件目录存在
+                    os.makedirs(os.path.dirname(self.lock_file), exist_ok=True)
+                    
+                    # 打开文件用于锁定
+                    self.lock_fd = open(self.lock_file, 'w+')
+                    
+                    # Windows 下使用 msvcrt.locking
+                    # 注意：Windows 不直接支持共享锁，这里简化处理
+                    msvcrt.locking(self.lock_fd.fileno(), msvcrt.LK_NBLCK, 1)
+                    return
+                    
+                except (IOError, OSError):
+                    if self.lock_fd:
+                        self.lock_fd.close()
+                        self.lock_fd = None
+                    
+                    if time.time() - start_time > self.timeout:
+                        raise LockTimeoutError(f"Failed to acquire lock on {self.lock_file} within {self.timeout}s")
+                    
+                    time.sleep(0.1)
+        
+        def _release_lock(self):
+            """释放锁"""
+            if self.lock_fd:
+                try:
+                    msvcrt.locking(self.lock_fd.fileno(), msvcrt.LK_UNLCK, 1)
+                    self.lock_fd.close()
+                except:
+                    # 忽略释放时的错误
+                    pass
+                finally:
+                    self.lock_fd = None
+
+else:
+    # Unix/Linux/Mac 系统使用 fcntl
+    import fcntl
+    
+    class FileLocker:
+        """Unix/Linux/Mac 平台文件锁实现"""
+        
+        def __init__(self, lock_file: str, timeout: float = 10.0):
+            self.lock_file = lock_file
+            self.timeout = timeout
+            self.lock_fd = None
+        
+        @contextlib.contextmanager
+        def acquire_read_lock(self) -> Generator[None, None, None]:
+            """获取读锁（共享锁）- Unix/Linux/Mac 实现"""
+            self._acquire_lock(fcntl.LOCK_SH)
+            try:
+                yield
+            finally:
+                self._release_lock()
+        
+        @contextlib.contextmanager
+        def acquire_write_lock(self) -> Generator[None, None, None]:
+            """获取写锁（排他锁）- Unix/Linux/Mac 实现"""
+            self._acquire_lock(fcntl.LOCK_EX)
+            try:
+                yield
+            finally:
+                self._release_lock()
+        
+        def _acquire_lock(self, lock_type: int):
+            """Unix/Linux/Mac 文件锁实现"""
+            start_time = time.time()
+            
+            # 确保锁文件目录存在
+            os.makedirs(os.path.dirname(self.lock_file), exist_ok=True)
+            
+            # 打开锁文件
+            self.lock_fd = open(self.lock_file, 'w+')
+            
+            while True:
+                try:
+                    # 尝试获取非阻塞锁
+                    fcntl.flock(self.lock_fd.fileno(), lock_type | fcntl.LOCK_NB)
+                    return
+                    
+                except (IOError, OSError):
+                    if time.time() - start_time > self.timeout:
+                        self.lock_fd.close()
+                        self.lock_fd = None
+                        raise LockTimeoutError(f"Failed to acquire lock on {self.lock_file} within {self.timeout}s")
+                    
+                    time.sleep(0.1)
+        
+        def _release_lock(self):
+            """释放锁"""
+            if self.lock_fd:
+                try:
+                    fcntl.flock(self.lock_fd.fileno(), fcntl.LOCK_UN)
+                    self.lock_fd.close()
+                except:
+                    # 忽略释放时的错误
+                    pass
+                finally:
+                    self.lock_fd = None 

autocoder/common/conversations/get_conversation_manager.py

@@ -0,0 +1,143 @@
+import os
+import threading
+from typing import Optional
+from .manager import PersistConversationManager
+from .config import ConversationManagerConfig
+
+
+class ConversationManagerSingleton:
+    """对话管理器的单例类，确保全局只有一个实例"""
+    
+    _instance: Optional[PersistConversationManager] = None
+    _lock = threading.Lock()
+    _config: Optional[ConversationManagerConfig] = None
+    
+    @classmethod
+    def get_instance(cls, config: Optional[ConversationManagerConfig] = None) -> PersistConversationManager:
+        """
+        获取对话管理器实例
+        
+        Args:
+            config: 配置对象，如果为None则使用默认配置
+            
+        Returns:
+            PersistConversationManager实例
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    if config is None:
+                        config = cls._get_default_config()
+                    cls._config = config
+                    cls._instance = PersistConversationManager(config)
+        return cls._instance
+    
+    @classmethod
+    def reset_instance(cls, config: Optional[ConversationManagerConfig] = None):
+        """
+        重置实例，用于测试或配置更改时
+        
+        Args:
+            config: 新的配置对象
+        """
+        with cls._lock:
+            cls._instance = None
+            cls._config = None
+            if config is not None:
+                cls._instance = PersistConversationManager(config)
+                cls._config = config
+    
+    @classmethod
+    def _get_default_config(cls) -> ConversationManagerConfig:
+        """获取默认配置"""
+        # 默认存储路径为当前工作目录下的 .auto-coder/conversations
+        default_storage_path = os.path.join(os.getcwd(), ".auto-coder", "conversations")
+        
+        return ConversationManagerConfig(
+            storage_path=default_storage_path,
+            max_cache_size=100,
+            cache_ttl=300.0,
+            lock_timeout=10.0,
+            backup_enabled=True,
+            backup_interval=3600.0,
+            max_backups=10
+        )
+    
+    @classmethod
+    def get_config(cls) -> Optional[ConversationManagerConfig]:
+        """获取当前使用的配置"""
+        return cls._config
+
+
+def get_conversation_manager(config: Optional[ConversationManagerConfig] = None) -> PersistConversationManager:
+    """
+    获取全局对话管理器实例
+    
+    这是一个便捷函数，内部使用单例模式确保全局只有一个实例。
+    首次调用时会创建实例，后续调用会返回同一个实例。
+    
+    Args:
+        config: 可选的配置对象。如果为None，将使用默认配置。
+               注意：只有在首次调用时，config参数才会生效。
+    
+    Returns:
+        PersistConversationManager: 对话管理器实例
+        
+    Example:
+        ```python
+        # 使用默认配置
+        manager = get_conversation_manager()
+        
+        # 使用自定义配置（仅在首次调用时生效）
+        config = ConversationManagerConfig(
+            storage_path="./my_conversations",
+            max_cache_size=200
+        )
+        manager = get_conversation_manager(config)
+        
+        # 创建对话
+        conv_id = manager.create_conversation(
+            name="测试对话",
+            description="这是一个测试对话"
+        )
+        ```
+    """
+    return ConversationManagerSingleton.get_instance(config)
+
+
+def reset_conversation_manager(config: Optional[ConversationManagerConfig] = None):
+    """
+    重置全局对话管理器实例
+    
+    用于测试或需要更改配置时重置实例。
+    
+    Args:
+        config: 新的配置对象，如果为None则在下次调用get_conversation_manager时使用默认配置
+        
+    Example:
+        ```python
+        # 重置为默认配置
+        reset_conversation_manager()
+        
+        # 重置为新配置
+        new_config = ConversationManagerConfig(storage_path="./new_path")
+        reset_conversation_manager(new_config)
+        ```
+    """
+    ConversationManagerSingleton.reset_instance(config)
+
+
+def get_conversation_manager_config() -> Optional[ConversationManagerConfig]:
+    """
+    获取当前对话管理器使用的配置
+    
+    Returns:
+        当前配置对象，如果还未初始化则返回None
+    """
+    return ConversationManagerSingleton.get_config()
+
+
+# 便捷别名
+get_manager = get_conversation_manager
+reset_manager = reset_conversation_manager
+get_manager_config = get_conversation_manager_config