auto-coder 0.1.303__tar.gz → 0.1.305__tar.gz

{auto_coder-0.1.303 → auto_coder-0.1.305}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.303
+Version: 0.1.305
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.303
+Version: 0.1.305
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/auto_coder_runner.py

@@ -2594,7 +2594,7 @@ def conf_import(path: str):
 def auto_command(query: str,extra_args: Dict[str,Any]={}):
     """处理/auto指令"""
     from autocoder.commands.auto_command import CommandAutoTuner, AutoCommandRequest, CommandConfig, MemoryConfig
-    args = get_final_config()            
+    args = get_final_config()       
 
     # 准备请求参数
     request = AutoCommandRequest(

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/chat_auto_coder.py

@@ -623,7 +623,7 @@ def main():
 
             elif user_input.startswith("/auto"):
                 query = user_input[len("/auto") :].strip()
-                auto_command(ARGS, query)
+                auto_command(query)
             elif user_input.startswith("/debug"):
                 code = user_input[len("/debug") :].strip()
                 try:

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/commands/auto_command.py

@@ -500,10 +500,7 @@ class CommandAutoTuner:
         result_manager = ResultManager()
 
         while True:
-            if global_cancel.requested:
-                printer = Printer(console)
-                printer.print_in_terminal("generation_cancelled")
-                break
+            global_cancel.check_and_raise()
             # 执行命令
             command = response.suggestions[0].command
             parameters = response.suggestions[0].parameters

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/commands/auto_web.py

@@ -794,15 +794,7 @@ class AutoWebTuner:
             logger.info(f"开始执行迭代 {iterations}/{max_iterations}")
 
             # 检查是否需要取消操作
-            if global_cancel.requested:
-                logger.info("检测到取消请求，停止操作")
-                self.printer.print_in_terminal(
-                    "operation_cancelled", style="yellow")
-                return AutoWebResponse(
-                    explanation="操作已取消",
-                    overall_status="cancelled",
-                    actions=[]
-                )
+            global_cancel.check_and_raise()
 
             # 如果没有更多操作，认为任务完成
             if not plan.actions:

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/common/auto_coder_lang.py

@@ -66,6 +66,11 @@ MESSAGES = {
         "index_related_files_fail": "⚠️ Failed to find related files for chunk {{ chunk_count }}",
         "index_file_removed": "🗑️ Removed non-existent file index: {{ file_path }}",
         "index_file_saved": "💾 Saved index file, updated {{ updated_files }} files, removed {{ removed_files }} files, input_tokens: {{ input_tokens }}, output_tokens: {{ output_tokens }}, input_cost: {{ input_cost }}, output_cost: {{ output_cost }}",
+        "task_cancelled_by_user": "Task was cancelled by user",
+        "cancellation_requested": "Cancellation requested, waiting for thread to terminate...",
+        "force_terminating_thread": "Force terminating thread after timeout",
+        "force_raising_keyboard_interrupt": "Force raising KeyboardInterrupt after timeout",
+        "thread_terminated": "Thread terminated",
         "human_as_model_instructions": (
             "You are now in Human as Model mode. The content has been copied to your clipboard.\n"
             "The system is waiting for your input. When finished, enter 'EOF' on a new line to submit.\n"
@@ -156,7 +161,6 @@ MESSAGES = {
         "generated_shell_script": "Generated Shell Script",
         "confirm_execute_shell_script": "Do you want to execute this shell script?",
         "shell_script_not_executed": "Shell script was not executed",
-        "conf_not_found": "Configuration file not found: {{path}}",
         "index_export_success": "Index exported successfully: {{path}}",
         "index_import_success": "Index imported successfully: {{path}}",
         "edits_title": "edits",
@@ -279,6 +283,11 @@ MESSAGES = {
         "index_related_files_fail": "⚠️ 无法为块 {{ chunk_count }} 找到相关文件",
         "index_file_removed": "🗑️ 已移除不存在的文件索引：{{ file_path }}",
         "index_file_saved": "💾 已保存索引文件，更新了 {{ updated_files }} 个文件，移除了 {{ removed_files }} 个文件，输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}, 输入成本: {{ input_cost }}, 输出成本: {{ output_cost }}",
+        "task_cancelled_by_user": "任务被用户取消",
+        "cancellation_requested": "已请求取消，正在等待线程终止...",
+        "force_terminating_thread": "线程超时强制终止",
+        "force_raising_keyboard_interrupt": "超时强制抛出键盘中断异常",
+        "thread_terminated": "线程已终止",
         "human_as_model_instructions": (
             "您现在处于人类作为模型模式。内容已复制到您的剪贴板。\n"
             "系统正在等待您的输入。完成后，在新行输入'EOF'提交。\n"

auto_coder-0.1.305/src/autocoder/common/global_cancel.py

@@ -0,0 +1,82 @@
+import threading
+from typing import Dict, Optional, Any
+
+class CancelRequestedException(Exception):
+    """当取消请求被触发时抛出的异常"""
+    def __init__(self, token: Optional[str] = None, message: str = "Operation was cancelled"):
+        self.token = token
+        self.message = message
+        super().__init__(self.message)
+
+class GlobalCancel:
+    def __init__(self):
+        self._global_flag = False
+        self._token_flags: Dict[str, bool] = {}
+        self._lock = threading.Lock()
+        self._context: Dict[str, Any] = {}  # 存储与取消相关的上下文信息
+    
+    @property
+    def requested(self) -> bool:
+        """检查是否请求了全局取消（向后兼容）"""
+        with self._lock:
+            return self._global_flag
+    
+    def is_requested(self, token: Optional[str] = None) -> bool:
+        """检查是否请求了特定token或全局的取消"""
+        with self._lock:
+            # 全局标志总是优先
+            if self._global_flag:
+                return True
+            # 如果提供了token，检查该token的标志
+            if token is not None and token in self._token_flags:
+                return self._token_flags[token]
+            return False
+    
+    def set(self, token: Optional[str] = None, context: Optional[Dict[str, Any]] = None) -> None:
+        """设置特定token或全局的取消标志"""
+        with self._lock:
+            if token is None:
+                self._global_flag = True
+            else:
+                self._token_flags[token] = True
+            
+            # 存储上下文
+            if context:
+                if token is None:
+                    self._context.update(context)
+                else:
+                    if "tokens" not in self._context:
+                        self._context["tokens"] = {}
+                    self._context["tokens"][token] = context
+    
+    def reset(self, token: Optional[str] = None) -> None:
+        """重置特定token或全局的取消标志"""
+        with self._lock:
+            if token is None:
+                # 全局重置
+                self._global_flag = False
+                self._token_flags.clear()
+                self._context.clear()
+            else:
+                # 特定token重置
+                if token in self._token_flags:
+                    del self._token_flags[token]
+                if "tokens" in self._context and token in self._context["tokens"]:
+                    del self._context["tokens"][token]
+    
+    def get_context(self, token: Optional[str] = None) -> Dict[str, Any]:
+        """获取与取消相关的上下文信息"""
+        with self._lock:
+            if token is None:
+                return self._context.copy()
+            if "tokens" in self._context and token in self._context["tokens"]:
+                return self._context["tokens"][token].copy()
+            return {}
+    
+    def check_and_raise(self, token: Optional[str] = None) -> None:
+        """检查是否请求了取消，如果是则抛出异常"""
+        if self.is_requested(token):
+            context = self.get_context(token)
+            raise CancelRequestedException(token, context.get("message", "Operation was cancelled"))
+
+global_cancel = GlobalCancel()

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/dispacher/actions/action.py

@@ -112,10 +112,7 @@ class ActionTSProject(BaseAction):
                     f"Content(send to model) is {content_length} tokens, which is larger than the maximum input length {self.args.model_max_input_length}"
                 )
 
-        if global_cancel.requested:
-            printer = Printer()
-            raise Exception(printer.get_message_from_key(
-                "generation_cancelled"))
+        global_cancel.check_and_raise()
 
         if args.execute:
             self.printer.print_in_terminal("code_generation_start")
@@ -181,10 +178,7 @@ class ActionTSProject(BaseAction):
                     action_file=self.args.file
                 ).to_dict())
 
-            if global_cancel.requested:
-                printer = Printer()
-                raise Exception(printer.get_message_from_key(
-                    "generation_cancelled"))
+            global_cancel.check_and_raise()
 
             merge_result = None
             if args.execute and args.auto_merge:
@@ -249,10 +243,7 @@ class ActionPyScriptProject(BaseAction):
 
     def process_content(self, source_code_list: SourceCodeList):
         args = self.args
-        if global_cancel.requested:
-            printer = Printer()
-            raise Exception(printer.get_message_from_key(
-                "generation_cancelled"))
+        global_cancel.check_and_raise()
 
         if args.execute:
             self.printer.print_in_terminal("code_generation_start")
@@ -318,10 +309,7 @@ class ActionPyScriptProject(BaseAction):
                     action_file=self.args.file
                 ).to_dict())
 
-            if global_cancel.requested:
-                printer = Printer()
-                raise Exception(printer.get_message_from_key(
-                    "generation_cancelled"))
+            global_cancel.check_and_raise()
 
             merge_result = None
             if args.execute and args.auto_merge:
@@ -410,10 +398,7 @@ class ActionPyProject(BaseAction):
                     max_length=self.args.model_max_input_length
                 )
 
-        if global_cancel.requested:
-            printer = Printer()
-            raise Exception(printer.get_message_from_key(
-                "generation_cancelled"))
+        global_cancel.check_and_raise()
 
         if args.execute:
             self.printer.print_in_terminal("code_generation_start")
@@ -479,10 +464,7 @@ class ActionPyProject(BaseAction):
                     action_file=self.args.file
                 ).to_dict())
 
-            if global_cancel.requested:
-                printer = Printer()
-                raise Exception(printer.get_message_from_key(
-                    "generation_cancelled"))
+            global_cancel.check_and_raise()
 
             merge_result = None
             if args.execute and args.auto_merge:
@@ -563,10 +545,7 @@ class ActionSuffixProject(BaseAction):
                     f"Content(send to model) is {content_length} tokens, which is larger than the maximum input length {self.args.model_max_input_length}"
                 )
 
-        if global_cancel.requested:
-            printer = Printer()
-            raise Exception(printer.get_message_from_key(
-                "generation_cancelled"))
+        global_cancel.check_and_raise()
 
         if args.execute:
             self.printer.print_in_terminal("code_generation_start")
@@ -631,10 +610,7 @@ class ActionSuffixProject(BaseAction):
                     action_file=self.args.file
                 ).to_dict())
 
-        if global_cancel.requested:
-            printer = Printer()
-            raise Exception(printer.get_message_from_key(
-                "generation_cancelled"))
+        global_cancel.check_and_raise()
 
         merge_result = None
         if args.execute and args.auto_merge:

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/dispacher/actions/plugins/action_regex_project.py

@@ -66,9 +66,7 @@ class ActionRegexProject:
 
         start_time = time.time()
         
-        if global_cancel.requested:
-            printer = Printer()            
-            raise Exception(printer.get_message_from_key("generation_cancelled")) 
+        global_cancel.check_and_raise()
         
         if args.execute:
             self.printer.print_in_terminal("code_generation_start")
@@ -128,9 +126,7 @@ class ActionRegexProject:
                     action_file=self.args.file
                 ).to_dict())
 
-            if global_cancel.requested:
-                printer = Printer()            
-                raise Exception(printer.get_message_from_key("generation_cancelled")) 
+            global_cancel.check_and_raise()
             
             merge_result = None
             if args.execute and args.auto_merge:

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/index/index.py

@@ -296,8 +296,7 @@ class IndexManager:
         return False
 
     def build_index_for_single_source(self, source: SourceCode):
-        if global_cancel.requested:
-            return None
+        global_cancel.check_and_raise()
 
         file_path = source.module_name
         if not os.path.exists(file_path):
@@ -552,8 +551,7 @@ class IndexManager:
                 for source in wait_to_build_files
             ]
             for future in as_completed(futures):
-                if global_cancel.requested:
-                    break
+                global_cancel.check_and_raise()
                 result = future.result()
                 if result is not None:
                     counter += 1

{auto_coder-0.1.303 → auto_coder-0.1.305}/src/autocoder/utils/auto_coder_utils/chat_stream_out.py

@@ -13,7 +13,7 @@ from autocoder.utils.request_queue import request_queue
 import time
 from byzerllm.utils.types import SingleOutputMeta
 from autocoder.common import AutoCoderArgs
-from autocoder.common.global_cancel import global_cancel
+from autocoder.common.global_cancel import global_cancel, CancelRequestedException
 from autocoder.events.event_manager_singleton import get_event_manager
 from autocoder.events import event_content as EventContentCreator
 from autocoder.events.event_types import EventMetadata
@@ -68,23 +68,35 @@ class MultiStreamRenderer:
             
     def _process_stream(self, 
                        stream_idx: int, 
-                       stream_generator: Generator[Tuple[str, Dict[str, Any]], None, None]):
+                       stream_generator: Generator[Tuple[str, Dict[str, Any]], None, None],
+                       cancel_token: Optional[str] = None):
         """Process a single stream in a separate thread"""
         stream = self.streams[stream_idx]
         try:
             for content, meta in stream_generator:
+                try:
+                    # 使用新的异常机制检查取消请求
+                    global_cancel.check_and_raise(cancel_token)
+                except CancelRequestedException:
+                    break
+                    
                 if content:
                     stream.update(content)
+        except CancelRequestedException:
+            # 处理取消异常
+            stream.update("\n\n**Operation was cancelled**")
         finally:
             stream.complete()
 
     def render_streams(self, 
-                      stream_generators: List[Generator[Tuple[str, Dict[str, Any]], None, None]]) -> List[str]:
+                      stream_generators: List[Generator[Tuple[str, Dict[str, Any]], None, None]],
+                      cancel_token: Optional[str] = None) -> List[str]:
         """
         Render multiple streams simultaneously
         
         Args:
             stream_generators: List of stream generators to render
+            cancel_token: Optional cancellation token
             
         Returns:
             List of final content from each stream
@@ -94,7 +106,7 @@ class MultiStreamRenderer:
         # Start processing threads
         threads = []
         for i, generator in enumerate(stream_generators):
-            thread = Thread(target=self._process_stream, args=(i, generator))
+            thread = Thread(target=self._process_stream, args=(i, generator, cancel_token))
             thread.daemon = True
             thread.start()
             threads.append(thread)
@@ -102,6 +114,13 @@ class MultiStreamRenderer:
         try:
             with Live(self.layout, console=self.console, refresh_per_second=10) as live:
                 while any(not stream.is_complete for stream in self.streams):
+                    try:
+                        # 使用新的异常机制检查取消请求
+                        global_cancel.check_and_raise(cancel_token)
+                    except CancelRequestedException:
+                        print("\nCancelling streams...")
+                        break
+                        
                     # Update all panels
                     for i, stream in enumerate(self.streams):
                         panel = Panel(
@@ -116,7 +135,11 @@ class MultiStreamRenderer:
                     time.sleep(0.1)  # Prevent excessive CPU usage
                     
         except KeyboardInterrupt:
+            # 键盘中断时设置取消标志
+            global_cancel.set(cancel_token, {"message": "Keyboard interrupt"})
             print("\nStopping streams...")
+        except CancelRequestedException:
+            print("\nCancelling streams...")
             
         # Wait for all threads to complete
         for thread in threads:
@@ -128,7 +151,8 @@ def multi_stream_out(
     stream_generators: List[Generator[Tuple[str, Dict[str, Any]], None, None]],
     titles: List[str],
     layout: str = "horizontal",
-    console: Optional[Console] = None
+    console: Optional[Console] = None,
+    cancel_token: Optional[str] = None
 ) -> List[str]:
     """
     Render multiple streams with Rich
@@ -138,12 +162,13 @@ def multi_stream_out(
         titles: List of titles for each stream
         layout: "horizontal" or "vertical"
         console: Optional Rich console instance
+        cancel_token: Optional cancellation token
         
     Returns:
         List of final content from each stream
     """
     renderer = MultiStreamRenderer(titles, layout, console)
-    return renderer.render_streams(stream_generators)
+    return renderer.render_streams(stream_generators, cancel_token)
 
 
 def stream_out(
@@ -155,7 +180,8 @@ def stream_out(
     final_title: Optional[str] = None,
     args: Optional[AutoCoderArgs] = None,
     display_func: Optional[Callable] = None,
-    extra_meta: Dict[str, Any] = {}
+    extra_meta: Dict[str, Any] = {},
+    cancel_token: Optional[str] = None
 ) -> Tuple[str, Optional[SingleOutputMeta]]:
     """
     处理流式输出事件并在终端中展示
@@ -167,6 +193,9 @@ def stream_out(
         model_name: 模型名称
         title: 面板标题，如果没有提供则使用默认值
         args: AutoCoderArgs对象
+        display_func: 可选的显示函数
+        extra_meta: 额外的元数据
+        cancel_token: 可选的取消令牌
     Returns:
         Tuple[str, Dict[SingleOutputMeta]]: 返回完整的响应内容和最后的元数据
     """
@@ -197,10 +226,8 @@ def stream_out(
             console=console
         ) as live:
             for res in stream_generator:
-                if global_cancel.requested:
-                    printer = Printer(console)
-                    printer.print_in_terminal("generation_cancelled")                    
-                    break
+                global_cancel.check_and_raise(cancel_token)
+                    
                 last_meta = res[1]                
                 content = res[0]
 
@@ -312,6 +339,24 @@ def stream_out(
                 )
             )            
             
+    except CancelRequestedException as cancel_exc:
+        # 捕获取消异常，显示取消信息
+        console.print(Panel(
+            "Generation was cancelled",  
+            title=f"Cancelled[ {panel_title} ]",
+            border_style="yellow"
+        ))
+        
+        if request_id and request_queue:
+            request_queue.add_request(
+                request_id,
+                RequestValue(
+                    value=StreamValue(value=["Operation was cancelled"]), 
+                    status=RequestOption.FAILED
+                ),
+            )
+        raise cancel_exc   
+    
     except Exception as e:
         console.print(Panel(
             f"Error: {str(e)}",  

auto_coder-0.1.305/src/autocoder/utils/thread_utils.py

@@ -0,0 +1,119 @@
+from functools import wraps
+from typing import Any, Optional, Dict, Callable
+import threading
+import time
+from autocoder.common.global_cancel import global_cancel, CancelRequestedException
+from autocoder.common.printer import Printer
+from autocoder.common.auto_coder_lang import get_message, get_message_with_format
+from autocoder.events.event_manager_singleton import get_event_manager
+from autocoder.events import event_content as EventContentCreator
+from autocoder.events.event_types import EventMetadata
+
+printer = Printer()
+
+def run_in_raw_thread(token: Optional[str] = None, context: Optional[Dict[str, Any]] = None):
+    """A decorator that runs a function in a separate thread and handles exceptions.
+    
+    Args:
+        token (Optional[str]): Optional cancellation token for this specific thread
+        context (Optional[Dict[str, Any]]): Optional context information for cancellation
+        
+    Returns:
+        A wrapper function that executes the decorated function in a thread
+        
+    The decorator will:
+    1. Run the function in a separate thread
+    2. Handle KeyboardInterrupt properly
+    3. Propagate exceptions from the thread
+    4. Support function arguments
+    5. Preserve function metadata
+    6. Support token-based cancellation
+    7. Provide context information for cancellation
+    """
+    def decorator(func: Callable):
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Store thread results
+            result = []
+            exception_raised = [None]  # 存储工作线程中的异常
+            thread_token = token
+            thread_context = context or {}
+            thread_terminated = threading.Event()  # 用于标记线程是否已终止
+            
+            def worker():
+                try:                                        
+                    # 执行用户函数
+                    ret = func(*args, **kwargs)
+                    result.append(ret)
+                except CancelRequestedException as e:
+                    # 处理取消异常
+                    printer.print_in_terminal("generation_cancelled")
+                    exception_raised[0] = e
+                except Exception as e:
+                    # 存储其他异常
+                    exception_raised[0] = e
+                finally:
+                    # 无论如何执行完毕后，重置取消标志并标记线程已终止
+                    global_cancel.reset(thread_token)
+                    thread_terminated.set()
+            
+            # Create and start thread with a meaningful name
+            thread = threading.Thread(target=worker, name=f"{func.__name__}_thread")
+            thread.daemon = True  # Make thread daemon so it doesn't prevent program exit
+            
+            try:
+                thread.start()
+                
+                # Poll thread status with timeout to allow for interruption
+                cancelled_by_keyboard = False
+                max_wait_time = 30  # 最大等待时间（秒）
+                wait_start_time = time.time()
+                
+                while thread.is_alive():
+                    # 每次等待较短时间，以便能够及时响应中断
+                    thread.join(0.1)
+                    
+                    # 检查是否已经超过最大等待时间（仅适用于已取消的情况）
+                    elapsed_time = time.time() - wait_start_time
+                    if cancelled_by_keyboard and elapsed_time > max_wait_time:
+                        printer.print_in_terminal("force_terminating_thread")
+                        break
+                    
+                    # 检查线程间的取消请求
+                    if global_cancel.is_requested(thread_token):
+                        # 传播取消请求到工作线程
+                        raise CancelRequestedException(thread_token)
+
+                # 如果工作线程出现了异常，在主线程中重新抛出
+                if exception_raised[0] is not None:
+                    raise exception_raised[0]
+                    
+                # 返回结果
+                return result[0] if result else None            
+                
+            except KeyboardInterrupt:
+                # 设置取消标志
+                cancel_context = {"message": get_message("task_cancelled_by_user"), "source": "keyboard_interrupt"}
+                cancel_context.update(thread_context)
+                global_cancel.set(thread_token, cancel_context)
+                printer.print_in_terminal("cancellation_requested")
+
+                # 标记为键盘中断取消
+                cancelled_by_keyboard = True
+                wait_start_time = time.time()
+                
+                # 等待线程终止或检测到取消
+                while thread.is_alive() and not thread_terminated.is_set():
+                    thread.join(0.5)
+                    elapsed_time = time.time() - wait_start_time
+                    if elapsed_time > max_wait_time:
+                        printer.print_in_terminal("force_raising_keyboard_interrupt")
+                        break
+                
+                # 如果线程已终止且有异常，优先抛出该异常
+                if exception_raised[0] is not None:
+                    raise exception_raised[0]                                                
+                
+        return wrapper
+    return decorator    

auto_coder-0.1.305/src/autocoder/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.305"

auto_coder-0.1.303/src/autocoder/common/global_cancel.py

@@ -1,21 +0,0 @@
-import threading
-
-class GlobalCancel:
-    def __init__(self):
-        self._flag = False
-        self._lock = threading.Lock()
-    
-    @property
-    def requested(self):
-        with self._lock:
-            return self._flag
-    
-    def set(self):
-        with self._lock:
-            self._flag = True
-    
-    def reset(self):
-        with self._lock:
-            self._flag = False
-
-global_cancel = GlobalCancel()