auto-coder 0.1.304__py3-none-any.whl → 0.1.306__py3-none-any.whl

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,9 +193,17 @@ def stream_out(
         model_name: 模型名称
         title: 面板标题，如果没有提供则使用默认值
         args: AutoCoderArgs对象
+        display_func: 可选的显示函数
+        extra_meta: 额外的元数据
+        cancel_token: 可选的取消令牌
     Returns:
         Tuple[str, Dict[SingleOutputMeta]]: 返回完整的响应内容和最后的元数据
     """
+    if args is None:
+        import traceback
+        traceback.print_stack()
+        print("=="*100)
+
     if console is None:
         console = Console(force_terminal=True, color_system="auto", height=None)
     
@@ -197,10 +231,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 +344,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)}",  

autocoder/utils/project_structure.py

@@ -169,7 +169,41 @@ class EnhancedFileAnalyzer:
 
     def _basic_analysis(self, extensions: Set[str]) -> Dict:
         """基于规则的基础分析"""
-        CODE_EXTS = {'.py', '.js', '.ts', '.java', '.c', '.cpp'}
+        CODE_EXTS = {
+            # 通用脚本语言
+            '.py',  # Python
+            '.js', '.jsx', '.ts', '.tsx',  # JavaScript/TypeScript
+            '.rb', '.erb',  # Ruby
+            '.php',  # PHP
+            '.pl', '.pm',  # Perl
+            
+            # 编译型语言
+            '.java', '.kt', '.groovy',  # JVM系
+            '.c', '.cpp', '.cc', '.cxx', '.h', '.hpp',  # C/C++
+            '.cs',  # C#
+            '.go',  # Go
+            '.rs',  # Rust
+            '.swift',  # Swift
+            
+            # Web开发
+            '.vue', '.svelte',  # 前端框架
+            '.html', '.htm',  # HTML
+            '.css', '.scss', '.sass', '.less',  # 样式表
+            
+            # 其他语言
+            '.scala',  # Scala
+            '.clj',  # Clojure
+            '.coffee',  # CoffeeScript
+            '.lua',  # Lua
+            '.r',  # R
+            '.sh', '.bash',  # Shell脚本
+            '.sql',  # SQL
+            '.dart',  # Dart
+            '.ex', '.exs',  # Elixir
+            '.fs', '.fsx',  # F#
+            '.hs',  # Haskell
+            '.ml', '.mli'  # OCaml
+        }
         CONFIG_EXTS = {'.yml', '.yaml', '.json', '.toml', '.ini'}
 
         return {

autocoder/utils/thread_utils.py

@@ -1,161 +1,22 @@
-from concurrent.futures import ThreadPoolExecutor, TimeoutError, CancelledError
-from threading import Event
-from inspect import signature
 from functools import wraps
-from typing import Any, Optional
+from typing import Any, Optional, Dict, Callable
 import threading
-import logging
 import time
-from autocoder.common.global_cancel import global_cancel
+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
 
-class CancellationRequested(Exception):
-    """Raised when a task is requested to be cancelled."""
-    pass
+printer = Printer()
 
-
-def run_in_thread(timeout: Optional[float] = None):
-    """Decorator that runs a function in a thread with signal handling.
-    
-    Args:
-        timeout (float, optional): Maximum time to wait for thread completion in seconds.
-            If None, will wait indefinitely.
-            
-    The decorated function will run in a separate thread and can be interrupted by
-    signals like Ctrl+C (KeyboardInterrupt). When interrupted, it will log the event
-    and clean up gracefully.
-    """
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            with ThreadPoolExecutor(max_workers=1) as executor:
-                future = executor.submit(func, *args, **kwargs)
-                start_time = time.time()
-                
-                while True:
-                    try:
-                        # 使用较短的超时时间进行轮询，确保能够响应中断信号
-                        poll_timeout = 0.1
-                        if timeout is not None:
-                            remaining = timeout - (time.time() - start_time)
-                            if remaining <= 0:
-                                future.cancel()
-                                raise TimeoutError(f"Timeout after {timeout}s in {func.__name__}")
-                            poll_timeout = min(poll_timeout, remaining)
-                            
-                        try:
-                            return future.result(timeout=poll_timeout)
-                        except TimeoutError:
-                            continue  # 继续轮询
-                            
-                    except KeyboardInterrupt:
-                        logging.warning("KeyboardInterrupt received, attempting to cancel task...")
-                        future.cancel()
-                        raise
-                    except Exception as e:
-                        logging.error(f"Error occurred in thread: {str(e)}")
-                        raise
-        return wrapper
-    return decorator
-
-def run_in_thread_with_cancel(timeout: Optional[float] = None):
-    """Decorator that runs a function in a thread with explicit cancellation support.
-    
-    Args:
-        timeout (float, optional): Maximum time to wait for thread completion in seconds.
-            If None, will wait indefinitely.
-            
-    The decorated function MUST accept 'cancel_event' as its first parameter.
-    This cancel_event is a threading.Event object that can be used to check if
-    cancellation has been requested.
-    
-    The decorated function can be called with an external cancel_event passed as a keyword argument.
-    If not provided, a new Event will be created.
-    
-    Example:
-        @run_in_thread_with_cancel(timeout=10)
-        def long_task(cancel_event, arg1, arg2):
-            while not cancel_event.is_set():
-                # do work
-                if cancel_event.is_set():
-                    raise CancellationRequested()
-                    
-        # 使用外部传入的cancel_event
-        external_cancel = Event()
-        try:
-            result = long_task(arg1, arg2, cancel_event=external_cancel)
-        except CancelledError:
-            print("Task was cancelled")
-            
-        # 在其他地方取消任务
-        external_cancel.set()
-    """
-    def decorator(func):
-        # 检查函数签名
-        sig = signature(func)
-        params = list(sig.parameters.keys())
-        if not params or params[0] != 'cancel_event':
-            raise ValueError(
-                f"Function {func.__name__} must have 'cancel_event' as its first parameter. "
-                f"Current parameters: {params}"
-            )
-        
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # 从kwargs中提取或创建cancel_event
-            cancel_event = kwargs.pop('cancel_event', None) or Event()
-            
-            def cancellable_task():
-                try:
-                    return func(cancel_event, *args, **kwargs)
-                except CancellationRequested:
-                    logging.info(f"Task {func.__name__} was cancelled")
-                    raise
-                except Exception as e:
-                    logging.error(f"Error in {func.__name__}: {str(e)}")
-                    raise
-            
-            with ThreadPoolExecutor(max_workers=1) as executor:
-                future = executor.submit(cancellable_task)
-                start_time = time.time()
-                
-                while True:
-                    try:
-                        # 使用较短的超时时间进行轮询，确保能够响应中断信号
-                        poll_timeout = 0.1
-                        if timeout is not None:
-                            remaining = timeout - (time.time() - start_time)
-                            if remaining <= 0:
-                                cancel_event.set()
-                                future.cancel()
-                                raise TimeoutError(f"Timeout after {timeout}s in {func.__name__}")
-                            poll_timeout = min(poll_timeout, remaining)
-                            
-                        try:
-                            return future.result(timeout=poll_timeout)
-                        except TimeoutError:
-                            continue  # 继续轮询
-                            
-                    except KeyboardInterrupt:
-                        logging.warning(f"KeyboardInterrupt received, cancelling {func.__name__}...")
-                        cancel_event.set()
-                        future.cancel()
-                        raise CancelledError("Task cancelled by user")
-                    except CancellationRequested:
-                        logging.info(f"Task {func.__name__} was cancelled")
-                        raise CancelledError("Task cancelled by request")
-                    except Exception as e:
-                        logging.error(f"Error occurred in thread: {str(e)}")
-                        raise
-                        
-        return wrapper
-    return decorator
-
-
-def run_in_raw_thread():
+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:
-        func: The function to run in a thread
+        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
@@ -166,28 +27,36 @@ def run_in_raw_thread():
     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):
+    def decorator(func: Callable):
 
         @wraps(func)
         def wrapper(*args, **kwargs):
             # Store thread results
             result = []
-            exception = []            
-            def worker():            
-                try:
-                    # 如果刚开始就遇到了,可能是用户中断的还没有释放
-                    # 等待五秒后强行释放
-                    if global_cancel.requested:
-                        time.sleep(5)
-                        global_cancel.reset()
-                    
+            exception_raised = [None]  # 存储工作线程中的异常
+            thread_token = token
+            thread_context = context or {}
+            thread_terminated = threading.Event()  # 用于标记线程是否已终止
+            
+            def worker():
+                try:                                        
+                    # 执行用户函数
                     ret = func(*args, **kwargs)
                     result.append(ret)
-                    global_cancel.reset()                
+                except CancelRequestedException as e:
+                    # 处理取消异常
+                    printer.print_in_terminal("generation_cancelled")
+                    exception_raised[0] = e
                 except Exception as e:
-                    global_cancel.reset()
-                    raise
+                    # 存储其他异常
+                    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")
@@ -195,16 +64,56 @@ def run_in_raw_thread():
             
             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:  
-                global_cancel.set()                              
-                raise KeyboardInterrupt("Task was cancelled by user")
-            except Exception as e:
-                global_cancel.reset()
-                raise
+                
+            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    

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.304"
+__version__ = "0.1.306"