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

autocoder/common/search_replace_patch/manager.py

@@ -0,0 +1,248 @@
+"""
+Search Replace Manager - unified interface for different replacement strategies
+"""
+
+from typing import List, Tuple, Optional, Dict, Any
+from loguru import logger
+
+from .base import BaseReplacer, ReplaceResult, ReplaceStrategy
+from .string_replacer import StringReplacer
+from .patch_replacer import PatchReplacer
+from .similarity_replacer import SimilarityReplacer
+
+
+class SearchReplaceManager:
+    """搜索替换管理器 - 统一管理多种替换策略"""
+    
+    def __init__(self, default_strategy: ReplaceStrategy = ReplaceStrategy.STRING):
+        """
+        初始化搜索替换管理器
+        
+        Args:
+            default_strategy: 默认的替换策略
+        """
+        self.default_strategy = default_strategy
+        self.replacers: Dict[ReplaceStrategy, BaseReplacer] = {}
+        self._initialize_replacers()
+    
+    def _initialize_replacers(self):
+        """初始化所有替换器"""
+        try:
+            # 初始化字符串替换器
+            self.replacers[ReplaceStrategy.STRING] = StringReplacer(lenient_mode=True)
+            logger.info("Initialized StringReplacer")
+        except Exception as e:
+            logger.error(f"Failed to initialize StringReplacer: {e}")
+        
+        try:
+            # 初始化补丁替换器
+            self.replacers[ReplaceStrategy.PATCH] = PatchReplacer(use_patch_ng=True)
+            logger.info("Initialized PatchReplacer")
+        except Exception as e:
+            logger.error(f"Failed to initialize PatchReplacer: {e}")
+        
+        try:
+            # 初始化相似度替换器
+            self.replacers[ReplaceStrategy.SIMILARITY] = SimilarityReplacer(similarity_threshold=0.99)
+            logger.info("Initialized SimilarityReplacer")
+        except Exception as e:
+            logger.error(f"Failed to initialize SimilarityReplacer: {e}")
+    
+    def get_replacer(self, strategy: ReplaceStrategy) -> Optional[BaseReplacer]:
+        """
+        获取指定策略的替换器
+        
+        Args:
+            strategy: 替换策略
+            
+        Returns:
+            对应的替换器实例，如果不存在则返回 None
+        """
+        return self.replacers.get(strategy)
+    
+    def replace(self, content: str, search_blocks: List[Tuple[str, str]], 
+                strategy: Optional[ReplaceStrategy] = None) -> ReplaceResult:
+        """
+        执行文本替换
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            strategy: 指定的替换策略，如果为None则使用默认策略
+            
+        Returns:
+            ReplaceResult: 替换结果
+        """
+        if strategy is None:
+            strategy = self.default_strategy
+        
+        replacer = self.get_replacer(strategy)
+        if not replacer:
+            return ReplaceResult(
+                success=False,
+                message=f"Replacer for strategy '{strategy.value}' not available",
+                total_count=len(search_blocks)
+            )
+        
+        logger.info(f"Using {strategy.value} strategy for replacement")
+        return replacer.replace(content, search_blocks)
+    
+    def replace_with_fallback(self, content: str, search_blocks: List[Tuple[str, str]], 
+                              fallback_strategies: Optional[List[ReplaceStrategy]] = None) -> ReplaceResult:
+        """
+        使用回退策略进行文本替换
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            fallback_strategies: 回退策略列表，默认为 [STRING, SIMILARITY, PATCH]
+            
+        Returns:
+            ReplaceResult: 替换结果
+        """
+        if fallback_strategies is None:
+            fallback_strategies = [
+                ReplaceStrategy.STRING,
+                ReplaceStrategy.SIMILARITY,
+                ReplaceStrategy.PATCH,
+            ]
+        
+        last_result = None
+        
+        for strategy in fallback_strategies:
+            replacer = self.get_replacer(strategy)
+            if not replacer:
+                logger.warning(f"Replacer for strategy '{strategy.value}' not available, skipping")
+                continue
+            
+            if not replacer.can_handle(content, search_blocks):
+                logger.warning(f"Replacer '{strategy.value}' cannot handle the given content, skipping")
+                continue
+            
+            logger.info(f"Trying {strategy.value} strategy for replacement")
+            result = replacer.replace(content, search_blocks)
+            
+            if result.success:
+                logger.info(f"Successfully replaced using {strategy.value} strategy")
+                result.metadata['used_strategy'] = strategy.value
+                result.metadata['fallback_used'] = len(fallback_strategies) > 1
+                return result
+            else:
+                logger.warning(f"Failed to replace using {strategy.value} strategy: {result.message}")
+                last_result = result
+        
+        # 如果所有策略都失败了，返回最后一个结果
+        if last_result:
+            last_result.metadata['all_strategies_failed'] = True
+            last_result.metadata['tried_strategies'] = [s.value for s in fallback_strategies]
+            return last_result
+        
+        return ReplaceResult(
+            success=False,
+            message="No suitable replacer found for the given content",
+            total_count=len(search_blocks)
+        )
+    
+    def get_available_strategies(self) -> List[ReplaceStrategy]:
+        """
+        获取所有可用的替换策略
+        
+        Returns:
+            可用的替换策略列表
+        """
+        return list(self.replacers.keys())
+    
+    def set_default_strategy(self, strategy: ReplaceStrategy):
+        """
+        设置默认替换策略
+        
+        Args:
+            strategy: 新的默认策略
+        """
+        if strategy in self.replacers:
+            self.default_strategy = strategy
+            logger.info(f"Default strategy set to {strategy.value}")
+        else:
+            logger.warning(f"Strategy {strategy.value} not available, default strategy unchanged")
+    
+    def configure_replacer(self, strategy: ReplaceStrategy, **kwargs):
+        """
+        配置指定替换器的参数
+        
+        Args:
+            strategy: 替换策略
+            **kwargs: 配置参数
+        """
+        replacer = self.get_replacer(strategy)
+        if not replacer:
+            logger.warning(f"Replacer for strategy '{strategy.value}' not available")
+            return
+        
+        try:
+            if strategy == ReplaceStrategy.STRING and isinstance(replacer, StringReplacer):
+                if 'lenient_mode' in kwargs:
+                    replacer.lenient_mode = kwargs['lenient_mode']
+                    logger.info(f"StringReplacer lenient_mode set to {kwargs['lenient_mode']}")
+            
+            elif strategy == ReplaceStrategy.PATCH and isinstance(replacer, PatchReplacer):
+                if 'use_patch_ng' in kwargs:
+                    replacer.use_patch_ng = kwargs['use_patch_ng']
+                    replacer._load_patch_module()
+                    logger.info(f"PatchReplacer use_patch_ng set to {kwargs['use_patch_ng']}")
+            
+            elif strategy == ReplaceStrategy.SIMILARITY and isinstance(replacer, SimilarityReplacer):
+                if 'similarity_threshold' in kwargs:
+                    replacer.set_similarity_threshold(kwargs['similarity_threshold'])
+                    
+        except Exception as e:
+            logger.error(f"Failed to configure {strategy.value} replacer: {e}")
+    
+    def get_replacer_info(self, strategy: ReplaceStrategy) -> Dict[str, Any]:
+        """
+        获取替换器信息
+        
+        Args:
+            strategy: 替换策略
+            
+        Returns:
+            替换器信息字典
+        """
+        replacer = self.get_replacer(strategy)
+        if not replacer:
+            return {'available': False, 'strategy': strategy.value}
+        
+        info = {
+            'available': True,
+            'strategy': strategy.value,
+            'class_name': replacer.__class__.__name__
+        }
+        
+        # 添加特定替换器的信息
+        try:
+            if strategy == ReplaceStrategy.STRING and isinstance(replacer, StringReplacer):
+                info['lenient_mode'] = replacer.lenient_mode
+            elif strategy == ReplaceStrategy.PATCH and isinstance(replacer, PatchReplacer):
+                info['use_patch_ng'] = replacer.use_patch_ng
+                info['patch_module_available'] = replacer._patch_module is not None
+            elif strategy == ReplaceStrategy.SIMILARITY and isinstance(replacer, SimilarityReplacer):
+                info['similarity_threshold'] = replacer.similarity_threshold
+        except Exception as e:
+            logger.warning(f"Failed to get detailed info for {strategy.value}: {e}")
+        
+        return info
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        获取管理器状态
+        
+        Returns:
+            状态信息字典
+        """
+        return {
+            'default_strategy': self.default_strategy.value,
+            'available_strategies': [s.value for s in self.get_available_strategies()],
+            'replacer_info': {
+                strategy.value: self.get_replacer_info(strategy)
+                for strategy in ReplaceStrategy
+            }
+        } 

autocoder/common/search_replace_patch/patch_replacer.py

@@ -0,0 +1,304 @@
+"""
+Patch-based text replacer implementation
+"""
+
+import tempfile
+import os
+from typing import List, Tuple, Optional
+from loguru import logger
+
+from .base import BaseReplacer, ReplaceResult, ReplaceStrategy
+
+
+class PatchReplacer(BaseReplacer):
+    """基于补丁库的文本替换器"""
+    
+    def __init__(self, use_patch_ng: bool = True):
+        """
+        初始化补丁替换器
+        
+        Args:
+            use_patch_ng: 是否使用 patch-ng 库（True）还是 unidiff 库（False）
+        """
+        super().__init__(ReplaceStrategy.PATCH)
+        self.use_patch_ng = use_patch_ng
+        self._patch_module = None
+        self._load_patch_module()
+    
+    def _load_patch_module(self):
+        """加载补丁模块"""
+        try:
+            if self.use_patch_ng:
+                try:
+                    import patch_ng
+                    self._patch_module = patch_ng
+                    logger.info("Loaded patch-ng module")
+                except ImportError:
+                    logger.warning("patch-ng not available, falling back to unidiff")
+                    self.use_patch_ng = False
+            
+            if not self.use_patch_ng:
+                try:
+                    import unidiff
+                    self._patch_module = unidiff
+                    logger.info("Loaded unidiff module")
+                except ImportError:
+                    logger.error("Neither patch-ng nor unidiff is available")
+                    self._patch_module = None
+                    
+        except Exception as e:
+            logger.error(f"Failed to load patch module: {e}")
+            self._patch_module = None
+    
+    def _search_blocks_to_unified_diff(self, search_blocks: List[Tuple[str, str]], 
+                                       filename: str = "file.txt") -> str:
+        """
+        将搜索替换块转换为统一差异格式
+        
+        Args:
+            search_blocks: 搜索替换块列表
+            filename: 文件名（用于生成diff头）
+            
+        Returns:
+            统一差异格式的字符串
+        """
+        # 为了简化，我们假设每个搜索块都是完整的替换
+        # 实际应用中可能需要更复杂的逻辑来生成正确的unified diff
+        
+        diff_lines = []
+        diff_lines.append(f"--- a/{filename}")
+        diff_lines.append(f"+++ b/{filename}")
+        
+        for i, (search_text, replace_text) in enumerate(search_blocks):
+            search_lines = search_text.splitlines()
+            replace_lines = replace_text.splitlines()
+            
+            # 生成hunk头
+            diff_lines.append(f"@@ -{i+1},{len(search_lines)} +{i+1},{len(replace_lines)} @@")
+            
+            # 添加删除行
+            for line in search_lines:
+                diff_lines.append(f"-{line}")
+            
+            # 添加添加行
+            for line in replace_lines:
+                diff_lines.append(f"+{line}")
+        
+        return "\n".join(diff_lines) + "\n"
+    
+    def _apply_patch_ng(self, content: str, diff_content: str, filename: str) -> Optional[str]:
+        """
+        使用 patch-ng 应用补丁
+        
+        Args:
+            content: 原始内容
+            diff_content: 差异内容
+            filename: 文件名
+            
+        Returns:
+            应用补丁后的内容，失败时返回 None
+        """
+        try:
+            patchset = self._patch_module.PatchSet.from_string(diff_content)
+            
+            # 创建临时文件
+            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
+                f.write(content)
+                temp_file = f.name
+            
+            try:
+                # 应用补丁
+                if patchset.apply(root=os.path.dirname(temp_file)):
+                    with open(temp_file, 'r', encoding='utf-8') as f:
+                        return f.read()
+                else:
+                    logger.error("Failed to apply patch using patch-ng")
+                    return None
+            finally:
+                # 清理临时文件
+                if os.path.exists(temp_file):
+                    os.unlink(temp_file)
+                    
+        except Exception as e:
+            logger.error(f"Error applying patch with patch-ng: {e}")
+            return None
+    
+    def _apply_unidiff(self, content: str, diff_content: str, filename: str) -> Optional[str]:
+        """
+        使用 unidiff 应用补丁
+        
+        Args:
+            content: 原始内容
+            diff_content: 差异内容
+            filename: 文件名
+            
+        Returns:
+            应用补丁后的内容，失败时返回 None
+        """
+        try:
+            patchset = self._patch_module.PatchSet(diff_content)
+            
+            if not patchset:
+                logger.error("No patches found in diff content")
+                return None
+            
+            # 取第一个补丁文件
+            patch_file = patchset[0]
+            
+            # 将内容分割为行
+            lines = content.splitlines(keepends=True)
+            
+            # 应用补丁
+            try:
+                new_lines = self._apply_patch_to_lines(lines, patch_file)
+                return ''.join(new_lines)
+            except Exception as e:
+                logger.error(f"Error applying patch to lines: {e}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error applying patch with unidiff: {e}")
+            return None
+    
+    def _apply_patch_to_lines(self, lines: List[str], patch_file) -> List[str]:
+        """
+        将补丁应用到行列表
+        
+        Args:
+            lines: 原始行列表
+            patch_file: 补丁文件对象
+            
+        Returns:
+            应用补丁后的行列表
+        """
+        new_lines = lines.copy()
+        
+        # 按照行号倒序处理hunks，避免行号偏移问题
+        for hunk in reversed(patch_file):
+            target_line = hunk.target_start - 1  # 转换为0索引
+            
+            # 删除旧行
+            lines_to_remove = [line for line in hunk if line.is_removed]
+            for _ in lines_to_remove:
+                if target_line < len(new_lines):
+                    new_lines.pop(target_line)
+            
+            # 添加新行
+            lines_to_add = [line.value for line in hunk if line.is_added]
+            for i, line_value in enumerate(lines_to_add):
+                new_lines.insert(target_line + i, line_value)
+        
+        return new_lines
+    
+    def replace(self, content: str, search_blocks: List[Tuple[str, str]]) -> ReplaceResult:
+        """
+        执行基于补丁的替换
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            ReplaceResult: 替换结果
+        """
+        if not self._patch_module:
+            return ReplaceResult(
+                success=False,
+                message="No patch module available. Please install patch-ng or unidiff",
+                total_count=len(search_blocks)
+            )
+        
+        if not self.validate_search_blocks(search_blocks):
+            return ReplaceResult(
+                success=False,
+                message="Invalid search blocks provided",
+                total_count=len(search_blocks)
+            )
+        
+        try:
+            # 检查是否有插入操作
+            insert_blocks = [(i, replace_text) for i, (search_text, replace_text) in enumerate(search_blocks) if search_text == ""]
+            regular_blocks = [(search_text, replace_text) for search_text, replace_text in search_blocks if search_text != ""]
+            
+            current_content = content
+            applied_count = 0
+            
+            # 先处理插入操作
+            for i, insert_text in insert_blocks:
+                # 插入到文件开头
+                if not insert_text.endswith(("\n", "\r\n")):
+                    insert_text += "\n"
+                
+                current_content = insert_text + current_content
+                applied_count += 1
+                logger.info(f"Patch replacer inserted block {i+1}/{len(search_blocks)} at file head")
+            
+            # 如果没有常规替换块，直接返回插入结果
+            if not regular_blocks:
+                return ReplaceResult(
+                    success=True,
+                    message=f"Successfully inserted {applied_count} blocks at file head",
+                    new_content=current_content,
+                    applied_count=applied_count,
+                    total_count=len(search_blocks),
+                    metadata={
+                        'strategy': self.get_strategy_name(),
+                        'patch_module': 'patch-ng' if self.use_patch_ng else 'unidiff'
+                    }
+                )
+            
+            # 处理常规替换块
+            # 将搜索替换块转换为统一差异格式
+            diff_content = self._search_blocks_to_unified_diff(regular_blocks)
+            logger.debug(f"Generated diff content:\n{diff_content}")
+            
+            # 应用补丁
+            if self.use_patch_ng:
+                new_content = self._apply_patch_ng(current_content, diff_content, "file.txt")
+            else:
+                new_content = self._apply_unidiff(current_content, diff_content, "file.txt")
+            
+            if new_content is not None:
+                return ReplaceResult(
+                    success=True,
+                    message=f"Successfully applied patch with {len(regular_blocks)} blocks and {len(insert_blocks)} inserts",
+                    new_content=new_content,
+                    applied_count=applied_count + len(regular_blocks),
+                    total_count=len(search_blocks),
+                    metadata={
+                        'strategy': self.get_strategy_name(),
+                        'patch_module': 'patch-ng' if self.use_patch_ng else 'unidiff'
+                    }
+                )
+            else:
+                return ReplaceResult(
+                    success=applied_count > 0,
+                    message=f"Failed to apply patch for regular blocks, but {applied_count} inserts succeeded",
+                    new_content=current_content if applied_count > 0 else None,
+                    applied_count=applied_count,
+                    total_count=len(search_blocks),
+                    errors=["Patch application failed for regular blocks"]
+                )
+                
+        except Exception as e:
+            logger.error(f"Error in patch replacement: {e}")
+            return ReplaceResult(
+                success=False,
+                message=f"Error in patch replacement: {str(e)}",
+                total_count=len(search_blocks),
+                errors=[str(e)]
+            )
+    
+    def can_handle(self, content: str, search_blocks: List[Tuple[str, str]]) -> bool:
+        """
+        检查是否能处理给定的内容和搜索块
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            bool: 是否能处理
+        """
+        return (self._patch_module is not None and 
+                self.validate_search_blocks(search_blocks))