auto-coder 0.1.206__py3-none-any.whl → 0.1.208__py3-none-any.whl

autocoder/common/code_auto_generate_strict_diff.py

@@ -1,9 +1,11 @@
 from typing import List, Dict, Tuple
-from autocoder.common.types import Mode
+from autocoder.common.types import Mode, CodeGenerateResult
 from autocoder.common import AutoCoderArgs
 import byzerllm
 from autocoder.utils.queue_communicate import queue_communicate, CommunicateEvent, CommunicateEventType
 from autocoder.common import sys_prompt
+from concurrent.futures import ThreadPoolExecutor
+import json
 
 class CodeAutoGenerateStrictDiff:
     def __init__(
@@ -12,12 +14,15 @@ class CodeAutoGenerateStrictDiff:
         self.llm = llm
         self.args = args
         self.action = action
+        self.llms = []
+        self.generate_times_same_model = args.generate_times_same_model
         if not self.llm:
             raise ValueError(
                 "Please provide a valid model instance to use for code generation."
-            )
-        if self.llm.get_sub_client("code_model"):
-            self.llm = self.llm.get_sub_client("code_model")
+            )        
+        self.llms = self.llm.get_sub_client("code_model") or [self.llm]
+        if not isinstance(self.llms, list):
+            self.llms = [self.llms]
 
     @byzerllm.prompt(llm=lambda self: self.llm)
     def multi_round_instruction(
@@ -258,74 +263,106 @@ class CodeAutoGenerateStrictDiff:
 
     def single_round_run(
         self, query: str, source_content: str
-    ) -> Tuple[str, Dict[str, str]]:
+    ) -> CodeGenerateResult:
         llm_config = {"human_as_model": self.args.human_as_model}
 
-        if self.args.request_id and not self.args.skip_events:
-            queue_communicate.send_event_no_wait(
-                request_id=self.args.request_id,
-                event=CommunicateEvent(
-                    event_type=CommunicateEventType.CODE_GENERATE_START.value,
-                    data=query,
-                ),
+        if self.args.template == "common":
+            init_prompt = self.single_round_instruction.prompt(
+                instruction=query, content=source_content, context=self.args.context
+            )
+        elif self.args.template == "auto_implement":
+            init_prompt = self.auto_implement_function.prompt(
+                instruction=query, content=source_content
             )
-
-        init_prompt = self.single_round_instruction.prompt(
-            instruction=query, content=source_content, context=self.args.context
-        )
 
         with open(self.args.target_file, "w") as file:
             file.write(init_prompt)
 
         conversations = []
+
         if self.args.system_prompt and self.args.system_prompt.strip() == "claude":
-            conversations.append({"role": "system", "content": sys_prompt.claude_sys_prompt.prompt()})
+            conversations.append(
+                {"role": "system", "content": sys_prompt.claude_sys_prompt.prompt()})
         elif self.args.system_prompt:
-            conversations.append({"role": "system", "content": self.args.system_prompt})
-        
+            conversations.append(
+                {"role": "system", "content": self.args.system_prompt})
+
         conversations.append({"role": "user", "content": init_prompt})
 
-        t = self.llm.chat_oai(conversations=conversations, llm_config=llm_config)
-        conversations.append({"role": "assistant", "content": t[0].output})
+        if self.args.request_id and not self.args.skip_events:
+            _ = queue_communicate.send_event(
+                request_id=self.args.request_id,
+                event=CommunicateEvent(
+                    event_type=CommunicateEventType.CODE_GENERATE_START.value,
+                    data=json.dumps({}, ensure_ascii=False),
+                ),
+            )
+        
+        conversations_list = []
+        results = []
+        if not self.args.human_as_model:
+            with ThreadPoolExecutor(max_workers=len(self.llms) * self.generate_times_same_model) as executor:
+                futures = []
+                for llm in self.llms:
+                    for _ in range(self.generate_times_same_model):
+                        futures.append(executor.submit(
+                            llm.chat_oai, conversations=conversations, llm_config=llm_config))
+                results = [future.result()[0].output for future in futures]
+            for result in results:
+                conversations_list.append(
+                    conversations + [{"role": "assistant", "content": result}])
+        else:
+            results = []
+            conversations_list = []
+            for _ in range(self.args.human_model_num):
+                v = self.llms[0].chat_oai(
+                    conversations=conversations, llm_config=llm_config)
+                results.append(v[0].output)
+                conversations_list.append(conversations + [{"role": "assistant", "content": v[0].output}])
 
         if self.args.request_id and not self.args.skip_events:
-            queue_communicate.send_event_no_wait(
+            _ = queue_communicate.send_event(
                 request_id=self.args.request_id,
                 event=CommunicateEvent(
                     event_type=CommunicateEventType.CODE_GENERATE_END.value,
-                    data="",
+                    data=json.dumps({}, ensure_ascii=False),
                 ),
             )
 
-        return [t[0].output], conversations
+        return CodeGenerateResult(contents=results, conversations=conversations_list)
 
     def multi_round_run(
         self, query: str, source_content: str, max_steps: int = 10
-    ) -> Tuple[List[str], List[Dict[str, str]]]:
+    ) -> CodeGenerateResult:
         llm_config = {"human_as_model": self.args.human_as_model}
         result = []
 
-        init_prompt = self.multi_round_instruction.prompt(
-            instruction=query, content=source_content, context=self.args.context
-        )
+        if self.args.template == "common":
+            init_prompt = self.multi_round_instruction.prompt(
+                instruction=query, content=source_content, context=self.args.context
+            )
+        elif self.args.template == "auto_implement":
+            init_prompt = self.auto_implement_function.prompt(
+                instruction=query, content=source_content
+            )
 
-        conversations = [{"role": "user", "content": init_prompt}]
+        conversations = []
+        # conversations.append({"role": "system", "content": sys_prompt.prompt()})
+        conversations.append({"role": "user", "content": init_prompt})
 
         with open(self.args.target_file, "w") as file:
             file.write(init_prompt)
-
-        t = self.llm.chat_oai(conversations=conversations, llm_config=llm_config)
+        
+        code_llm = self.llms[0]
+        t = code_llm.chat_oai(conversations=conversations,
+                              llm_config=llm_config)
 
         result.append(t[0].output)
 
         conversations.append({"role": "assistant", "content": t[0].output})
 
-        if (
-            "__完成__" in t[0].output
-            or "/done" in t[0].output
-            or "__EOF__" in t[0].output
-        ):
-            return result, conversations
+        if "__完成__" in t[0].output or "/done" in t[0].output or "__EOF__" in t[0].output:
+            return CodeGenerateResult(contents=["\n\n".join(result)], conversations=[conversations])
 
         current_step = 0
 
@@ -336,17 +373,14 @@ class CodeAutoGenerateStrictDiff:
             with open(self.args.target_file, "w") as file:
                 file.write("继续")
 
-            t = self.llm.chat_oai(conversations=conversations, llm_config=llm_config)
+            t = code_llm.chat_oai(
+                conversations=conversations, llm_config=llm_config)
 
             result.append(t[0].output)
             conversations.append({"role": "assistant", "content": t[0].output})
             current_step += 1
 
-            if (
-                "__完成__" in t[0].output
-                or "/done" in t[0].output
-                or "__EOF__" in t[0].output
-            ):
-                return result, conversations
+            if "__完成__" in t[0].output or "/done" in t[0].output or "__EOF__" in t[0].output:
+                return CodeGenerateResult(contents=["\n\n".join(result)], conversations=[conversations])
 
-        return result, conversations
+        return CodeGenerateResult(contents=["\n\n".join(result)], conversations=[conversations])

autocoder/common/code_auto_merge.py

@@ -2,10 +2,12 @@
 import os
 from byzerllm.utils.client import code_utils
 from autocoder.common import AutoCoderArgs,git_utils
-from typing import List
+from typing import List,Union,Tuple
 import pydantic
 import byzerllm
 from loguru import logger
+from autocoder.common.types import CodeGenerateResult, MergeCodeWithoutEffect
+from autocoder.common.code_modification_ranker import CodeModificationRanker
 import hashlib
 
 class PathAndCode(pydantic.BaseModel):
@@ -58,7 +60,26 @@ class CodeAutoMerge:
             elif start_marker_count > 0:
                 block.append(line)                
 
-        return path_and_code_list     
+        return path_and_code_list
+
+    def merge_code(self, generate_result: CodeGenerateResult, force_skip_git: bool = False):
+        result = self.choose_best_choice(generate_result)
+        self._merge_code(result.contents[0], force_skip_git)
+        return result
+
+    def choose_best_choice(self, generate_result: CodeGenerateResult) -> CodeGenerateResult:
+        if len(generate_result.contents) == 1:
+            return generate_result
+
+        ranker = CodeModificationRanker(self.llm, self.args)
+        ranked_result = ranker.rank_modifications(generate_result)
+        # Filter out contents with failed blocks
+        for content,conversations in zip(ranked_result.contents,ranked_result.conversations):
+            merge_result = self._merge_code_without_effect(content)
+            if not merge_result.failed_blocks:
+                return CodeGenerateResult(contents=[content], conversations=[conversations])
+        # If all have failed blocks, return the first one
+        return CodeGenerateResult(contents=[ranked_result.contents[0]], conversations=[ranked_result.conversations[0]])
 
 
     def parse_text(self, text: str) -> List[PathAndCode]:
@@ -99,7 +120,34 @@ class CodeAutoMerge:
         Error: {{ error }}
         '''
 
-    def merge_code(self, content: str,force_skip_git:bool=False):        
+    def _merge_code_without_effect(self, content: str) -> MergeCodeWithoutEffect:
+        """Merge code without any side effects like git operations or file writing.
+        Returns a tuple of:
+        - list of (file_path, new_content) tuples for successfully merged blocks
+        - list of (file_path, content) tuples for failed to merge blocks"""
+        codes = self.parse_whole_text_v2(content)
+        file_content_mapping = {}
+        failed_blocks = []
+        
+        for block in codes:
+            file_path = block.path
+            if not os.path.exists(file_path):
+                file_content_mapping[file_path] = block.content
+            else:
+                if file_path not in file_content_mapping:
+                    with open(file_path, "r") as f:
+                        file_content_mapping[file_path] = f.read()
+                if file_content_mapping[file_path] != block.content:
+                    file_content_mapping[file_path] = block.content
+                else:
+                    failed_blocks.append((file_path, block.content))
+                
+        return MergeCodeWithoutEffect(
+            success_blocks=[(path, content) for path, content in file_content_mapping.items()],
+            failed_blocks=failed_blocks
+        )
+
+    def _merge_code(self, content: str,force_skip_git:bool=False):        
         total = 0
         
         file_content = open(self.args.file).read()
@@ -114,18 +162,6 @@ class CodeAutoMerge:
                 logger.error(self.git_require_msg(source_dir=self.args.source_dir,error=str(e)))
                 return            
 
-        # codes =  code_utils.extract_code(content)
-        # for (lang,code) in codes:            
-        #     parsed_blocks = self.parse_text(code)
-
-        #     for block in parsed_blocks:
-        #         file_path = block.path
-        #         os.makedirs(os.path.dirname(file_path), exist_ok=True)
-
-        #         with open(file_path, "w") as f:
-        #             logger.info(f"Upsert path: {file_path}")
-        #             total += 1
-        #             f.write(block.content)
         codes = self.parse_whole_text_v2(content)
         for block in codes:
             file_path = block.path

autocoder/common/code_auto_merge_diff.py

@@ -1,7 +1,7 @@
 import os
 import difflib
 from autocoder.common import AutoCoderArgs,git_utils
-from typing import List
+from typing import List,Union,Tuple
 import pydantic
 import byzerllm
 from loguru import logger
@@ -15,6 +15,8 @@ from autocoder.common.search_replace import (
     flexible_search_and_replace,
     search_and_replace,
 )
+from autocoder.common.types import CodeGenerateResult, MergeCodeWithoutEffect
+from autocoder.common.code_modification_ranker import CodeModificationRanker
 
 class PathAndCode(pydantic.BaseModel):
     path: str
@@ -374,6 +376,25 @@ class CodeAutoMergeDiff:
             edits.append((path, hunk))
 
         return edits
+
+    def merge_code(self, generate_result: CodeGenerateResult, force_skip_git: bool = False):
+        result = self.choose_best_choice(generate_result)
+        self._merge_code(result.contents[0], force_skip_git)
+        return result
+
+    def choose_best_choice(self, generate_result: CodeGenerateResult) -> CodeGenerateResult:
+        if len(generate_result.contents) == 1:
+            return generate_result
+
+        ranker = CodeModificationRanker(self.llm, self.args)
+        ranked_result = ranker.rank_modifications(generate_result)
+        # Filter out contents with failed blocks
+        for content,conversations in zip(ranked_result.contents,ranked_result.conversations):
+            merge_result = self._merge_code_without_effect(content)
+            if not merge_result.failed_blocks:
+                return CodeGenerateResult(contents=[content], conversations=[conversations])
+        # If all have failed blocks, return the first one
+        return CodeGenerateResult(contents=[ranked_result.contents[0]], conversations=[ranked_result.conversations[0]])
     
     @byzerllm.prompt(render="jinja2")
     def git_require_msg(self,source_dir:str,error:str)->str:
@@ -450,7 +471,39 @@ class CodeAutoMergeDiff:
                 errors += other_hunks_applied
             raise ValueError(errors)    
 
-    def merge_code(self, content: str,force_skip_git:bool=False):        
+    def _merge_code_without_effect(self, content: str) -> MergeCodeWithoutEffect:
+        """Merge code without any side effects like git operations or file writing.
+        Returns a tuple of:
+        - list of (file_path, new_content) tuples for successfully merged blocks
+        - list of (file_path, hunk) tuples for failed to merge blocks"""
+        edits = self.get_edits(content)
+        file_content_mapping = {}
+        failed_blocks = []
+        
+        for path, hunk in edits:
+            full_path = self.abs_root_path(path)
+            if not os.path.exists(full_path):
+                _, after = hunk_to_before_after(hunk)
+                file_content_mapping[full_path] = after
+                continue
+                
+            if full_path not in file_content_mapping:
+                with open(full_path, "r") as f:
+                    file_content_mapping[full_path] = f.read()
+            
+            content = file_content_mapping[full_path]
+            new_content = do_replace(full_path, content, hunk)
+            if new_content:
+                file_content_mapping[full_path] = new_content
+            else:
+                failed_blocks.append((full_path, "\n".join(hunk)))
+                
+        return MergeCodeWithoutEffect(
+            success_blocks=[(path, content) for path, content in file_content_mapping.items()],
+            failed_blocks=failed_blocks
+        )
+
+    def _merge_code(self, content: str,force_skip_git:bool=False):        
         total = 0
         
         file_content = open(self.args.file).read()

autocoder/common/code_auto_merge_editblock.py

@@ -7,7 +7,6 @@ from autocoder.utils.queue_communicate import (
     CommunicateEvent,
     CommunicateEventType,
 )
-from typing import List
 import pydantic
 import byzerllm
 from loguru import logger
@@ -18,6 +17,9 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.syntax import Syntax
 import json
+from typing import Union, List, Tuple
+from autocoder.common.types import CodeGenerateResult, MergeCodeWithoutEffect
+from autocoder.common.code_modification_ranker import CodeModificationRanker
 
 
 class PathAndCode(pydantic.BaseModel):
@@ -138,7 +140,7 @@ class CodeAutoMergeEditBlock:
             elif end_marker(line, index) and start_marker_count == 1:
                 start_marker_count -= 1
                 if block:
-                    if current_editblock_mode == "two_line_mode":                        
+                    if current_editblock_mode == "two_line_mode":
                         path = block[0].split(":", 1)[1].strip()
                         content = "\n".join(block[1:])
                     else:
@@ -152,6 +154,25 @@ class CodeAutoMergeEditBlock:
 
         return path_and_code_list
 
+    def merge_code(self, generate_result: CodeGenerateResult, force_skip_git: bool = False):
+        result = self.choose_best_choice(generate_result)
+        self._merge_code(result.contents[0], force_skip_git)
+        return result
+
+    def choose_best_choice(self, generate_result: CodeGenerateResult) -> CodeGenerateResult:
+        if len(generate_result.contents) == 1:
+            return generate_result
+
+        ranker = CodeModificationRanker(self.llm, self.args)
+        ranked_result = ranker.rank_modifications(generate_result)
+        # Filter out contents with failed blocks
+        for content,conversations in zip(ranked_result.contents,ranked_result.conversations):
+            merge_result = self._merge_code_without_effect(content)
+            if not merge_result.failed_blocks:
+                return CodeGenerateResult(contents=[content], conversations=[conversations])
+        # If all have failed blocks, return the first one
+        return CodeGenerateResult(contents=[ranked_result.contents[0]], conversations=[ranked_result.conversations[0]])
+
     @byzerllm.prompt()
     def git_require_msg(self, source_dir: str, error: str) -> str:
         """
@@ -197,9 +218,57 @@ class CodeAutoMergeEditBlock:
                 if in_updated:
                     updates.append(line)
             result.append((edit.path, "\n".join(heads), "\n".join(updates)))
-        return result
+        return result        
+
+    def _merge_code_without_effect(self, content: str) -> MergeCodeWithoutEffect:
+        """Merge code without any side effects like git operations, linting or file writing.
+        Returns a tuple of:
+        - list of (file_path, new_content) tuples for successfully merged blocks
+        - list of (file_path, head, update) tuples for failed to merge blocks"""
+        codes = self.get_edits(content)
+        file_content_mapping = {}
+        failed_blocks = []
+
+        for block in codes:
+            file_path, head, update = block
+            if not os.path.exists(file_path):
+                file_content_mapping[file_path] = update
+            else:
+                if file_path not in file_content_mapping:
+                    with open(file_path, "r") as f:
+                        temp = f.read()
+                        file_content_mapping[file_path] = temp
+                existing_content = file_content_mapping[file_path]
+
+                # First try exact match
+                new_content = (
+                    existing_content.replace(head, update, 1)
+                    if head
+                    else existing_content + "\n" + update
+                )
+
+                # If exact match fails, try similarity match
+                if new_content == existing_content and head:
+                    similarity, best_window = TextSimilarity(
+                        head, existing_content
+                    ).get_best_matching_window()
+                    if similarity > self.args.editblock_similarity:
+                        new_content = existing_content.replace(
+                            best_window, update, 1
+                        )
 
-    def merge_code(self, content: str, force_skip_git: bool = False):
+                if new_content != existing_content:
+                    file_content_mapping[file_path] = new_content
+                else:
+                    failed_blocks.append((file_path, head, update))
+
+        return MergeCodeWithoutEffect(
+            success_blocks=[(path, content)
+                            for path, content in file_content_mapping.items()],
+            failed_blocks=failed_blocks
+        )
+
+    def _merge_code(self, content: str, force_skip_git: bool = False):
         file_content = open(self.args.file).read()
         md5 = hashlib.md5(file_content.encode("utf-8")).hexdigest()
         file_name = os.path.basename(self.args.file)
@@ -207,15 +276,15 @@ class CodeAutoMergeEditBlock:
         codes = self.get_edits(content)
         changes_to_make = []
         changes_made = False
-        unmerged_blocks = []  
-        merged_blocks = []      
+        unmerged_blocks = []
+        merged_blocks = []
 
         # First, check if there are any changes to be made
         file_content_mapping = {}
         for block in codes:
             file_path, head, update = block
             if not os.path.exists(file_path):
-                changes_to_make.append((file_path, None, update))                
+                changes_to_make.append((file_path, None, update))
                 file_content_mapping[file_path] = update
                 merged_blocks.append((file_path, "", update, 1))
                 changes_made = True
@@ -235,7 +304,7 @@ class CodeAutoMergeEditBlock:
                         (file_path, existing_content, new_content))
                     file_content_mapping[file_path] = new_content
                     merged_blocks.append((file_path, head, update, 1))
-                    changes_made = True                    
+                    changes_made = True
                 else:
                     # If the SEARCH BLOCK is not found exactly, then try to use
                     # the similarity ratio to find the best matching block
@@ -250,8 +319,9 @@ class CodeAutoMergeEditBlock:
                                 (file_path, existing_content, new_content)
                             )
                             file_content_mapping[file_path] = new_content
-                            merged_blocks.append((file_path, head, update, similarity))
-                            changes_made = True                            
+                            merged_blocks.append(
+                                (file_path, head, update, similarity))
+                            changes_made = True
                     else:
                         unmerged_blocks.append(
                             (file_path, head, update, similarity))
@@ -317,10 +387,10 @@ class CodeAutoMergeEditBlock:
                 file_path, head, update, similarity = code
                 event_data.append(
                     {
-                            "file_path": file_path,
-                            "head": head,
-                            "update": update,
-                            "similarity": similarity,
+                        "file_path": file_path,
+                        "head": head,
+                        "update": update,
+                        "similarity": similarity,
                     }
                 )
 

autocoder/common/code_auto_merge_strict_diff.py

@@ -2,12 +2,14 @@ import os
 import difflib
 import diff_match_patch as dmp_module
 from autocoder.common import AutoCoderArgs, git_utils
-from typing import List
+from typing import List,Tuple
 import pydantic
 import byzerllm
 from loguru import logger
 import hashlib
 from pathlib import Path
+from autocoder.common.types import CodeGenerateResult, MergeCodeWithoutEffect
+from autocoder.common.code_modification_ranker import CodeModificationRanker
 
 class PathAndCode(pydantic.BaseModel):
     path: str
@@ -125,7 +127,26 @@ class CodeAutoMergeStrictDiff:
             elif start_marker_count > 0:
                 block.append(line)                
 
-        return path_and_code_list    
+        return path_and_code_list
+
+    def merge_code(self, generate_result: CodeGenerateResult, force_skip_git: bool = False):
+        result = self.choose_best_choice(generate_result)
+        self._merge_code(result.contents[0], force_skip_git)
+        return result
+
+    def choose_best_choice(self, generate_result: CodeGenerateResult) -> CodeGenerateResult:
+        if len(generate_result.contents) == 1:
+            return generate_result
+
+        ranker = CodeModificationRanker(self.llm, self.args)
+        ranked_result = ranker.rank_modifications(generate_result)
+        # Filter out contents with failed blocks
+        for content,conversations in zip(ranked_result.contents,ranked_result.conversations):
+            merge_result = self._merge_code_without_effect(content)
+            if not merge_result.failed_blocks:
+                return CodeGenerateResult(contents=[content], conversations=[conversations])
+        # If all have failed blocks, return the first one
+        return CodeGenerateResult(contents=[ranked_result.contents[0]], conversations=[ranked_result.conversations[0]])
     
 
     def abs_root_path(self, path):
@@ -134,7 +155,52 @@ class CodeAutoMergeStrictDiff:
         res = Path(self.args.source_dir) / path
         return safe_abs_path(res)            
 
-    def merge_code(self, content: str, force_skip_git: bool = False):        
+    def _merge_code_without_effect(self, content: str) -> MergeCodeWithoutEffect:
+        """Merge code without any side effects like git operations or file writing.
+        Returns a tuple of:
+        - list of (file_path, new_content) tuples for successfully merged blocks
+        - list of (file_path, content) tuples for failed to merge blocks"""
+        diff_blocks = self.parse_diff_block(content)
+        file_content_mapping = {}
+        failed_blocks = []
+        
+        for block in diff_blocks:
+            path = block.path
+            content = block.content
+            full_path = self.abs_root_path(path)
+            
+            if not os.path.exists(full_path):
+                file_content_mapping[full_path] = content
+                continue
+                
+            if full_path not in file_content_mapping:
+                with open(full_path, "r") as f:
+                    file_content_mapping[full_path] = f.read()
+            
+            try:
+                import patch
+                patch_obj = patch.fromstring(content.encode('utf-8'))
+                root_path = None
+                if not path.startswith(self.args.source_dir):
+                    root_path = self.args.source_dir
+
+                # Create a copy of the content to apply patch
+                temp_content = file_content_mapping[full_path]
+                success = patch_obj.apply(root=root_path, content=temp_content)
+                if success:
+                    file_content_mapping[full_path] = temp_content
+                else:
+                    failed_blocks.append((full_path, content))
+            except Exception as e:
+                logger.warning(f"Failed to apply patch to {full_path}: {str(e)}")
+                failed_blocks.append((full_path, content))
+                
+        return MergeCodeWithoutEffect(
+            success_blocks=[(path, content) for path, content in file_content_mapping.items()],
+            failed_blocks=failed_blocks
+        )
+
+    def _merge_code(self, content: str, force_skip_git: bool = False):        
         total = 0
         
         file_content = open(self.args.file).read()
@@ -154,35 +220,6 @@ class CodeAutoMergeStrictDiff:
             path = diff_blocks.path
             content = diff_blocks.content          
 
-            # unidiff_patch = unidiff.PatchSet(content)
-            # dmp_patches = []
-            # for patched_file in unidiff_patch:
-            #     diffs = []
-            #     start_line = 0
-            #     for hunk in patched_file:
-            #         start_line = hunk.target_start - 1  # 获取hunk的起始位置
-            #         for line in hunk:
-            #             if line.is_added:
-            #                 diffs.append(dmp_module.diff('', line.value.strip(), start_line))
-            #                 start_line += 1
-            #             elif line.is_removed:
-            #                 diffs.append(dmp_module.diff(line.value.strip(), '', start_line))
-            #             else:
-            #                 start_line += 1
-            #     patch_text = dmp.patch_make(diffs)
-            #     dmp_patches.extend(patch_text)
-            
-            # with open(path, 'r') as f:
-            #     original_content = f.read()
-                
-            # dmp = dmp_module.diff_match_patch()            
-            # new_text, results = dmp.patch_apply(dmp_patches, original_content)            
-            # if any(results) is False:
-            #     raise Exception("Error applying diff to file: " + path)
-            # with open(self.abs_root_path(path), 'w') as f:
-            #     f.write(new_text)
-            # total += 1 
-
             import patch
             patch_obj = patch.fromstring(content.encode('utf-8'))
             root_path = None