auto-coder 0.1.375__py3-none-any.whl → 0.1.376__py3-none-any.whl

autocoder/common/llm_rerank.py

@@ -1,84 +0,0 @@
-import byzerllm
-from typing import Union,List
-from loguru import logger
-from llama_index.core.schema import QueryBundle,NodeWithScore
-
-class LLMRerank():
-    def __init__(self,llm:byzerllm.ByzerLLM):
-        self.llm = llm        
-
-    @byzerllm.prompt(llm=lambda self: self.llm)
-    def rereank(self,context_str:str, query_str:str)->str:
-        '''
-        以下显示了一份文档列表。每个文档旁边都有一个编号以及该文档的摘要。还提供了一个问题。
-        回答问题时，请按照相关性顺序列出你应该参考的文档的编号，并给出相关性评分。相关性评分是一个1-10的数字，基于你认为该文档与问题的相关程度。
-        不要包括任何与问题无关的文档。
-        示例格式：
-        文档1：
-        <文档1的摘要>
-
-        文档2：
-        <文档2的摘要>
-
-        ...
-
-        文档10：
-        <文档10的摘要>
-
-        问题：<问题>
-        回答：
-        文档：9，相关性：7
-        文档：3，相关性：4
-        文档：7，相关性：3
-
-        现在让我们试一试：
-
-        {{ context_str }}
-
-        问题：{{ query_str }}
-        回答：
-        '''
-
-    def postprocess_nodes(self,
-                          nodes:List[NodeWithScore], 
-                          query_bundle:Union[str,QueryBundle],
-                          choice_batch_size:int=5, top_n:int=1,verbose:bool=False)->List[NodeWithScore]:                          
-        if isinstance(query_bundle, str):
-            query_bundle = QueryBundle(query_str=query_bundle)
-
-        # 给每个节点添加全局索引
-        indexed_nodes = list(enumerate(nodes))
-
-        # 按 choice_batch_size 切分 nodes
-        node_batches = [indexed_nodes[i:i+choice_batch_size] for i in range(0, len(indexed_nodes), choice_batch_size)]
-
-        # 合并排序后的结果
-        sorted_nodes = []
-        for batch in node_batches:
-            context_str = "\n\n".join([f"文档{idx}:\n{node.node.get_text()}" for idx, node in batch])            
-            rerank_output = self.rereank(context_str, query_bundle.query_str)
-            if verbose:
-                logger.info(self.rereank.prompt(context_str, query_bundle.query_str))
-                logger.info(rerank_output)
-
-            # 解析 rerank 的输出
-            rerank_result = []
-            for line in rerank_output.split("\n"):
-                if line.startswith("文档："):
-                    parts = line.split("，")
-                    if len(parts) == 2:
-                        try:
-                            doc_idx = int(parts[0].split("：")[1])
-                            relevance = float(parts[1].split("：")[1])
-                            rerank_result.append((doc_idx, relevance))
-                        except:
-                            logger.warning(f"Failed to parse line: {line}")
-                            pass
-
-            # 更新 batch 中节点的分数
-            for doc_idx, relevance in rerank_result:                  
-                indexed_nodes[doc_idx][1].score = relevance
-
-        sorted_nodes.extend([node for _, node in sorted(indexed_nodes, key=lambda x: x[1].score, reverse=True)])
-
-        return sorted_nodes[:top_n]

autocoder/common/model_speed_test.py

@@ -1,392 +0,0 @@
-import time
-import byzerllm
-from typing import Dict, Any, List, Optional
-from rich.console import Console
-from rich.table import Table
-from rich.panel import Panel
-from autocoder.common.printer import Printer
-from autocoder import models as models_module
-from autocoder.utils.llms import get_single_llm
-import byzerllm
-import pkg_resources
-from concurrent.futures import ThreadPoolExecutor
-from typing import Dict, List, Tuple
-from pydantic import BaseModel
-
-class ModelSpeedTestResult(BaseModel):
-    model_name: str
-    tokens_per_second: float
-    first_token_time: float
-    input_tokens_count: float
-    generated_tokens_count: float
-    input_tokens_cost: float
-    generated_tokens_cost: float
-    status: str
-    error: Optional[str] = None
-
-class SpeedTestResults(BaseModel):
-    results: List[ModelSpeedTestResult]
-
-byzerllm_content = ""
-try:
-    byzerllm_conten_path = pkg_resources.resource_filename(
-        "autocoder", "data/byzerllm.md"
-    )
-    with open(byzerllm_conten_path, "r",encoding="utf-8") as f:
-        byzerllm_content = f.read()
-except FileNotFoundError:
-    pass
-
-@byzerllm.prompt()
-def long_context_prompt() -> str:
-    '''
-    下面是我们提供的一份文档：
-    <document>
-    {{ content }}
-    </document>
-    
-    请根据上述文档，实现用户的需求：
-
-    <query>
-    我想开发一个翻译程序，使用prompt 函数实现。
-    </query>
-    '''
-    return {
-        "content": byzerllm_content
-    }
-
-@byzerllm.prompt()
-def short_context_prompt() -> str:
-    '''
-    Hello, can you help me test the response speed?
-    '''
-    return {}
-
-def test_model_speed(model_name: str, 
-                    product_mode: str, 
-                    test_rounds: int = 3,
-                    enable_long_context: bool = False
-                    ) -> Dict[str, Any]:
-    from autocoder.models import get_model_by_name
-    """
-    测试单个模型的速度
-    
-    Args:
-        model_name: 模型名称
-        product_mode: 产品模式 (lite/pro)
-        test_rounds: 测试轮数
-        
-    Returns:
-        Dict包含测试结果:
-            - avg_time: 平均响应时间
-            - min_time: 最小响应时间
-            - max_time: 最大响应时间
-            - first_token_time: 首token时间
-            - success: 是否测试成功
-            - error: 错误信息(如果有)
-    """
-    try:
-        llm = get_single_llm(model_name, product_mode)
-        model_info = get_model_by_name(model_name)
-
-        times = []
-        first_token_times = []
-        tokens_per_seconds = []
-        input_tokens_counts = []
-        generated_tokens_counts = []
-        
-        input_tokens_costs = []
-        generated_tokens_costs = []
-
-        input_tokens_cost_per_m = model_info.get("input_price", 0.0) / 1000000
-        output_tokens_cost_per_m = model_info.get("output_price", 0.0) / 1000000
-
-        test_query = short_context_prompt.prompt()
-        if enable_long_context:
-            test_query = long_context_prompt.prompt()                
-        
-        content = ""
-        for _ in range(test_rounds):
-            start_time = time.time()
-            first_token_received = False
-            first_token_time = None
-            last_meta = None
-            input_tokens_count = 0
-            generated_tokens_count = 0 
-            input_tokens_cost = 0
-            generated_tokens_cost = 0           
-            for chunk,meta in llm.stream_chat_oai(conversations=[{
-                "role": "user",
-                "content": test_query
-            }],delta_mode=True):
-                content += chunk
-                last_meta = meta                
-                current_time = time.time()
-                if not first_token_received:
-                    first_token_time = current_time - start_time
-                    first_token_received = True
-                    first_token_times.append(first_token_time)
-            
-            end_time = time.time()            
-            generated_tokens_count = 0
-            if last_meta:                
-                generated_tokens_count = last_meta.generated_tokens_count
-                input_tokens_count = last_meta.input_tokens_count
-                input_tokens_cost = input_tokens_count * input_tokens_cost_per_m
-                generated_tokens_cost = generated_tokens_count * output_tokens_cost_per_m
-
-                input_tokens_costs.append(input_tokens_cost)
-                generated_tokens_costs.append(generated_tokens_cost)
-                generated_tokens_counts.append(generated_tokens_count)
-                input_tokens_counts.append(input_tokens_count)
-            
-            tokens_per_seconds.append(generated_tokens_count / (end_time - start_time))    
-            times.append(end_time - start_time)
-            
-            
-        avg_time = sum(times) / len(times)
-        return {
-            "tokens_per_second": sum(tokens_per_seconds) / len(tokens_per_seconds),
-            "avg_time": avg_time,
-            "min_time": min(times),
-            "max_time": max(times),
-            "first_token_time": sum(first_token_times) / len(first_token_times),
-            "input_tokens_count": sum(input_tokens_counts) / len(input_tokens_counts),
-            "generated_tokens_count": sum(generated_tokens_counts) / len(generated_tokens_counts),
-            "success": True,
-            "error": None,
-            "input_tokens_cost": sum(input_tokens_costs) / len(input_tokens_costs),
-            "generated_tokens_cost": sum(generated_tokens_costs) / len(generated_tokens_costs)
-        }
-    except Exception as e:
-        return {
-            "tokens_per_second": 0,
-            "avg_time": 0,
-            "min_time": 0,
-            "max_time": 0,
-            "first_token_time": 0,
-            "input_tokens_count": 0,
-            "generated_tokens_count": 0,
-            "success": False,
-            "error": str(e),
-            "input_tokens_cost": 0.0,
-            "generated_tokens_cost": 0.0
-        }
-
-def test_model_speed_wrapper(args: Tuple[str, str, int, bool]) -> Tuple[str, Dict[str, Any]]:
-    """
-    包装测试函数以适应线程池调用
-    
-    Args:
-        args: (model_name, product_mode, test_rounds)的元组
-        
-    Returns:
-        (model_name, test_results)的元组
-    """
-    model_name, product_mode, test_rounds,enable_long_context = args
-    results = test_model_speed(model_name, product_mode, test_rounds,enable_long_context)
-    return (model_name, results)
-
-
-def run_speed_test(product_mode: str, test_rounds: int = 3, max_workers: Optional[int] = None, enable_long_context: bool = False) -> SpeedTestResults:
-    """
-    运行所有已激活模型的速度测试
-    
-    Args:
-        product_mode: 产品模式 (lite/pro)
-        test_rounds: 每个模型测试的轮数
-        max_workers: 最大线程数,默认为None(ThreadPoolExecutor会自动设置)
-        enable_long_context: 是否启用长文本上下文测试
-    
-    Returns:
-        SpeedTestResults: 包含所有模型测试结果的pydantic模型
-    """
-    # 获取所有模型
-    models_data = models_module.load_models()
-    active_models = [m for m in models_data if "api_key" in m] if product_mode == "lite" else models_data
-    
-    if not active_models:
-        return SpeedTestResults(results=[])
-    
-    # 准备测试参数
-    test_args = [(model["name"], product_mode, test_rounds, enable_long_context) for model in active_models]
-    
-    # 存储结果用于排序
-    results_list = []
-    
-    # 使用线程池并发测试
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        # 提交所有测试任务并获取future对象
-        future_to_model = {executor.submit(test_model_speed_wrapper, args): args[0] 
-                          for args in test_args}
-        
-        # 收集结果
-        for future in future_to_model:
-            model_name = future_to_model[future]
-            
-            try:
-                _, results = future.result()
-                
-                if results["success"]:
-                    status = "✓"
-                    results_list.append((
-                        results['tokens_per_second'],
-                        ModelSpeedTestResult(
-                            model_name=model_name,
-                            tokens_per_second=results['tokens_per_second'],
-                            first_token_time=results['first_token_time'],
-                            input_tokens_count=results['input_tokens_count'],
-                            generated_tokens_count=results['generated_tokens_count'],
-                            status=status,
-                            input_tokens_cost=results['input_tokens_cost'],
-                            generated_tokens_cost=results['generated_tokens_cost'],                            
-                        )
-                    ))
-                    try:
-                        # 更新模型的平均速度
-                        models_module.update_model_speed(model_name, results['tokens_per_second'])
-                    except Exception:
-                        pass
-                else:                    
-                    results_list.append((
-                        0,
-                        ModelSpeedTestResult(
-                            model_name=model_name,
-                            tokens_per_second=0,
-                            first_token_time=0,
-                            input_tokens_count=0,
-                            generated_tokens_count=0,
-                            status=f"✗ {results['error']}",
-                            error=results['error'],
-                            input_tokens_cost=0.0,
-                            generated_tokens_cost=0.0
-                        )
-                    ))
-            except Exception as e:
-                results_list.append((
-                    0,
-                    ModelSpeedTestResult(
-                        model_name=model_name,
-                        tokens_per_second=0,
-                        first_token_time=0,
-                        input_tokens_count=0,
-                        generated_tokens_count=0,
-                        status=f"✗ {str(e)}",
-                        error=str(e),
-                        input_tokens_cost=0.0,
-                        generated_tokens_cost=0.0
-                    )
-                ))
-
-    # 按速度排序
-    results_list.sort(key=lambda x: x[0], reverse=True)
-    
-    return SpeedTestResults(results=[result[1] for result in results_list])
-
-def render_speed_test_in_terminal(product_mode: str, test_rounds: int = 3, max_workers: Optional[int] = None,enable_long_context: bool = False) -> None:
-    """
-    运行所有已激活模型的速度测试
-    
-    Args:
-        product_mode: 产品模式 (lite/pro)
-        test_rounds: 每个模型测试的轮数
-        max_workers: 最大线程数,默认为None(ThreadPoolExecutor会自动设置)
-    """
-    printer = Printer()
-    console = Console()
-    
-    # 获取所有模型
-    models_data = models_module.load_models()
-    active_models = [m for m in models_data if "api_key" in m] if product_mode == "lite" else models_data
-    
-    if not active_models:
-        printer.print_in_terminal("models_no_active", style="yellow")
-        return
-        
-    # 创建结果表格
-    table = Table(
-        title=printer.get_message_from_key("models_speed_test_results"),
-        show_header=True,
-        header_style="bold magenta",
-        show_lines=True
-    )
-    
-    table.add_column("Model", style="cyan", width=30)
-    table.add_column("Tokens/s", style="green", width=15)
-    table.add_column("First Token(s)", style="magenta", width=15)
-    table.add_column("Input Tokens", style="magenta", width=15)
-    table.add_column("Generated Tokens", style="magenta", width=15)            
-    table.add_column("Input Tokens Cost", style="yellow", width=15)
-    table.add_column("Generated Tokens Cost", style="yellow", width=15)
-    table.add_column("Status", style="red", width=20)
-    
-    # 准备测试参数
-    test_args = [(model["name"], product_mode, test_rounds, enable_long_context) for model in active_models]
-    
-    # 存储结果用于排序
-    results_list = []
-    
-    # 使用线程池并发测试
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        printer.print_in_terminal("models_testing_start", style="yellow")
-        
-        # 提交所有测试任务并获取future对象
-        future_to_model = {executor.submit(test_model_speed_wrapper, args): args[0] 
-                          for args in test_args}
-        
-        # 收集结果
-        completed = 0
-        total = len(future_to_model)
-        for future in future_to_model:
-            completed += 1
-            printer.print_in_terminal("models_testing_progress", style="yellow", completed=completed, total=total)
-            model_name = future_to_model[future]
-            printer.print_in_terminal("models_testing", style="yellow", name=model_name)
-            
-            try:
-                _, results = future.result()
-                
-                if results["success"]:
-                    status = "✓"
-                    results['status'] = status
-                    results_list.append((
-                        results['tokens_per_second'],
-                        model_name,
-                        results
-                    ))                  
-                    try:  
-                        # 更新模型的平均速度
-                        models_module.update_model_speed(model_name, results['tokens_per_second'])
-                    except Exception as e:
-                        pass
-                else:
-                    status = f"✗ ({results['error']})"
-                    results_list.append((
-                        0,
-                        model_name,
-                        {"tokens_per_second":0,"avg_time": 0, "input_tokens_count":0, "generated_tokens_count":0, "min_time": 0, "max_time": 0, "first_token_time": 0, "input_tokens_cost": 0.0, "generated_tokens_cost": 0.0, "status": status}
-                    ))
-            except Exception as e:
-                results_list.append((
-                    0,
-                    model_name,
-                        {"tokens_per_second":0,"avg_time": 0, "input_tokens_count":0, "generated_tokens_count":0, "min_time": 0, "max_time": 0, "first_token_time": 0, "input_tokens_cost": 0.0, "generated_tokens_cost": 0.0, "status": f"✗ ({str(e)})"}
-                ))
-
-    # 按速度排序
-    results_list.sort(key=lambda x: x[0], reverse=True)
-    
-    # 添加排序后的结果到表格
-    for tokens_per_second, model_name, results in results_list:        
-        table.add_row(
-            model_name,  
-            f"{tokens_per_second:.2f}",
-            f"{results['first_token_time']:.2f}",
-            f"{results['input_tokens_count']}",
-            f"{results['generated_tokens_count']}",
-            f"{results['input_tokens_cost']:.4f}",
-            f"{results['generated_tokens_cost']:.4f}",            
-            results['status']
-        )        
-    
-    console.print(Panel(table, border_style="blue"))

autocoder/common/v2/agent/agentic_edit_conversation.py

@@ -1,188 +0,0 @@
-# src/autocoder/common/v2/agent/agentic_edit_conversation.py
-import os
-import json
-import uuid
-from typing import List, Dict, Any, Optional
-from autocoder.common import AutoCoderArgs
-
-# Define a type alias for a message dictionary
-MessageType = Dict[str, Any]
-
-class AgenticConversation:
-    """
-    Manages the conversation history for an agentic editing process.
-
-    Handles adding messages (user, assistant, tool calls, tool results)
-    and retrieving the history.
-    """
-
-    def __init__(self, args: AutoCoderArgs, initial_history: Optional[List[MessageType]] = None, conversation_name: Optional[str] = None):
-        """
-        Initializes the conversation history.
-
-        Args:
-            initial_history: An optional list of messages to start with.
-            conversation_name: Optional conversation identifier. If provided, history is saved/loaded from a file named after it.
-        """
-        self.project_path = args.source_dir
-        self._history: List[MessageType] = initial_history if initial_history is not None else []
-
-        # Determine the memory directory
-        memory_dir = os.path.join(self.project_path, ".auto-coder", "memory", "agentic_edit_memory")
-        os.makedirs(memory_dir, exist_ok=True)
-
-        # Determine conversation file path
-        if conversation_name:
-            filename = f"{conversation_name}.json"
-        else:
-            conversation_name = str(uuid.uuid4())
-            filename = f"{conversation_name}.json"
-
-        self.conversation_name = conversation_name
-        self.memory_file_path = os.path.join(memory_dir, filename)
-
-        # Load existing history if file exists
-        self._load_memory()
-
-    def add_message(self, role: str, content: Any, **kwargs):
-        """
-        Adds a message to the conversation history.
-
-        Args:
-            role: The role of the message sender (e.g., "user", "assistant", "tool").
-            content: The content of the message. Can be None for messages like tool calls.
-            **kwargs: Additional key-value pairs to include in the message dictionary (e.g., tool_calls, tool_call_id).
-        """
-        message: MessageType = {"role": role}
-        if content is not None:
-            message["content"] = content
-        message.update(kwargs)
-        self._history.append(message)
-        self._save_memory()
-
-    def add_user_message(self, content: str):
-        """Adds a user message."""
-        self.add_message(role="user", content=content)
-
-    def add_assistant_message(self, content: str):
-        """Adds an assistant message (potentially containing text response)."""
-        self.add_message(role="assistant", content=content)
-
-    def append_to_last_message(self, content: str, role: str = "assistant"):
-        """Appends content to the last message."""
-        if self._history:
-            last_message = self._history[-1]  
-            if role and last_message["role"] == role:
-                last_message["content"] += content   
-            elif not role:
-                last_message["content"] += content
-
-    def add_assistant_tool_call_message(self, tool_calls: List[Dict[str, Any]], content: Optional[str] = None):
-         """
-         Adds a message representing one or more tool calls from the assistant.
-         Optionally includes assistant's textual reasoning/content alongside the calls.
-         """
-         self.add_message(role="assistant", content=content, tool_calls=tool_calls)
-
-
-    def add_tool_result_message(self, tool_call_id: str, content: Any):
-         """Adds a message representing the result of a specific tool call."""
-         # The content here is typically the output/result from the tool execution.
-         self.add_message(role="tool", content=content, tool_call_id=tool_call_id)
-
-
-    def get_history(self) -> List[MessageType]:
-        """
-        Returns the latest 20 pairs of (user, assistant) conversation history.
-        Merges adjacent same-role messages into one, concatenated by newline.
-        Ensures that each user message is paired with the subsequent assistant response,
-        skips other roles, and that the last message is always assistant (drops trailing user if unpaired).
-        
-        Returns:
-            A list of message dictionaries, ordered chronologically.
-        """
-        paired_history = []
-        pair_count = 0
-        pending_assistant = None
-        pending_user = None
-
-        # Traverse history in reverse to collect latest pairs with merging
-        for msg in reversed(self._history):
-            role = msg.get("role")
-            if role == "assistant":
-                if pending_assistant is None:
-                    pending_assistant = dict(msg)
-                else:
-                    # Merge with previous assistant
-                    prev_content = pending_assistant.get("content", "")
-                    curr_content = msg.get("content", "")
-                    merged_content = (curr_content.strip() + "\n" + prev_content.strip()).strip()
-                    pending_assistant["content"] = merged_content
-            elif role == "user":
-                if pending_user is None:
-                    pending_user = dict(msg)
-                else:
-                    # Merge with previous user
-                    prev_content = pending_user.get("content", "")
-                    curr_content = msg.get("content", "")
-                    merged_content = (curr_content.strip() + "\n" + prev_content.strip()).strip()
-                    pending_user["content"] = merged_content
-
-                if pending_assistant is not None:
-                    # Have a full pair, insert in order
-                    paired_history.insert(0, pending_user)
-                    paired_history.insert(1, pending_assistant)
-                    pair_count += 1
-                    pending_assistant = None
-                    pending_user = None
-                    if pair_count >= 20:
-                        break
-                else:
-                    # User without assistant yet, continue accumulating
-                    continue
-            else:
-                # Ignore other roles
-                continue
-
-        # Ensure last message is assistant, drop trailing user if unpaired
-        if paired_history and paired_history[-1].get("role") == "user":
-            paired_history.pop()
-
-        return paired_history
-
-    def clear_history(self):
-        """Clears the conversation history."""
-        self._history = []
-        self._save_memory()
-
-    def __len__(self) -> int:
-        """Returns the number of messages in the history."""
-        return len(self._history)
-
-    def __str__(self) -> str:
-        """Returns a string representation of the conversation history."""
-        # Consider a more readable format if needed for debugging
-        return str(self._history)
-
-    # Potential future enhancements:
-    # - Method to limit history size (by tokens or message count)
-    # - Method to format history specifically for different LLM APIs
-    # - Serialization/deserialization methods
-
-    def _save_memory(self):
-        try:
-            os.makedirs(os.path.dirname(self.memory_file_path), exist_ok=True)
-            with open(self.memory_file_path, "w", encoding="utf-8") as f:
-                json.dump(self._history, f, ensure_ascii=False, indent=2)
-        except Exception as e:
-            # Optionally log or ignore
-            pass
-
-    def _load_memory(self):
-        try:
-            if os.path.exists(self.memory_file_path):
-                with open(self.memory_file_path, "r", encoding="utf-8") as f:
-                    self._history = json.load(f)
-        except Exception as e:
-            # Ignore loading errors, start fresh
-            pass