auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/env_manager.py

@@ -0,0 +1,282 @@
+"""
+环境变量管理模块
+
+该模块提供了一个统一的环境变量管理接口，方便项目中各个组件获取和使用环境变量。
+支持环境变量的获取、默认值设置、类型转换等功能。
+"""
+
+import os
+from typing import Optional, Union, Dict, Any
+from enum import Enum
+
+
+class Environment(Enum):
+    """环境类型枚举"""
+    PRODUCTION = "production"
+    DEVELOPMENT = "development"
+    DEV = "dev"  # development 的简写
+    PROD = "prod"  # production 的简写
+    
+
+class EnvManager:
+    """环境变量管理器
+    
+    提供统一的环境变量访问接口，支持类型转换和默认值设置。
+    """
+    
+    # 预定义的环境变量配置
+    ENV_CONFIGS = {
+        "AUTO_CODER_ENV": {
+            "description": "当前运行环境，支持 production/prod 或 development/dev",
+            "default": "development",
+            "type": str
+        },
+        # 可以在这里添加更多需要管理的环境变量
+    }
+    
+    @classmethod
+    def get_environment(cls) -> Environment:
+        """获取当前运行环境
+        
+        Returns:
+            Environment: 当前环境类型
+        """
+        env_value = cls.get_env("AUTO_CODER_ENV", "development").lower()
+        
+        # 标准化环境值
+        if env_value in ["production", "prod"]:
+            return Environment.PRODUCTION
+        elif env_value in ["development", "dev"]:
+            return Environment.DEVELOPMENT
+        else:
+            # 默认返回开发环境
+            return Environment.DEVELOPMENT
+    
+    @classmethod
+    def is_production(cls) -> bool:
+        """判断是否为生产环境
+        
+        Returns:
+            bool: True 如果是生产环境，False 否则
+        """
+        return cls.get_environment() == Environment.PRODUCTION
+    
+    @classmethod
+    def is_development(cls) -> bool:
+        """判断是否为开发环境
+        
+        Returns:
+            bool: True 如果是开发环境，False 否则
+        """
+        return cls.get_environment() == Environment.DEVELOPMENT
+    
+    @classmethod
+    def get_env(cls, key: str, default: Optional[Union[str, int, float, bool]] = None) -> Any:
+        """获取环境变量值
+        
+        Args:
+            key: 环境变量名
+            default: 默认值，如果环境变量不存在则返回此值
+            
+        Returns:
+            Any: 环境变量的值，类型取决于默认值类型
+        """
+        value = os.environ.get(key)
+        
+        if value is None:
+            return default
+        
+        # 根据默认值类型进行类型转换
+        if default is not None:
+            if isinstance(default, bool):
+                return cls._str_to_bool(value)
+            elif isinstance(default, int):
+                try:
+                    return int(value)
+                except ValueError:
+                    return default
+            elif isinstance(default, float):
+                try:
+                    return float(value)
+                except ValueError:
+                    return default
+        
+        return value
+    
+    @classmethod
+    def get_env_bool(cls, key: str, default: bool = False) -> bool:
+        """获取布尔类型环境变量
+        
+        Args:
+            key: 环境变量名
+            default: 默认值
+            
+        Returns:
+            bool: 环境变量的布尔值
+        """
+        value = os.environ.get(key)
+        if value is None:
+            return default
+        return cls._str_to_bool(value)
+    
+    @classmethod
+    def get_env_int(cls, key: str, default: int = 0) -> int:
+        """获取整数类型环境变量
+        
+        Args:
+            key: 环境变量名
+            default: 默认值
+            
+        Returns:
+            int: 环境变量的整数值
+        """
+        value = os.environ.get(key)
+        if value is None:
+            return default
+        try:
+            return int(value)
+        except ValueError:
+            return default
+    
+    @classmethod
+    def get_env_float(cls, key: str, default: float = 0.0) -> float:
+        """获取浮点数类型环境变量
+        
+        Args:
+            key: 环境变量名
+            default: 默认值
+            
+        Returns:
+            float: 环境变量的浮点数值
+        """
+        value = os.environ.get(key)
+        if value is None:
+            return default
+        try:
+            return float(value)
+        except ValueError:
+            return default
+    
+    @classmethod
+    def set_env(cls, key: str, value: Union[str, int, float, bool]) -> None:
+        """设置环境变量
+        
+        Args:
+            key: 环境变量名
+            value: 环境变量值
+        """
+        os.environ[key] = str(value)
+    
+    @classmethod
+    def has_env(cls, key: str) -> bool:
+        """检查环境变量是否存在
+        
+        Args:
+            key: 环境变量名
+            
+        Returns:
+            bool: True 如果环境变量存在，False 否则
+        """
+        return key in os.environ
+    
+    @classmethod
+    def get_all_managed_envs(cls) -> Dict[str, Any]:
+        """获取所有被管理的环境变量及其当前值
+        
+        Returns:
+            Dict[str, Any]: 环境变量名到值的映射
+        """
+        result = {}
+        for key, config in cls.ENV_CONFIGS.items():
+            result[key] = cls.get_env(key, config.get("default"))
+        return result
+    
+    @classmethod
+    def get_env_info(cls) -> Dict[str, Any]:
+        """获取环境信息摘要
+        
+        Returns:
+            Dict[str, Any]: 包含环境信息的字典
+        """
+        return {
+            "environment": cls.get_environment().value,
+            "is_production": cls.is_production(),
+            "is_development": cls.is_development(),
+            "managed_envs": cls.get_all_managed_envs()
+        }
+    
+    @staticmethod
+    def _str_to_bool(value: str) -> bool:
+        """将字符串转换为布尔值
+        
+        Args:
+            value: 字符串值
+            
+        Returns:
+            bool: 转换后的布尔值
+        """
+        if isinstance(value, bool):
+            return value
+        
+        value_lower = value.lower().strip()
+        
+        # True 值
+        if value_lower in ("true", "1", "yes", "on", "y", "t"):
+            return True
+        # False 值
+        elif value_lower in ("false", "0", "no", "off", "n", "f", ""):
+            return False
+        else:
+            # 其他值默认为 True（非空字符串）
+            return bool(value.strip())
+
+
+# 便捷函数，直接使用类方法
+def get_environment() -> Environment:
+    """获取当前运行环境"""
+    return EnvManager.get_environment()
+
+
+def is_production() -> bool:
+    """判断是否为生产环境"""
+    return EnvManager.is_production()
+
+
+def is_development() -> bool:
+    """判断是否为开发环境"""
+    return EnvManager.is_development()
+
+
+def get_env(key: str, default: Optional[Union[str, int, float, bool]] = None) -> Any:
+    """获取环境变量值"""
+    return EnvManager.get_env(key, default)
+
+
+def get_env_bool(key: str, default: bool = False) -> bool:
+    """获取布尔类型环境变量"""
+    return EnvManager.get_env_bool(key, default)
+
+
+def get_env_int(key: str, default: int = 0) -> int:
+    """获取整数类型环境变量"""
+    return EnvManager.get_env_int(key, default)
+
+
+def get_env_float(key: str, default: float = 0.0) -> float:
+    """获取浮点数类型环境变量"""
+    return EnvManager.get_env_float(key, default)
+
+
+def set_env(key: str, value: Union[str, int, float, bool]) -> None:
+    """设置环境变量"""
+    return EnvManager.set_env(key, value)
+
+
+def has_env(key: str) -> bool:
+    """检查环境变量是否存在"""
+    return EnvManager.has_env(key)
+
+
+def get_env_info() -> Dict[str, Any]:
+    """获取环境信息摘要"""
+    return EnvManager.get_env_info()

autocoder/common/env_manager_usage_example.py

@@ -0,0 +1,211 @@
+
+#!/usr/bin/env python3
+"""
+环境变量管理模块使用示例
+
+展示如何在项目中使用 env_manager 模块
+"""
+
+from env_manager import (
+    # 类和枚举
+    EnvManager, Environment,
+    # 便捷函数
+    get_environment, is_production, is_development,
+    get_env, get_env_bool, get_env_int, get_env_float,
+    set_env, has_env, get_env_info
+)
+
+
+def example_basic_usage():
+    """基本使用示例"""
+    print("=== 基本使用示例 ===")
+    
+    # 1. 检查当前环境
+    current_env = get_environment()
+    print(f"当前环境: {current_env.value}")
+    
+    # 2. 根据环境执行不同逻辑
+    if is_production():
+        print("运行在生产环境，启用严格模式")
+        # 生产环境的特殊配置
+        debug_mode = False
+        log_level = "INFO"
+    else:
+        print("运行在开发环境，启用调试模式")
+        # 开发环境的特殊配置
+        debug_mode = True
+        log_level = "DEBUG"
+    
+    print(f"调试模式: {debug_mode}")
+    print(f"日志级别: {log_level}")
+    print()
+
+
+def example_env_configuration():
+    """环境变量配置示例"""
+    print("=== 环境变量配置示例 ===")
+    
+    # 获取各种类型的环境变量，带默认值
+    database_url = get_env("DATABASE_URL", "sqlite:///default.db")
+    max_connections = get_env_int("MAX_CONNECTIONS", 10)
+    enable_cache = get_env_bool("ENABLE_CACHE", True)
+    timeout = get_env_float("TIMEOUT", 30.0)
+    
+    print(f"数据库URL: {database_url}")
+    print(f"最大连接数: {max_connections}")
+    print(f"启用缓存: {enable_cache}")
+    print(f"超时时间: {timeout}秒")
+    print()
+
+
+def example_dynamic_configuration():
+    """动态配置示例"""
+    print("=== 动态配置示例 ===")
+    
+    # 根据环境动态调整配置
+    if is_production():
+        # 生产环境配置
+        worker_count = get_env_int("WORKER_COUNT", 4)
+        enable_debug = False
+        cache_timeout = get_env_int("CACHE_TIMEOUT", 3600)
+    else:
+        # 开发环境配置
+        worker_count = get_env_int("WORKER_COUNT", 1)
+        enable_debug = get_env_bool("DEBUG", True)
+        cache_timeout = get_env_int("CACHE_TIMEOUT", 60)
+    
+    print(f"工作进程数: {worker_count}")
+    print(f"调试模式: {enable_debug}")
+    print(f"缓存超时: {cache_timeout}秒")
+    print()
+
+
+def example_feature_flags():
+    """功能开关示例"""
+    print("=== 功能开关示例 ===")
+    
+    # 使用环境变量控制功能开关
+    features = {
+        "NEW_UI": get_env_bool("FEATURE_NEW_UI", False),
+        "EXPERIMENTAL_API": get_env_bool("FEATURE_EXPERIMENTAL_API", False),
+        "ANALYTICS": get_env_bool("FEATURE_ANALYTICS", is_production()),  # 生产环境默认开启
+        "DEBUG_TOOLBAR": get_env_bool("FEATURE_DEBUG_TOOLBAR", is_development()),  # 开发环境默认开启
+    }
+    
+    print("功能开关状态:")
+    for feature, enabled in features.items():
+        status = "启用" if enabled else "禁用"
+        print(f"  {feature}: {status}")
+    print()
+
+
+def example_configuration_validation():
+    """配置验证示例"""
+    print("=== 配置验证示例 ===")
+    
+    # 检查必需的环境变量
+    required_vars = ["API_KEY", "SECRET_KEY"]
+    missing_vars = []
+    
+    for var in required_vars:
+        if not has_env(var):
+            missing_vars.append(var)
+    
+    if missing_vars:
+        print(f"警告: 缺少必需的环境变量: {', '.join(missing_vars)}")
+        print("请设置这些环境变量后重新启动应用")
+    else:
+        print("所有必需的环境变量都已设置")
+    
+    # 验证环境变量值的有效性
+    max_retries = get_env_int("MAX_RETRIES", 3)
+    if max_retries < 1 or max_retries > 10:
+        print(f"警告: MAX_RETRIES 值 {max_retries} 不在有效范围内 (1-10)")
+    
+    print()
+
+
+def example_logging_configuration():
+    """日志配置示例"""
+    print("=== 日志配置示例 ===")
+    
+    # 根据环境配置日志
+    log_config = {
+        "level": get_env("LOG_LEVEL", "INFO" if is_production() else "DEBUG"),
+        "format": get_env("LOG_FORMAT", "json" if is_production() else "console"),
+        "output": get_env("LOG_OUTPUT", "file" if is_production() else "console"),
+        "max_size": get_env_int("LOG_MAX_SIZE", 100),  # MB
+        "backup_count": get_env_int("LOG_BACKUP_COUNT", 5),
+    }
+    
+    print("日志配置:")
+    for key, value in log_config.items():
+        print(f"  {key}: {value}")
+    print()
+
+
+def example_service_configuration():
+    """服务配置示例"""
+    print("=== 服务配置示例 ===")
+    
+    # Web 服务配置
+    web_config = {
+        "host": get_env("HOST", "0.0.0.0" if is_production() else "127.0.0.1"),
+        "port": get_env_int("PORT", 8000),
+        "workers": get_env_int("WORKERS", 4 if is_production() else 1),
+        "reload": get_env_bool("RELOAD", is_development()),
+        "access_log": get_env_bool("ACCESS_LOG", is_production()),
+    }
+    
+    print("Web服务配置:")
+    for key, value in web_config.items():
+        print(f"  {key}: {value}")
+    print()
+
+
+def example_environment_info():
+    """环境信息示例"""
+    print("=== 环境信息示例 ===")
+    
+    # 获取完整的环境信息
+    env_info = get_env_info()
+    print("完整环境信息:")
+    for key, value in env_info.items():
+        print(f"  {key}: {value}")
+    print()
+
+
+def main():
+    """主函数"""
+    print("环境变量管理模块使用示例")
+    print("=" * 50)
+    
+    example_basic_usage()
+    example_env_configuration()
+    example_dynamic_configuration()
+    example_feature_flags()
+    example_configuration_validation()
+    example_logging_configuration()
+    example_service_configuration()
+    example_environment_info()
+    
+    print("示例演示完成!")
+
+
+if __name__ == "__main__":
+    # 设置一些示例环境变量
+    import os
+    os.environ.update({
+        "DATABASE_URL": "postgresql://user:pass@localhost/mydb",
+        "MAX_CONNECTIONS": "20",
+        "ENABLE_CACHE": "true",
+        "TIMEOUT": "45.5",
+        "FEATURE_NEW_UI": "true",
+        "API_KEY": "your-api-key-here",
+        "SECRET_KEY": "your-secret-key-here",
+        "LOG_LEVEL": "INFO",
+        "PORT": "8080",
+    })
+    
+    main()
+

autocoder/common/file_checkpoint/conversation_checkpoint.py

@@ -12,7 +12,9 @@ class ConversationCheckpoint(BaseModel):
     
     checkpoint_id: str  # 检查点ID，与变更组ID对应
     timestamp: float  # 创建时间戳
-    conversations: List[Dict[str, Any]]  # 对话历史
+    conversation_id: Optional[str] = None  # 对话ID，与具体对话会话关联
+    first_message_id: Optional[str] = None  # 对话消息区间起始ID
+    last_message_id: Optional[str] = None  # 对话消息区间结束ID
     metadata: Optional[Dict[str, Any]] = None  # 元数据，可包含额外信息
 
 
@@ -47,6 +49,9 @@ class ConversationCheckpointStore:
             
         Returns:
             str: 检查点ID
+            
+        Raises:
+            Exception: 保存失败时抛出异常
         """
         # 确保检查点有ID
         if not checkpoint.checkpoint_id:
@@ -60,19 +65,15 @@ class ConversationCheckpointStore:
         file_path = os.path.join(self.store_dir, f"{checkpoint.checkpoint_id}.json")
         
         # 保存为JSON文件
-        try:
-            with open(file_path, 'w', encoding='utf-8') as f:
-                f.write(checkpoint.model_dump_json(ensure_ascii=False, indent=2))
-            
-            logger.info(f"已保存对话检查点: {checkpoint.checkpoint_id}")
-            
-            # 检查并清理过期的检查点
-            self._cleanup_old_checkpoints()
-            
-            return checkpoint.checkpoint_id
-        except Exception as e:
-            logger.error(f"保存对话检查点失败: {str(e)}")
-            return ""
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(json.dumps(checkpoint.model_dump(), ensure_ascii=False, indent=2))
+        
+        logger.debug(f"已保存对话检查点: {checkpoint.checkpoint_id}")
+        
+        # 检查并清理过期的检查点
+        self._cleanup_old_checkpoints()
+        
+        return checkpoint.checkpoint_id
     
     def get_checkpoint(self, checkpoint_id: str) -> Optional[ConversationCheckpoint]:
         """
@@ -87,7 +88,6 @@ class ConversationCheckpointStore:
         file_path = os.path.join(self.store_dir, f"{checkpoint_id}.json")
         
         if not os.path.exists(file_path):
-            logger.warning(f"对话检查点不存在: {checkpoint_id}")
             return None
         
         try:
@@ -96,7 +96,7 @@ class ConversationCheckpointStore:
             
             return ConversationCheckpoint(**data)
         except Exception as e:
-            logger.error(f"读取对话检查点失败: {str(e)}")
+            logger.error(f"读取对话检查点失败 {checkpoint_id}: {str(e)}")
             return None
     
     def get_latest_checkpoint(self) -> Optional[ConversationCheckpoint]:
@@ -129,15 +129,14 @@ class ConversationCheckpointStore:
         file_path = os.path.join(self.store_dir, f"{checkpoint_id}.json")
         
         if not os.path.exists(file_path):
-            logger.warning(f"要删除的对话检查点不存在: {checkpoint_id}")
             return False
         
         try:
             os.remove(file_path)
-            logger.info(f"已删除对话检查点: {checkpoint_id}")
+            logger.debug(f"已删除对话检查点: {checkpoint_id}")
             return True
         except Exception as e:
-            logger.error(f"删除对话检查点失败: {str(e)}")
+            logger.error(f"删除对话检查点失败 {checkpoint_id}: {str(e)}")
             return False
     
     def _get_all_checkpoints(self) -> List[ConversationCheckpoint]:
@@ -180,3 +179,4 @@ class ConversationCheckpointStore:
         # 删除超出限制的旧检查点
         for checkpoint in checkpoints[self.max_history:]:
             self.delete_checkpoint(checkpoint.checkpoint_id)
+            logger.debug(f"清理旧检查点: {checkpoint.checkpoint_id}")