auto-coder 0.1.326__py3-none-any.whl → 0.1.328__py3-none-any.whl

autocoder/compilers/models.py

@@ -0,0 +1,210 @@
+"""
+用于表示代码编译结果的 Pydantic 模型。
+"""
+
+from enum import Enum
+from typing import List, Dict, Any, Optional, Union
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+class CompilationErrorSeverity(str, Enum):
+    """编译错误严重性的枚举"""
+    ERROR = "error"  # 错误
+    WARNING = "warning"  # 警告
+    INFO = "info"  # 信息
+
+class CompilationErrorPosition(BaseModel):
+    """文件中编译错误的位置"""
+    line: int = Field(..., description="发现错误的行号（从1开始）")
+    column: Optional[int] = Field(None, description="发现错误的列号（从1开始）")
+    end_line: Optional[int] = Field(None, description="错误的结束行号")
+    end_column: Optional[int] = Field(None, description="错误的结束列号")
+
+    def to_str(self) -> str:
+        """将位置转换为人类可读的字符串"""
+        result = f"第 {self.line} 行"
+        if self.column is not None:
+            result += f"，第 {self.column} 列"
+        if self.end_line is not None and (self.end_line != self.line or self.end_column is not None):
+            result += f" 到第 {self.end_line} 行"
+            if self.end_column is not None:
+                result += f"，第 {self.end_column} 列"
+        return result
+
+class CompilationError(BaseModel):
+    """单个编译错误的表示"""
+    code: Optional[str] = Field(None, description="错误代码或标识符")
+    message: str = Field(..., description="错误的人类可读描述")
+    severity: CompilationErrorSeverity = Field(..., description="错误的严重性级别")
+    position: CompilationErrorPosition = Field(..., description="错误在文件中的位置")
+    file_path: str = Field(..., description="发现错误的文件路径")
+    source: Optional[str] = Field(None, description="发现错误的源代码片段")
+    
+    def to_str(self, show_file_path: bool = True) -> str:
+        """
+        将错误转换为人类可读的字符串
+        
+        参数:
+            show_file_path: 是否在输出中包含文件路径
+            
+        返回:
+            错误的格式化字符串表示
+        """
+        parts = []
+        
+        if show_file_path:
+            parts.append(f"{self.file_path}:{self.position.line}")
+        
+        parts.append(f"[{self.severity.value.upper()}] {self.message}")
+        
+        if self.code:
+            parts.append(f"({self.code})")
+            
+        result = " ".join(parts)
+        
+        if self.source:
+            # 为了更好的可读性，缩进源代码
+            indented_source = "\n    ".join(self.source.splitlines())
+            result += f"\n    {indented_source}"
+            
+        return result
+
+class FileCompilationResult(BaseModel):
+    """单个文件的编译结果"""
+    file_path: str = Field(..., description="被编译的文件路径")
+    success: bool = Field(True, description="编译是否成功完成")
+    language: str = Field(..., description="被编译的语言/文件类型")
+    errors: List[CompilationError] = Field(default_factory=list, description="发现的编译错误列表")
+    error_message: Optional[str] = Field(None, description="如果编译失败，错误消息")
+    warning_count: int = Field(0, description="发现的警告数量")
+    error_count: int = Field(0, description="发现的错误数量")
+    info_count: int = Field(0, description="发现的信息性问题数量")
+    execution_time_ms: Optional[int] = Field(None, description="编译文件所花费的时间（毫秒）")
+    output_file: Optional[str] = Field(None, description="编译输出的文件路径")
+
+    def to_str(self, show_file_path_in_errors: bool = False) -> str:
+        """
+        将文件编译结果转换为人类可读的字符串
+        
+        参数:
+            show_file_path_in_errors: 是否在单个错误中包含文件路径
+            
+        返回:
+            文件编译结果的格式化字符串表示
+        """
+        if not self.success:
+            return f"编译 {self.file_path} 时出错: {self.error_message or '未知错误'}"
+        
+        result = [f"{self.file_path} 的编译结果 ({self.language}):"]
+        
+        # 摘要信息
+        if self.success and self.error_count == 0 and self.warning_count == 0:
+            result.append("编译成功")
+            if self.output_file:
+                result.append(f"输出文件: {self.output_file}")
+        else:
+            summary = []
+            if self.error_count > 0:
+                summary.append(f"{self.error_count} 个错误")
+            if self.warning_count > 0:
+                summary.append(f"{self.warning_count} 个警告")
+            if self.info_count > 0:
+                summary.append(f"{self.info_count} 个信息")
+                
+            if summary:
+                result.append("发现 " + "，".join(summary))
+                
+        if self.execution_time_ms is not None:
+            result.append(f"执行时间: {self.execution_time_ms}毫秒")
+            
+        # 添加单个错误
+        if self.errors:
+            result.append("\n错误:")
+            for error in self.errors:
+                error_str = error.to_str(show_file_path=show_file_path_in_errors)
+                # 缩进错误描述的每一行
+                indented_error = "\n  ".join(error_str.splitlines())
+                result.append(f"  {indented_error}")
+        
+        return "\n".join(result)
+
+class ProjectCompilationResult(BaseModel):
+    """整个项目的编译结果"""  
+    project_path: str = Field(..., description="被编译的项目路径")
+    file_results: Dict[str, FileCompilationResult] = Field(default_factory=dict, description="文件路径到其编译结果的映射")
+    total_files: int = Field(0, description="编译的文件总数")
+    files_with_errors: int = Field(0, description="至少有一个错误的文件数量")
+    total_errors: int = Field(0, description="所有文件中发现的错误总数")
+    total_warnings: int = Field(0, description="所有文件中的警告总数")
+    total_infos: int = Field(0, description="所有文件中的信息性问题总数")
+    success: bool = Field(True, description="整个项目的编译过程是否成功完成")
+    error_message: Optional[str] = Field(None, description="如果编译失败，错误消息")    
+    output_directory: Optional[str] = Field(None, description="编译输出的目录路径")
+
+    def to_str(self, include_all_files: bool = True, include_errors: bool = True) -> str:
+        """
+        将项目编译结果转换为人类可读的字符串
+        
+        参数:
+            include_all_files: 是否包含没有错误的文件的结果
+            include_errors: 是否包含单个错误的详细信息
+            
+        返回:
+            项目编译结果的格式化字符串表示
+        """
+        result = [f"项目编译结果 ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})"]
+        
+        result.append(f"项目: {self.project_path}")
+            
+        if not self.success:
+            result.append(f"错误: {self.error_message or '未知错误'}")            
+        
+        # 摘要信息
+        result.append(f"编译的文件: {self.total_files}")
+        
+        if self.success and self.total_errors == 0:
+            result.append("编译成功完成")
+            if self.output_directory:
+                result.append(f"输出目录: {self.output_directory}")
+        else:
+            result.append(f"有错误的文件: {self.files_with_errors}")
+            result.append(f"总错误数: {self.total_errors} ({self.total_errors} 个错误, {self.total_warnings} 个警告, {self.total_infos} 个信息)")
+        
+        # 添加每个文件的结果
+        if self.file_results:
+            result.append("\n按文件的结果:")
+            
+            for file_path, file_result in sorted(self.file_results.items()):
+                # 如果请求，跳过没有错误的文件
+                if not include_all_files and not (file_result.error_count + file_result.warning_count + file_result.info_count) > 0:
+                    continue
+                    
+                if include_errors:
+                    file_str = file_result.to_str(show_file_path_in_errors=False)
+                    # 缩进文件结果的每一行
+                    indented_file = "\n  ".join(file_str.splitlines())
+                    result.append(f"  {indented_file}")
+                else:
+                    # 每个文件只有一行摘要
+                    error_count = file_result.error_count + file_result.warning_count + file_result.info_count
+                    if error_count > 0:
+                        result.append(f"  {file_path}: {error_count} 个问题 ({file_result.error_count} 个错误, {file_result.warning_count} 个警告)")
+                    else:
+                        result.append(f"  {file_path}: 编译成功")
+                        
+                # 在文件之间添加分隔符以提高可读性
+                result.append("")
+        
+        return "\n".join(result)
+
+    def get_file_result(self, file_path: str) -> Optional[FileCompilationResult]:
+        """
+        获取特定文件的编译结果
+        
+        参数:
+            file_path: 文件路径
+            
+        返回:
+            文件的编译结果，如果文件未被编译则返回None
+        """
+        return self.file_results.get(file_path) 

autocoder/compilers/provided_compiler.py

@@ -0,0 +1,343 @@
+"""
+Module for compiling code based on a provided YAML configuration.
+This module reads from a compiler.yml file and runs the specified compilation command.
+"""
+
+import os
+import subprocess
+import re
+import yaml
+from typing import Dict, List, Any, Optional, Union
+import time
+from pathlib import Path
+
+from autocoder.compilers.base_compiler import BaseCompiler
+from autocoder.compilers.models import (
+    CompilationError,
+    FileCompilationResult,
+    ProjectCompilationResult,
+    CompilationErrorPosition,
+    CompilationErrorSeverity
+)
+
+
+class ProvidedCompiler(BaseCompiler):
+    """
+    A compiler that uses a provided YAML configuration to execute compilation commands.
+    It reads the configuration, runs the command, and processes the output based on
+    extraction patterns defined in the YAML.
+    """
+
+    def __init__(self, verbose: bool = False, config_path: Optional[str] = None):
+        """
+        Initialize the ProvidedCompiler.
+
+        Args:
+            verbose (bool): Whether to display verbose output.
+            config_path (Optional[str]): Path to the compiler.yml file. If None, will look in .auto-coder/projects/compiler.yml
+        """
+        super().__init__(verbose)
+        self.config_path = config_path or os.path.join(".auto-coder","projects","compiler.yml")
+        self.config = None
+
+    def get_supported_extensions(self) -> List[str]:
+        """
+        Get the list of file extensions supported by this compiler.
+        This is a generic compiler, so it returns an empty list as it doesn't target specific file types.
+
+        Returns:
+            List[str]: List of supported file extensions.
+        """
+        return []
+
+    def _check_dependencies(self) -> bool:
+        """
+        Check if required dependencies are installed.
+        For the provided compiler, we check if the compiler.yml file exists.
+
+        Returns:
+            bool: True if all dependencies are available, False otherwise.
+        """
+        return os.path.exists(self.config_path)
+
+    def _load_config(self) -> bool:
+        """
+        Load the compiler configuration from YAML file.
+
+        Returns:
+            bool: True if configuration was loaded successfully, False otherwise.
+        """
+        if not self._check_dependencies():
+            if self.verbose:
+                print(f"Configuration file not found: {self.config_path}")
+            return False
+
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                self.config = yaml.safe_load(f)
+
+            if not self.config or 'compilers' not in self.config:
+                if self.verbose:
+                    print(f"Invalid configuration file: 'compilers' section not found")
+                return False
+
+            return True
+        except Exception as e:
+            if self.verbose:
+                print(f"Error loading configuration: {str(e)}")
+            return False
+
+    def _run_compilation_command(self, project_path:str, compiler_config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Run the compilation command specified in the configuration.
+
+        Args:
+            compiler_config (Dict[str, Any]): Compiler configuration from YAML.
+
+        Returns:
+            Dict[str, Any]: Dictionary containing compilation results.
+        """
+        result = {
+            'success': True,
+            'errors': [],
+            'error_count': 0,
+            'warning_count': 0,
+            'info_count': 0,
+            'raw_output': "",
+        }
+
+        try:
+            working_dir = os.path.join(project_path,compiler_config.get('working_dir', '.'))
+            command = compiler_config.get('command')
+            args = compiler_config.get('args', [])
+            extract_regex = compiler_config.get('extract_regex')
+
+            if not command:
+                result['success'] = False
+                result['error_message'] = "No command specified in configuration"
+                return result
+
+            # Create the full command with arguments
+            full_command = [command] + args
+
+            # Record start time
+            start_time = time.time()
+
+            # Run the command
+            try:
+                # Ensure the working directory exists
+                os.makedirs(os.path.abspath(working_dir), exist_ok=True)
+
+                # Run the command in the specified working directory
+                process = subprocess.run(
+                    full_command,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    cwd=working_dir
+                )
+
+                # Combine stdout and stderr
+                output = process.stdout + process.stderr
+                result['raw_output'] = output
+
+                # Set success based on return code
+                result['success'] = process.returncode == 0
+
+                # If unsuccessful and no error message is set
+                if not result['success'] and not result.get('error_message'):
+                    result['error_message'] = f"Command failed with exit code {process.returncode}"
+
+                # Extract errors using regex if provided
+                if extract_regex and output:
+                    errors = self._extract_errors(
+                        output, extract_regex, working_dir)
+                    result['errors'] = errors
+                    result['error_count'] = sum(
+                        1 for e in errors if e.severity == CompilationErrorSeverity.ERROR)
+                    result['warning_count'] = sum(
+                        1 for e in errors if e.severity == CompilationErrorSeverity.WARNING)
+                    result['info_count'] = sum(
+                        1 for e in errors if e.severity == CompilationErrorSeverity.INFO)
+                elif not result['success']:
+                    result['errors'] = [CompilationError(
+                        file_path="",
+                        message=result['raw_output'],
+                        severity=CompilationErrorSeverity.ERROR,
+                        position=CompilationErrorPosition(                            
+                            line=-1                            
+                        ))]
+            except subprocess.SubprocessError as e:
+                result['success'] = False
+                result['error_message'] = f"Error executing command: {str(e)}"
+
+            # Calculate execution time
+            result['execution_time_ms'] = int(
+                (time.time() - start_time) * 1000)
+
+        except Exception as e:
+            result['success'] = False
+            result['error_message'] = f"Unexpected error: {str(e)}"
+
+        return result
+
+    def _extract_errors(self, output: str, regex_pattern: str, base_path: str) -> List[CompilationError]:
+        """
+        Extract errors from command output using the provided regex pattern.
+
+        Args:
+            output (str): Command output text.
+            regex_pattern (str): Regular expression to extract errors.
+            base_path (str): Base path for file references.
+
+        Returns:
+            List[CompilationError]: List of extracted compilation errors.
+        """
+        errors = []
+
+        try:
+            pattern = re.compile(regex_pattern)
+            matches = pattern.finditer(output)
+
+            for match in matches:
+                match_str = match.group(0)
+                errors.append(CompilationError(
+                    message=match_str,
+                    severity=CompilationErrorSeverity.ERROR,
+                    position=CompilationErrorPosition(
+                        file_path="",
+                        line=-1,
+                        column=-1
+                    )
+                ))
+        except Exception as e:
+            # If regex parsing fails, create a generic error
+            if self.verbose:
+                print(f"Error parsing regex: {str(e)}")
+
+        return errors
+
+    def compile_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        This compiler doesn't support compiling individual files directly.
+
+        Args:
+            file_path (str): Path to the file to compile.
+
+        Returns:
+            Dict[str, Any]: Error indicating that file compilation is not supported.
+        """
+        return {
+            'success': False,
+            'error_message': "ProvidedCompiler does not support compiling individual files.",
+            'file_path': file_path,
+            'language': 'unknown'
+        }
+
+    def compile_project(self, project_path: str,target_compiler_name:Optional[str] = None) -> ProjectCompilationResult:
+        """
+        Compile a project using configuration from compiler.yml.
+
+        Args:
+            project_path (str): Path to the project directory.
+
+        Returns:
+            Dict[str, Any]: Dictionary containing compilation results.
+        """
+        # Create a project compilation result
+        result = ProjectCompilationResult(
+            project_path=project_path,
+            success=True
+        )
+
+        # Load configuration
+        if not self._load_config():
+            result.success = False
+            result.error_message = f"Failed to load configuration from {self.config_path}"
+            return result
+        
+        target_compiler_config = None
+        if target_compiler_name:
+            for compiler_config in self.config.get('compilers', []):
+                if compiler_config.get("name","") == target_compiler_name:
+                    target_compiler_config = compiler_config
+                    break
+        
+        if not target_compiler_config:
+            result.success = False
+            result.error_message = f"Compiler {target_compiler_name} not found in configuration"
+            return result
+                
+        if self.verbose:
+            print(f"Running compiler: {target_compiler_name}")
+
+        # Run the compilation command
+        compile_result = self._run_compilation_command(project_path, target_compiler_config)
+        compile_errors:List[CompilationError] = compile_result['errors']
+        error_count = len(compile_errors)
+
+        result = ProjectCompilationResult(
+            project_path=project_path,            
+            success=compile_result['success'],
+            error_message=compile_result['error_message'],
+            file_results={
+                "1":FileCompilationResult(
+                file_path="1",  
+                language="unknown",              
+                errors=compile_errors,
+                warning_count= 0,
+                error_count= error_count,
+                info_count=0,
+                execution_time_ms=compile_result['execution_time_ms'],
+                output_file=None
+                )
+            },
+            total_errors=error_count,
+            total_warnings=0,
+            total_infos=0,
+            total_files= -1 ,
+            files_with_errors=error_count            
+        )
+
+        return result
+
+    def format_compile_result(self, compile_result: Union[ProjectCompilationResult, FileCompilationResult]) -> str:
+        """
+        Format compilation results into a human-readable string.
+
+        Args:
+            compile_result (Dict[str, Any]): The compilation result dictionary.
+
+        Returns:
+            str: A formatted string representation of the compilation results.
+        """
+        if isinstance(compile_result, dict) and 'project_path' in compile_result:
+            # This is a project compilation result
+            project_result = ProjectCompilationResult(**compile_result)
+            return project_result.to_str()
+        elif isinstance(compile_result, dict) and 'file_path' in compile_result:
+            # This is a file compilation result
+            file_result = FileCompilationResult(**compile_result)
+            return file_result.to_str()
+        else:
+            # For raw dictionary results
+            if compile_result.get('success', False):
+                return "Compilation successful"
+            else:
+                return f"Compilation failed: {compile_result.get('error_message', 'Unknown error')}"
+
+
+def compile_with_provided_config(project_path: str, config_path: Optional[str] = None, verbose: bool = False) -> Dict[str, Any]:
+    """
+    Utility function to compile a project using the provided configuration.
+
+    Args:
+        project_path (str): Path to the project directory.
+        config_path (Optional[str]): Path to the compiler.yml file. If None, will look in .auto-coder/projects/compiler.yml
+        verbose (bool): Whether to display verbose output.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing compilation results.
+    """
+    compiler = ProvidedCompiler(verbose=verbose, config_path=config_path)
+    return compiler.compile_project(project_path)