auto-coder 0.1.277__tar.gz → 0.1.279__tar.gz

{auto_coder-0.1.277 → auto_coder-0.1.279}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.277
+Version: 0.1.279
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -26,7 +26,7 @@ Requires-Dist: tabulate
 Requires-Dist: jupyter_client
 Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
-Requires-Dist: byzerllm[saas]>=0.1.169
+Requires-Dist: byzerllm[saas]>=0.1.170
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-0.1.277 → auto_coder-0.1.279}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.277
+Version: 0.1.279
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -26,7 +26,7 @@ Requires-Dist: tabulate
 Requires-Dist: jupyter_client
 Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
-Requires-Dist: byzerllm[saas]>=0.1.169
+Requires-Dist: byzerllm[saas]>=0.1.170
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-0.1.277 → auto_coder-0.1.279}/src/auto_coder.egg-info/requires.txt

@@ -16,7 +16,7 @@ tabulate
 jupyter_client
 prompt-toolkit
 tokenizers
-byzerllm[saas]>=0.1.169
+byzerllm[saas]>=0.1.170
 patch
 diff_match_patch
 GitPython

{auto_coder-0.1.277 → auto_coder-0.1.279}/src/autocoder/commands/auto_command.py

@@ -23,6 +23,7 @@ from autocoder.rag.token_counter import count_tokens
 from autocoder.common.global_cancel import global_cancel
 from autocoder.common.auto_configure import config_readme
 from autocoder.utils.auto_project_type import ProjectTypeAnalyzer
+from rich.text import Text
 
 class CommandMessage(BaseModel):
     role: str
@@ -435,8 +436,10 @@ class CommandAutoTuner:
                     "command_execution_result", 
                     action=action
                 )
+                # 转义内容，避免Rich将内容中的[]解释为markup语法                
+                text_content = Text(truncated_content)
                 console.print(Panel(
-                    truncated_content,
+                    text_content,
                     title=title,
                     border_style="blue",
                     padding=(1, 2)

{auto_coder-0.1.277 → auto_coder-0.1.279}/src/autocoder/common/shells.py

@@ -11,6 +11,9 @@ from rich.panel import Panel
 from rich.text import Text
 from rich.live import Live
 import getpass
+from rich.markup import escape
+import threading
+import queue
 
 from autocoder.common.result_manager import ResultManager
 
@@ -356,7 +359,7 @@ def _win_code_page_to_encoding(code_page: str) -> str:
 
 def execute_shell_command(command: str):
     """
-    Execute a shell command with cross-platform encoding support.
+    Execute a shell command with cross-platform encoding support and streaming output.
     
     Args:
         command (str): The shell command to execute
@@ -446,81 +449,95 @@ set PYTHONIOENCODING=utf-8
             encoding='utf-8',  # 直接指定 UTF-8 编码
             errors='replace',  # 处理无法解码的字符
             env=env,          # 传递修改后的环境变量
-            startupinfo=startupinfo
+            startupinfo=startupinfo,
+            bufsize=1,        # Line buffering for immediate flushing
+            universal_newlines=True  # Use text mode to handle platform line endings
         )
 
         # Safe decoding helper (for binary output)
-        def safe_decode(byte_stream, encoding):
-            if isinstance(byte_stream, str):
-                return byte_stream.strip()
+        def safe_decode(text, encoding):
+            if isinstance(text, str):
+                return text.strip()
             try:
-                # 首先尝试 UTF-8
-                return byte_stream.decode('utf-8').strip()
+                # Try UTF-8 first
+                return text.decode('utf-8').strip()
             except UnicodeDecodeError:
                 try:
-                    # 如果失败，尝试 GBK
-                    return byte_stream.decode('gbk').strip()
+                    # If that fails, try GBK
+                    return text.decode('gbk').strip()
                 except UnicodeDecodeError:
-                    # 最后使用替换模式
-                    return byte_stream.decode(encoding, errors='replace').strip()
+                    # Finally use replacement mode
+                    return text.decode(encoding, errors='replace').strip()
 
         output = []
-        with Live(console=console, refresh_per_second=4) as live:
-            while True:
-                # Read output streams
-                output_bytes = process.stdout.readline()
-                error_bytes = process.stderr.readline()
-
-                # Handle standard output
-                if output_bytes:
-                    output_line = safe_decode(output_bytes, encoding)
-                    output.append(output_line)
-                    live.update(
-                        Panel(
-                            Text("\n".join(output[-20:])),
-                            title="Shell Output",
-                            border_style="green",
-                        )
-                    )
-
-                # Handle error output
-                if error_bytes:
-                    error_line = safe_decode(error_bytes, encoding)
-                    output.append(f"ERROR: {error_line}")
-                    live.update(
-                        Panel(
-                            Text("\n".join(output[-20:])),
-                            title="Shell Output",
-                            border_style="red",
-                        )
-                    )
-
-                # Check if process has ended
-                if process.poll() is not None:
+        # Use direct printing for streaming output, not a Live object
+        console.print(f"[bold blue]Running command:[/bold blue] {command}")
+        console.print("[bold blue]Output streaming:[/bold blue]")                
+                
+        output_queue = queue.Queue()
+        
+        def read_stream(stream, stream_name):
+            """Read data from stream and put in queue"""
+            for line in stream:
+                line = line.rstrip() if isinstance(line, str) else safe_decode(line, encoding)
+                prefix = "[ERROR] " if stream_name == "stderr" else ""
+                output_queue.put((stream_name, f"{prefix}{line}"))
+            output_queue.put((stream_name, None))  # Mark stream end
+            
+        # Create threads to read stdout and stderr
+        stdout_thread = threading.Thread(target=read_stream, args=(process.stdout, "stdout"))
+        stderr_thread = threading.Thread(target=read_stream, args=(process.stderr, "stderr"))
+        stdout_thread.daemon = True
+        stderr_thread.daemon = True
+        stdout_thread.start()
+        stderr_thread.start()
+        
+        # Track number of active streams
+        active_streams = 2
+        
+        # Process output from queue
+        while active_streams > 0:
+            try:
+                stream_name, line = output_queue.get(timeout=0.1)
+                if line is None:
+                    active_streams -= 1
+                    continue
+                    
+                output.append(line)
+                # Print each line directly for true streaming output
+                if stream_name == "stderr":
+                    console.print(f"[red]{line}[/red]")
+                else:
+                    console.print(line)
+                    
+            except queue.Empty:
+                # Check if process is still running
+                if process.poll() is not None and active_streams == 2:
+                    # If process ended but threads are still running, may have no output
                     break
-
-        # Get remaining output
-        remaining_out, remaining_err = process.communicate()
-        if remaining_out:
-            output.append(safe_decode(remaining_out, encoding))
-        if remaining_err:
-            output.append(f"ERROR: {safe_decode(remaining_err, encoding)}")
+                continue
+                
+        # Wait for threads to finish
+        stdout_thread.join()
+        stderr_thread.join()
         
-        result_manager.add_result(content="\n".join(output),meta={
+        # Wait for process to end and get return code
+        return_code = process.wait()
+        
+        # Compile results
+        result_content = "\n".join(output)
+        result_manager.add_result(content=result_content, meta={
             "action": "execute_shell_command",
             "input": {
                 "command": command
-            }
+            },
+            "return_code": return_code
         })
-        # Show final output
-        console.print(
-            Panel(
-                Text("\n".join(output)),
-                title="Final Output",
-                border_style="blue",
-                subtitle=f"Encoding: {encoding} | OS: {sys.platform}"
-            )
-        )
+        
+        # Show command completion info
+        completion_message = f"Command completed with return code: {return_code}"
+        style = "green" if return_code == 0 else "red"
+        console.print(f"[bold {style}]{escape(completion_message)}[/bold {style}]")
 
     except FileNotFoundError:
         result_manager.add_result(content=f"[bold red]Command not found:[/bold red] [yellow]{command}[/yellow]",meta={

{auto_coder-0.1.277 → auto_coder-0.1.279}/src/autocoder/rag/api_server.py

@@ -103,9 +103,7 @@ async def create_chat_completion(
     NOTE: Currently we do not support the following features:
         - function_call (Users should implement this by themselves)
         - logit_bias (to be supported by vLLM engine)
-    """
-    # async with async_timeout.timeout(TIMEOUT):
-
+    """    
     generator = await openai_serving_chat.create_chat_completion(body, request)
     if isinstance(generator, ErrorResponse):
         return JSONResponse(

auto_coder-0.1.279/src/autocoder/rag/llm_wrapper.py

@@ -0,0 +1,91 @@
+from typing import Any, Dict, List, Optional, Union, Callable
+from byzerllm.utils.client.types import (
+    LLMFunctionCallResponse,
+    LLMClassResponse, LLMResponse
+)
+import pydantic
+from byzerllm import ByzerLLM
+from byzerllm.utils.client import LLMResponse
+from byzerllm.utils.types import SingleOutputMeta
+from autocoder.rag.simple_rag import SimpleRAG
+from autocoder.rag.long_context_rag import LongContextRAG
+from loguru import logger
+from byzerllm.utils.langutil import asyncfy_with_semaphore
+
+
+class LLWrapper:
+
+    def __init__(self, llm: ByzerLLM, rag: Union[SimpleRAG, LongContextRAG]):
+        self.llm = llm
+        self.rag = rag
+
+    def chat_oai(self,
+                 conversations,
+                 tools: List[Union[Callable, str]] = [],
+                 tool_choice: Optional[Union[Callable, str]] = None,
+                 execute_tool: bool = False,
+                 impl_func: Optional[Callable] = None,
+                 execute_impl_func: bool = False,
+                 impl_func_params: Optional[Dict[str, Any]] = None,
+                 func_params: Optional[Dict[str, Any]] = None,
+                 response_class: Optional[Union[pydantic.BaseModel, str]] = None,
+                 response_after_chat: Optional[Union[pydantic.BaseModel, str]] = False,
+                 enable_default_sys_message: bool = True,
+                 model: Optional[str] = None,
+                 role_mapping=None,
+                 llm_config: Dict[str, Any] = {},
+                 only_return_prompt: bool = False,
+                 extra_request_params: Dict[str, Any] = {}
+                 ) -> Union[List[LLMResponse], List[LLMFunctionCallResponse], List[LLMClassResponse]]:
+        res, contexts = self.rag.stream_chat_oai(
+            conversations, llm_config=llm_config, extra_request_params=extra_request_params)
+        metadata = {"request_id":""}
+        output = ""
+        for chunk in res:
+            output += chunk[0]
+            metadata["input_tokens_count"] = chunk[1].input_tokens_count
+            metadata["generated_tokens_count"] = chunk[1].generated_tokens_count
+            metadata["reasoning_content"] = chunk[1].reasoning_content
+            metadata["finish_reason"] = chunk[1].finish_reason
+            metadata["first_token_time"] = chunk[1].first_token_time
+            
+        return [LLMResponse(output=output, metadata=metadata, input="")]
+
+    def stream_chat_oai(self, conversations,
+                        model: Optional[str] = None,
+                        role_mapping=None,
+                        delta_mode=False,
+                        llm_config: Dict[str, Any] = {},
+                        extra_request_params: Dict[str, Any] = {}
+                        ):
+        res, contexts = self.rag.stream_chat_oai(
+                conversations, llm_config=llm_config, extra_request_params=extra_request_params)
+
+        if isinstance(res, tuple):
+            for (t, metadata) in res:
+                yield (t, SingleOutputMeta(
+                    input_tokens_count=metadata.get("input_tokens_count", 0),
+                    generated_tokens_count=metadata.get(
+                        "generated_tokens_count", 0),
+                    reasoning_content=metadata.get("reasoning_content", ""),
+                    finish_reason=metadata.get("finish_reason", "stop"),
+                    first_token_time=metadata.get("first_token_time", 0)
+                ))
+        else:
+            for t in res:
+                yield (t, SingleOutputMeta(0, 0))
+
+    async def async_stream_chat_oai(self, conversations,
+                                    model: Optional[str] = None,
+                                    role_mapping=None,
+                                    delta_mode=False,
+                                    llm_config: Dict[str, Any] = {},
+                                    extra_request_params: Dict[str, Any] = {}
+                                    ):
+        res, contexts = await asyncfy_with_semaphore(lambda: self.rag.stream_chat_oai(conversations, llm_config=llm_config, extra_request_params=extra_request_params))()
+        # res,contexts = await self.llm.async_stream_chat_oai(conversations,llm_config=llm_config)
+        for t in res:
+            yield t
+
+    def __getattr__(self, name):
+        return getattr(self.llm, name)