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

autocoder/common/command_file_manager/test_command_file_manager.py

@@ -0,0 +1,507 @@
+"""
+命令文件管理模块的单元测试
+
+测试 CommandManager 类、工具函数和数据模型的主要功能。
+"""
+
+import os
+import tempfile
+import unittest
+from unittest.mock import patch, mock_open
+from typing import Dict, Set, List
+
+from autocoder.common.command_file_manager import (
+    CommandManager, CommandFile, JinjaVariable, CommandFileAnalysisResult,
+    ListCommandsResult, extract_jinja2_variables, extract_jinja2_variables_with_metadata,
+    analyze_command_file, is_command_file
+)
+
+
+class TestCommandFileManager(unittest.TestCase):
+    """测试 CommandManager 类的功能"""
+    
+    def setUp(self):
+        """设置测试环境"""
+        # 根据内存中的信息，初始化和加载 tokenizer
+        try:
+            from transformers import AutoTokenizer  # type: ignore
+            self.tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+        except ImportError:
+            # 如果没有 transformers 库，使用模拟对象
+            self.tokenizer = None
+        
+        # 创建临时目录用于测试
+        self.temp_dir = tempfile.mkdtemp()
+        self.manager = CommandManager(self.temp_dir)
+        
+        # 创建测试文件内容
+        self.test_content_basic = """
+# {{ project_name }}
+
+这是一个测试项目，作者是 {{ author }}。
+版本号：{{ version }}
+"""
+        
+        self.test_content_with_metadata = """
+{# @var: project_name, default: TestProject, description: 项目名称 #}
+{# @var: author, default: TestUser, description: 作者姓名 #}
+{# @var: version, default: 1.0.0, description: 版本号 #}
+# {{ project_name }}
+
+这是一个由 {{ author }} 创建的项目。
+版本：{{ version }}
+
+{% if include_docs %}
+## 文档
+包含文档说明
+{% endif %}
+"""
+        
+        self.test_content_control_structures = """
+{% for item in items %}
+- {{ item.name }}: {{ item.value }}
+{% endfor %}
+
+{% if debug_mode %}
+DEBUG: {{ debug_info }}
+{% endif %}
+"""
+    
+    def tearDown(self):
+        """清理测试环境"""
+        # 删除临时目录
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+    
+    def _create_test_file(self, filename: str, content: str) -> str:
+        """创建测试文件"""
+        file_path = os.path.join(self.temp_dir, filename)
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return file_path
+    
+    def test_initialization(self):
+        """测试 CommandManager 初始化"""
+        # 测试默认初始化
+        default_manager = CommandManager()
+        expected_dir = os.path.join(os.getcwd(), ".autocodercommands")
+        self.assertEqual(default_manager.commands_dir, expected_dir)
+        
+        # 测试自定义目录初始化
+        custom_manager = CommandManager(self.temp_dir)
+        self.assertEqual(custom_manager.commands_dir, self.temp_dir)
+    
+    def test_list_command_files_empty_directory(self):
+        """测试空目录下列出命令文件"""
+        result = self.manager.list_command_files()
+        self.assertTrue(result.success)
+        self.assertEqual(len(result.command_files), 0)
+        self.assertFalse(result.has_errors)
+    
+    def test_list_command_files_with_files(self):
+        """测试有文件的目录下列出命令文件"""
+        # 创建测试文件
+        self._create_test_file("test1.md", self.test_content_basic)
+        self._create_test_file("test2.md", self.test_content_with_metadata)
+        self._create_test_file("not_command.txt", "这不是命令文件")
+        
+        # 测试非递归列出
+        result = self.manager.list_command_files(recursive=False)
+        self.assertTrue(result.success)
+        self.assertEqual(len(result.command_files), 2)
+        self.assertIn("test1.md", result.command_files)
+        self.assertIn("test2.md", result.command_files)
+        self.assertNotIn("not_command.txt", result.command_files)
+    
+    def test_list_command_files_recursive(self):
+        """测试递归列出命令文件"""
+        # 创建子目录和文件
+        subdir = os.path.join(self.temp_dir, "subdir")
+        os.makedirs(subdir)
+        
+        self._create_test_file("test1.md", self.test_content_basic)
+        sub_file = os.path.join(subdir, "test2.md")
+        with open(sub_file, 'w', encoding='utf-8') as f:
+            f.write(self.test_content_with_metadata)
+        
+        # 测试递归列出
+        result = self.manager.list_command_files(recursive=True)
+        self.assertTrue(result.success)
+        self.assertEqual(len(result.command_files), 2)
+        self.assertIn("test1.md", result.command_files)
+        self.assertIn(os.path.join("subdir", "test2.md"), result.command_files)
+    
+    def test_read_command_file_success(self):
+        """测试成功读取命令文件"""
+        filename = "test.md"
+        self._create_test_file(filename, self.test_content_basic)
+        
+        result = self.manager.read_command_file(filename)
+        self.assertIsNotNone(result)
+        if result is not None:
+            self.assertEqual(result.file_name, filename)
+            self.assertEqual(result.content, self.test_content_basic)
+            self.assertTrue(result.file_path.endswith(filename))
+    
+    def test_read_command_file_not_found(self):
+        """测试读取不存在的命令文件"""
+        result = self.manager.read_command_file("nonexistent.md")
+        self.assertIsNone(result)
+    
+    def test_read_command_file_with_render(self):
+        """测试读取并渲染命令文件"""
+        filename = "test.md"
+        self._create_test_file(filename, self.test_content_basic)
+        
+        render_variables = {
+            "project_name": "MyProject",
+            "author": "TestAuthor",
+            "version": "2.0.0"
+        }
+        
+        result = self.manager.read_command_file_with_render(filename, render_variables)
+        self.assertIsNotNone(result)
+        if result is not None:
+            self.assertIn("MyProject", result)
+            self.assertIn("TestAuthor", result)
+            self.assertIn("2.0.0", result)
+    
+    def test_read_command_file_with_render_empty_variables(self):
+        """测试使用空变量字典渲染"""
+        filename = "test.md"
+        self._create_test_file(filename, self.test_content_basic)
+        
+        result = self.manager.read_command_file_with_render(filename, {})
+        self.assertIsNotNone(result)
+        # 空变量字典会导致变量被渲染为空字符串
+        if result is not None:
+            # 检查变量被渲染后的内容
+            self.assertIn("这是一个测试项目，作者是", result)
+            self.assertIn("版本号：", result)
+    
+    def test_analyze_command_file_success(self):
+        """测试成功分析命令文件"""
+        filename = "test.md"
+        self._create_test_file(filename, self.test_content_with_metadata)
+        
+        result = self.manager.analyze_command_file(filename)
+        self.assertIsNotNone(result)
+        if result is not None:
+            self.assertEqual(result.file_name, filename)
+            self.assertGreater(len(result.variables), 0)
+            self.assertGreater(len(result.raw_variables), 0)
+            
+            # 检查特定变量
+            project_name_var = next((v for v in result.variables if v.name == "project_name"), None)
+            self.assertIsNotNone(project_name_var)
+            if project_name_var is not None:
+                self.assertEqual(project_name_var.default_value, "TestProject")
+                self.assertEqual(project_name_var.description, "项目名称")
+    
+    def test_analyze_command_file_not_found(self):
+        """测试分析不存在的命令文件"""
+        result = self.manager.analyze_command_file("nonexistent.md")
+        self.assertIsNone(result)
+    
+    def test_get_all_variables(self):
+        """测试获取所有变量"""
+        # 创建多个测试文件
+        self._create_test_file("test1.md", self.test_content_basic)
+        self._create_test_file("test2.md", self.test_content_with_metadata)
+        
+        result = self.manager.get_all_variables()
+        self.assertIsInstance(result, dict)
+        self.assertEqual(len(result), 2)
+        
+        # 检查变量内容
+        self.assertIn("test1.md", result)
+        self.assertIn("test2.md", result)
+        self.assertIn("project_name", result["test1.md"])
+        self.assertIn("author", result["test1.md"])
+    
+    def test_get_command_file_path(self):
+        """测试获取命令文件路径"""
+        filename = "test.md"
+        result = self.manager.get_command_file_path(filename)
+        expected = os.path.join(self.temp_dir, filename)
+        self.assertEqual(result, expected)
+
+
+class TestUtilityFunctions(unittest.TestCase):
+    """测试工具函数"""
+    
+    def setUp(self):
+        """设置测试环境"""
+        # 根据内存中的信息，初始化和加载 tokenizer
+        try:
+            from transformers import AutoTokenizer  # type: ignore
+            self.tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+        except ImportError:
+            self.tokenizer = None
+    
+    def test_extract_jinja2_variables_basic(self):
+        """测试基本的Jinja2变量提取"""
+        content = "Hello {{ name }}, version {{ version }}"
+        result = extract_jinja2_variables(content)
+        self.assertIsInstance(result, set)
+        self.assertEqual(result, {"name", "version"})
+    
+    def test_extract_jinja2_variables_with_spaces(self):
+        """测试带空格的Jinja2变量提取"""
+        content = "Hello {{  name  }}, version {{version}}"
+        result = extract_jinja2_variables(content)
+        self.assertEqual(result, {"name", "version"})
+    
+    def test_extract_jinja2_variables_control_structures(self):
+        """测试控制结构中的变量提取"""
+        content = """
+        {% if debug_mode %}
+        {% for item in items %}
+        {{ item.name }}
+        {% endfor %}
+        {% endif %}
+        """
+        result = extract_jinja2_variables(content)
+        self.assertIn("debug_mode", result)
+        # 注意：当前的正则表达式提取的是'item'而不是'items'
+        # 这是因为正则表达式匹配的是变量名，而不是for循环中的集合名
+        self.assertIn("item", result)
+    
+    def test_extract_jinja2_variables_with_metadata(self):
+        """测试带元数据的变量提取"""
+        content = """
+        {# @var: project_name, default: TestProject, description: 项目名称 #}
+        {# @var: author, default: TestUser, description: 作者姓名 #}
+        # {{ project_name }}
+        Author: {{ author }}
+        Version: {{ version }}
+        """
+        result = extract_jinja2_variables_with_metadata(content)
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 3)
+        
+        # 检查带元数据的变量
+        project_var = next((v for v in result if v.name == "project_name"), None)
+        self.assertIsNotNone(project_var)
+        if project_var is not None:
+            self.assertEqual(project_var.default_value, "TestProject")
+            self.assertEqual(project_var.description, "项目名称")
+        
+        # 检查不带元数据的变量
+        version_var = next((v for v in result if v.name == "version"), None)
+        self.assertIsNotNone(version_var)
+        if version_var is not None:
+            self.assertIsNone(version_var.default_value)
+            self.assertIsNone(version_var.description)
+    
+    def test_analyze_command_file_function(self):
+        """测试文件分析函数"""
+        file_path = "/tmp/test.md"
+        content = """
+        {# @var: name, default: Test, description: 名称 #}
+        Hello {{ name }}!
+        """
+        
+        result = analyze_command_file(file_path, content)
+        self.assertIsInstance(result, CommandFileAnalysisResult)
+        self.assertEqual(result.file_path, file_path)
+        self.assertEqual(result.file_name, "test.md")
+        self.assertGreater(len(result.variables), 0)
+        self.assertIn("name", result.raw_variables)
+    
+    def test_is_command_file(self):
+        """测试命令文件检测"""
+        self.assertTrue(is_command_file("test.md"))
+        self.assertTrue(is_command_file("example.md"))
+        self.assertFalse(is_command_file("test.txt"))
+        self.assertFalse(is_command_file("test.py"))
+        self.assertFalse(is_command_file("test"))
+
+
+class TestDataModels(unittest.TestCase):
+    """测试数据模型"""
+    
+    def setUp(self):
+        """设置测试环境"""
+        # 根据内存中的信息，初始化和加载 tokenizer
+        try:
+            from transformers import AutoTokenizer  # type: ignore
+            self.tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+        except ImportError:
+            self.tokenizer = None
+    
+    def test_command_file_model(self):
+        """测试 CommandFile 模型"""
+        file_data = {
+            "file_path": "/tmp/test.md",
+            "file_name": "test.md",
+            "content": "Hello {{ name }}"
+        }
+        
+        # 测试创建和转换
+        command_file = CommandFile.from_dict(file_data)
+        self.assertEqual(command_file.file_path, file_data["file_path"])
+        self.assertEqual(command_file.file_name, file_data["file_name"])
+        self.assertEqual(command_file.content, file_data["content"])
+        
+        # 测试转回字典
+        result_dict = command_file.to_dict()
+        self.assertEqual(result_dict, file_data)
+    
+    def test_jinja_variable_model(self):
+        """测试 JinjaVariable 模型"""
+        var_data = {
+            "name": "project_name",
+            "default_value": "TestProject",
+            "description": "项目名称"
+        }
+        
+        # 测试创建和转换
+        jinja_var = JinjaVariable.from_dict(var_data)
+        self.assertEqual(jinja_var.name, var_data["name"])
+        self.assertEqual(jinja_var.default_value, var_data["default_value"])
+        self.assertEqual(jinja_var.description, var_data["description"])
+        
+        # 测试转回字典
+        result_dict = jinja_var.to_dict()
+        self.assertEqual(result_dict, var_data)
+    
+    def test_jinja_variable_optional_fields(self):
+        """测试 JinjaVariable 可选字段"""
+        var_data = {"name": "simple_var"}
+        
+        jinja_var = JinjaVariable.from_dict(var_data)
+        self.assertEqual(jinja_var.name, "simple_var")
+        self.assertIsNone(jinja_var.default_value)
+        self.assertIsNone(jinja_var.description)
+    
+    def test_command_file_analysis_result(self):
+        """测试 CommandFileAnalysisResult 模型"""
+        # 创建测试数据
+        var1 = JinjaVariable(name="var1", default_value="default1", description="desc1")
+        var2 = JinjaVariable(name="var2")
+        
+        result = CommandFileAnalysisResult(
+            file_path="/tmp/test.md",
+            file_name="test.md"
+        )
+        
+        result.add_variable(var1)
+        result.add_variable(var2)
+        
+        self.assertEqual(len(result.variables), 2)
+        self.assertEqual(result.raw_variables, {"var1", "var2"})
+        
+        # 测试转换为字典
+        result_dict = result.to_dict()
+        self.assertEqual(result_dict["file_path"], "/tmp/test.md")
+        self.assertEqual(result_dict["file_name"], "test.md")
+        self.assertEqual(len(result_dict["variables"]), 2)
+        self.assertEqual(set(result_dict["raw_variables"]), {"var1", "var2"})
+    
+    def test_list_commands_result(self):
+        """测试 ListCommandsResult 模型"""
+        result = ListCommandsResult(success=True)
+        
+        # 测试添加命令文件
+        result.add_command_file("test1.md")
+        result.add_command_file("test2.md")
+        
+        self.assertEqual(len(result.command_files), 2)
+        self.assertIn("test1.md", result.command_files)
+        self.assertIn("test2.md", result.command_files)
+        self.assertFalse(result.has_errors)
+        
+        # 测试添加错误
+        result.add_error("/tmp/error.md", "File not found")
+        self.assertTrue(result.has_errors)
+        self.assertFalse(result.success)
+        self.assertEqual(result.errors["/tmp/error.md"], "File not found")
+
+
+class TestIntegration(unittest.TestCase):
+    """集成测试"""
+    
+    def setUp(self):
+        """设置测试环境"""
+        # 根据内存中的信息，初始化和加载 tokenizer
+        try:
+            from transformers import AutoTokenizer  # type: ignore
+            self.tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+        except ImportError:
+            self.tokenizer = None
+        
+        self.temp_dir = tempfile.mkdtemp()
+        self.manager = CommandManager(self.temp_dir)
+    
+    def tearDown(self):
+        """清理测试环境"""
+        import shutil
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+    
+    def test_full_workflow(self):
+        """测试完整的工作流程"""
+        # 创建测试文件
+        content = """
+        {# @var: app_name, default: MyApp, description: 应用名称 #}
+        {# @var: version, default: 1.0.0, description: 版本号 #}
+        
+        # {{ app_name }}
+        
+        欢迎使用 {{ app_name }} v{{ version }}
+        
+        {% if include_docs %}
+        ## 文档
+        文档内容...
+        {% endif %}
+        """
+        
+        filename = "app_template.md"
+        file_path = os.path.join(self.temp_dir, filename)
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        # 1. 列出文件
+        list_result = self.manager.list_command_files()
+        self.assertTrue(list_result.success)
+        self.assertIn(filename, list_result.command_files)
+        
+        # 2. 读取文件
+        command_file = self.manager.read_command_file(filename)
+        self.assertIsNotNone(command_file)
+        if command_file is not None:
+            self.assertEqual(command_file.file_name, filename)
+        
+        # 3. 分析文件
+        analysis = self.manager.analyze_command_file(filename)
+        self.assertIsNotNone(analysis)
+        if analysis is not None:
+            self.assertGreater(len(analysis.variables), 0)
+            
+            # 验证变量
+            expected_vars = {"app_name", "version", "include_docs"}
+            self.assertEqual(analysis.raw_variables, expected_vars)
+        
+        # 4. 渲染文件
+        render_vars = {
+            "app_name": "TestApp",
+            "version": "2.0.0",
+            "include_docs": True
+        }
+        
+        rendered = self.manager.read_command_file_with_render(filename, render_vars)
+        self.assertIsNotNone(rendered)
+        if rendered is not None:
+            self.assertIn("TestApp", rendered)
+            self.assertIn("2.0.0", rendered)
+            self.assertIn("## 文档", rendered)
+        
+        # 5. 获取所有变量
+        all_vars = self.manager.get_all_variables()
+        self.assertIn(filename, all_vars)
+        if analysis is not None:
+            self.assertEqual(all_vars[filename], analysis.raw_variables)
+
+
+if __name__ == '__main__':
+    unittest.main() 

autocoder/common/command_templates.py

@@ -164,7 +164,7 @@ def base_000_example()->str:
 @byzerllm.prompt()
 def base_base(source_dir:str,project_type:str)->str:    
     '''
-    project_type: {{ project_type }}
+    project_type: "{{ project_type }}"
     source_dir: {{ source_dir }}
     target_file: {{ target_file }}
 

autocoder/common/conf_utils.py

@@ -1,6 +1,6 @@
 import os
 import json
-import pkg_resources
+import importlib.resources as resources
 from autocoder.common import AutoCoderArgs
 
 ## 用于auto-coder 内部使用
@@ -9,9 +9,7 @@ def load_tokenizer():
     from autocoder.rag.variable_holder import VariableHolder
     from tokenizers import Tokenizer    
     try:
-        tokenizer_path = pkg_resources.resource_filename(
-            "autocoder", "data/tokenizer.json"
-        )
+        tokenizer_path = str(resources.files("autocoder") / "data" / "tokenizer.json")
         VariableHolder.TOKENIZER_PATH = tokenizer_path
         VariableHolder.TOKENIZER_MODEL = Tokenizer.from_file(tokenizer_path)
     except FileNotFoundError:

autocoder/common/conversations/config.py

@@ -22,6 +22,7 @@ class ConversationManagerConfig:
     max_backups: int = 10
     enable_compression: bool = False
     log_level: str = "INFO"
+    default_namespace: Optional[str] = None
     
     def __post_init__(self):
         """配置验证"""
@@ -57,6 +58,10 @@ class ConversationManagerConfig:
         valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
         if self.log_level not in valid_levels:
             raise ValueError(f"无效的日志级别: {self.log_level}，有效级别: {valid_levels}")
+        
+        # 验证默认命名空间
+        if self.default_namespace is not None and not isinstance(self.default_namespace, str):
+            raise ValueError("默认命名空间必须是字符串或None")
     
     def to_dict(self) -> Dict[str, Any]:
         """转换为字典"""
@@ -69,7 +74,8 @@ class ConversationManagerConfig:
             "backup_interval": self.backup_interval,
             "max_backups": self.max_backups,
             "enable_compression": self.enable_compression,
-            "log_level": self.log_level
+            "log_level": self.log_level,
+            "default_namespace": self.default_namespace
         }
     
     @classmethod
@@ -103,7 +109,8 @@ class ConversationManagerConfig:
             f"{prefix}BACKUP_INTERVAL": "backup_interval",
             f"{prefix}MAX_BACKUPS": "max_backups",
             f"{prefix}ENABLE_COMPRESSION": "enable_compression",
-            f"{prefix}LOG_LEVEL": "log_level"
+            f"{prefix}LOG_LEVEL": "log_level",
+            f"{prefix}DEFAULT_NAMESPACE": "default_namespace"
         }
         
         for env_key, attr_name in env_mapping.items():
@@ -185,7 +192,8 @@ class ConversationManagerConfig:
                 f"cache_ttl={self.cache_ttl}, "
                 f"lock_timeout={self.lock_timeout}, "
                 f"backup_enabled={self.backup_enabled}, "
-                f"log_level='{self.log_level}')")
+                f"log_level='{self.log_level}', "
+                f"default_namespace={self.default_namespace!r})")
     
     def __eq__(self, other) -> bool:
         """相等性比较"""