auto-coder 0.1.254__py3-none-any.whl → 0.1.256__py3-none-any.whl

autocoder/dispacher/actions/action.py

@@ -125,13 +125,17 @@ class ActionTSProject(BaseAction):
                     query=args.query, source_content=content
                 )
             elapsed_time = time.time() - start_time
-            speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0            
-            model_names = ",".join(get_llm_names(self.llm))
+            speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
+            model_names = ",".join(get_llm_names(generate.llms))
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )
@@ -221,12 +225,16 @@ class ActionPyScriptProject(BaseAction):
 
             elapsed_time = time.time() - start_time
             speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
-            model_names = ",".join(get_llm_names(self.llm))
+            model_names = ",".join(get_llm_names(generate.llms))
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )
@@ -264,13 +272,7 @@ class ActionPyScriptProject(BaseAction):
                     model=self.llm.default_model_name,
                 )
 
-            end_time = time.time()
-            self.printer.print_in_terminal(
-                "code_generation_complete",
-                duration=end_time - start_time,
-                input_tokens=generate_result.metadata.get('input_tokens_count', 0),
-                output_tokens=generate_result.metadata.get('generated_tokens_count', 0)
-            )
+            end_time = time.time()            
             with open(self.args.target_file, "w") as file:
                 file.write(content)
 
@@ -348,12 +350,16 @@ class ActionPyProject(BaseAction):
                 )
             elapsed_time = time.time() - start_time
             speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
-            model_names = ",".join(get_llm_names(self.llm))
+            model_names = ",".join(get_llm_names(generate.llms))
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )
@@ -458,12 +464,16 @@ class ActionSuffixProject(BaseAction):
               
         elapsed_time = time.time() - start_time
         speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
-        model_names = ",".join(get_llm_names(self.llm))
+        model_names = ",".join(get_llm_names(generate.llms))
+        input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+        generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
         self.printer.print_in_terminal(
             "code_generation_complete",
             duration=elapsed_time,
             input_tokens=generate_result.metadata.get('input_tokens_count', 0),
             output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+            input_cost=input_tokens_cost,
+            output_cost=generated_tokens_cost,
             speed=round(speed, 2),
             model_names=model_names
         )

autocoder/dispacher/actions/plugins/action_regex_project.py

@@ -88,11 +88,15 @@ class ActionRegexProject:
             elapsed_time = time.time() - start_time
             speed = generate_result.metadata.get('generated_tokens_count', 0) / elapsed_time if elapsed_time > 0 else 0
             model_names = ",".join(get_llm_names(self.llm))
+            input_tokens_cost = generate_result.metadata.get('input_tokens_cost', 0)
+            generated_tokens_cost = generate_result.metadata.get('generated_tokens_cost', 0)
             self.printer.print_in_terminal(
                 "code_generation_complete",
                 duration=elapsed_time,
                 input_tokens=generate_result.metadata.get('input_tokens_count', 0),
                 output_tokens=generate_result.metadata.get('generated_tokens_count', 0),
+                input_cost=input_tokens_cost,
+                output_cost=generated_tokens_cost,
                 speed=round(speed, 2),
                 model_names=model_names
             )

autocoder/index/filter/quick_filter.py

@@ -4,21 +4,21 @@ from autocoder.utils.auto_coder_utils.chat_stream_out import stream_out
 from autocoder.common.utils_code_auto_generate import stream_chat_with_continue
 from byzerllm.utils.str2model import to_model
 from autocoder.index.types import IndexItem
-from autocoder.common import AutoCoderArgs,SourceCode
+from autocoder.common import AutoCoderArgs, SourceCode
 import byzerllm
 import time
 from autocoder.index.index import IndexManager
 from autocoder.index.types import (
     IndexItem,
-    TargetFile,    
+    TargetFile,
     FileNumberList
 )
 from autocoder.rag.token_counter import count_tokens
 from autocoder.common.printer import Printer
 from concurrent.futures import ThreadPoolExecutor
-import threading
+from byzerllm import MetaHolder
 
-from autocoder.utils.llms import get_llm_names
+from autocoder.utils.llms import get_llm_names, get_model_info
 
 
 def get_file_path(file_path):
@@ -32,8 +32,9 @@ class QuickFilterResult(BaseModel):
     has_error: bool
     error_message: Optional[str] = None
 
+
 class QuickFilter():
-    def __init__(self, index_manager: IndexManager,stats:Dict[str,Any],sources:List[SourceCode]):
+    def __init__(self, index_manager: IndexManager, stats: Dict[str, Any], sources: List[SourceCode]):
         self.index_manager = index_manager
         self.args = index_manager.args
         self.stats = stats
@@ -41,72 +42,142 @@ class QuickFilter():
         self.printer = Printer()
         self.max_tokens = self.args.index_filter_model_max_input_length
 
-
     def big_filter(self, index_items: List[IndexItem],) -> QuickFilterResult:
         chunks = []
         current_chunk = []
-                
+
         # 将 index_items 切分成多个 chunks,第一个chunk尽可能接近max_tokens
         for item in index_items:
             # 使用 quick_filter_files.prompt 生成文本再统计
             temp_chunk = current_chunk + [item]
-            prompt_text = self.quick_filter_files.prompt(temp_chunk, self.args.query)
-            temp_size = count_tokens(prompt_text)            
+            prompt_text = self.quick_filter_files.prompt(
+                temp_chunk, self.args.query)
+            temp_size = count_tokens(prompt_text)
             # 如果当前chunk为空,或者添加item后不超过max_tokens,就添加到当前chunk
             if not current_chunk or temp_size <= self.max_tokens:
-                current_chunk.append(item)                
+                current_chunk.append(item)
             else:
                 # 当前chunk已满,创建新chunk
                 chunks.append(current_chunk)
-                current_chunk = [item]                
-            
+                current_chunk = [item]
+
         if current_chunk:
             chunks.append(current_chunk)
-        
-        tokens_len = count_tokens(self.quick_filter_files.prompt(index_items, self.args.query))
+
+        tokens_len = count_tokens(
+            self.quick_filter_files.prompt(index_items, self.args.query))
         self.printer.print_in_terminal(
-                "quick_filter_too_long",
-                style="yellow",
-                tokens_len=tokens_len,
-                max_tokens=self.max_tokens,
-                split_size=len(chunks)
-            )    
+            "quick_filter_too_long",
+            style="yellow",
+            tokens_len=tokens_len,
+            max_tokens=self.max_tokens,
+            split_size=len(chunks)
+        )
 
         def process_chunk(chunk_index: int, chunk: List[IndexItem]) -> QuickFilterResult:
             try:
-                model_name = ",".join(get_llm_names(self.index_manager.index_filter_llm))
+                # 获取模型名称列表
+                model_names = get_llm_names(
+                    self.index_manager.index_filter_llm)
+                model_name = ",".join(model_names)
                 files: Dict[str, TargetFile] = {}
-                
+
+                # 获取模型价格信息
+                model_info_map = {}
+                for name in model_names:
+                    # 第二个参数是产品模式,从args中获取
+                    info = get_model_info(name, self.args.product_mode)
+                    if info:
+                        model_info_map[name] = {
+                            # 每百万tokens成本
+                            "input_price": info.get("input_price", 0.0),
+                            # 每百万tokens成本
+                            "output_price": info.get("output_price", 0.0)
+                        }
+
                 if chunk_index == 0:
                     # 第一个chunk使用流式输出
                     stream_generator = stream_chat_with_continue(
                         self.index_manager.index_filter_llm,
-                        [{"role": "user", "content": self.quick_filter_files.prompt(chunk, self.args.query)}],
+                        [{"role": "user", "content": self.quick_filter_files.prompt(
+                            chunk, self.args.query)}],
                         {}
                     )
-                    full_response, _ = stream_out(
+                    full_response, last_meta = stream_out(
                         stream_generator,
                         model_name=model_name,
-                        title=self.printer.get_message_from_key_with_format("quick_filter_title", model_name=model_name),
+                        title=self.printer.get_message_from_key_with_format(
+                            "quick_filter_title", model_name=model_name),
                         args=self.args
                     )
                     file_number_list = to_model(full_response, FileNumberList)
+
+                    # 计算总成本
+                    total_input_cost = 0.0
+                    total_output_cost = 0.0
+
+                    for name in model_names:
+                        info = model_info_map.get(name, {})
+                        # 计算公式:token数 * 单价 / 1000000
+                        total_input_cost += (last_meta.input_tokens_count *
+                                             info.get("input_price", 0.0)) / 1000000
+                        total_output_cost += (last_meta.generated_tokens_count *
+                                              info.get("output_price", 0.0)) / 1000000
+
+                    # 四舍五入到4位小数
+                    total_input_cost = round(total_input_cost, 4)
+                    total_output_cost = round(total_output_cost, 4)
+
+                    # 打印 token 统计信息和成本
+                    self.printer.print_in_terminal(
+                        "quick_filter_stats",
+                        style="blue",
+                        input_tokens=last_meta.input_tokens_count,
+                        output_tokens=last_meta.generated_tokens_count,
+                        input_cost=total_input_cost,
+                        output_cost=total_output_cost,
+                        model_names=model_name
+                    )
                 else:
                     # 其他chunks直接使用with_llm
-                    file_number_list = self.quick_filter_files.with_llm(self.index_manager.index_filter_llm).with_return_type(FileNumberList).run(chunk, self.args.query)
-                
+                    meta_holder = MetaHolder()
+                    start_time = time.monotonic()
+                    file_number_list = self.quick_filter_files.with_llm(self.index_manager.index_filter_llm).with_meta(
+                        meta_holder).with_return_type(FileNumberList).run(chunk, self.args.query)
+                    end_time = time.monotonic()
+                    
+                    total_input_cost = 0.0
+                    total_output_cost = 0.0
+                    if meta_holder.get_meta():
+                        meta_dict = meta_holder.get_meta()                    
+                        total_input_cost = meta_dict.get("input_tokens_count", 0) * model_info_map.get(model_name, {}).get("input_price", 0.0) / 1000000
+                        total_output_cost = meta_dict.get("generated_tokens_count", 0) * model_info_map.get(model_name, {}).get("output_price", 0.0) / 1000000
+                    
+                    self.printer.print_in_terminal(
+                        "quick_filter_stats",
+                        style="blue",
+                        input_tokens=meta_dict.get("input_tokens_count", 0),
+                        output_tokens=meta_dict.get("generated_tokens_count", 0),
+                        input_cost=total_input_cost,
+                        output_cost=total_output_cost,
+                        model_names=model_name,
+                        elapsed_time=f"{end_time - start_time:.2f}"
+                    )
+
                 if file_number_list:
                     for file_number in file_number_list.file_list:
-                        file_path = get_file_path(chunk[file_number].module_name)
+                        file_path = get_file_path(
+                            chunk[file_number].module_name)
                         files[file_path] = TargetFile(
                             file_path=chunk[file_number].module_name,
-                            reason=self.printer.get_message_from_key("quick_filter_reason")
+                            reason=self.printer.get_message_from_key(
+                                "quick_filter_reason")
                         )
                 return QuickFilterResult(
                     files=files,
                     has_error=False
                 )
-                            
+
             except Exception as e:
                 self.printer.print_in_terminal(
                     "quick_filter_failed",
@@ -123,25 +194,25 @@ class QuickFilter():
         if chunks:
             with ThreadPoolExecutor() as executor:
                 # 提交所有chunks到线程池并收集结果
-                futures = [executor.submit(process_chunk, i, chunk) 
-                          for i, chunk in enumerate(chunks)]
-                
+                futures = [executor.submit(process_chunk, i, chunk)
+                           for i, chunk in enumerate(chunks)]
+
                 # 等待所有任务完成并收集结果
                 for future in futures:
                     results.append(future.result())
-        
+
         # 合并所有结果
         final_files: Dict[str, TargetFile] = {}
         has_error = False
         error_messages: List[str] = []
-        
+
         for result in results:
             if result.has_error:
                 has_error = True
                 if result.error_message:
                     error_messages.append(result.error_message)
             final_files.update(result.files)
-        
+
         return QuickFilterResult(
             files=final_files,
             has_error=has_error,
@@ -149,7 +220,7 @@ class QuickFilter():
         )
 
     @byzerllm.prompt()
-    def quick_filter_files(self,file_meta_list:List[IndexItem],query:str) -> str:
+    def quick_filter_files(self, file_meta_list: List[IndexItem], query: str) -> str:
         '''
         当用户提一个需求的时候，我们需要找到相关的文件，然后阅读这些文件，并且修改其中部分文件。
         现在，给定下面的索引文件：
@@ -160,7 +231,7 @@ class QuickFilter():
 
         索引文件包含文件序号(##[]括起来的部分)，文件路径，文件符号信息等。
         下面是用户的查询需求：
-        
+
         <query>
         {{ query }}
         </query>
@@ -182,63 +253,101 @@ class QuickFilter():
         2. 如果 query 里是一段历史对话，那么对话里的内容提及的文件路径必须要返回。
         3. json格式数据不允许有注释        
         '''
-        file_meta_str = "\n".join([f"##[{index}]{item.module_name}\n{item.symbols}" for index,item in enumerate(file_meta_list)])
+        file_meta_str = "\n".join(
+            [f"##[{index}]{item.module_name}\n{item.symbols}" for index, item in enumerate(file_meta_list)])
         context = {
             "content": file_meta_str,
             "query": query
         }
-        return context    
+        return context
 
     def filter(self, index_items: List[IndexItem], query: str) -> QuickFilterResult:
         final_files: Dict[str, TargetFile] = {}
-        start_time = time.monotonic()        
+        start_time = time.monotonic()
+
+        prompt_str = self.quick_filter_files.prompt(index_items, query)
+
+        tokens_len = count_tokens(prompt_str)
 
-        prompt_str = self.quick_filter_files.prompt(index_items,query)            
-        
-        tokens_len = count_tokens(prompt_str)            
-        
         # Print current index size
         self.printer.print_in_terminal(
             "quick_filter_tokens_len",
             style="blue",
             tokens_len=tokens_len
         )
-        
-        if tokens_len > self.max_tokens:                        
+
+        if tokens_len > self.max_tokens:
             return self.big_filter(index_items)
-        
+
         try:
-            model_name = ",".join(get_llm_names(self.index_manager.index_filter_llm))
-            
+            # 获取模型名称
+            model_names = get_llm_names(self.index_manager.index_filter_llm)
+            model_name = ",".join(model_names)
+
+            # 获取模型价格信息
+            model_info_map = {}
+            for name in model_names:
+                # 第二个参数是产品模式,从args中获取
+                info = get_model_info(name, self.args.product_mode)
+                if info:
+                    model_info_map[name] = {
+                        # 每百万tokens成本
+                        "input_price": info.get("input_price", 0.0),
+                        # 每百万tokens成本
+                        "output_price": info.get("output_price", 0.0)
+                    }
+
             # 渲染 Prompt 模板
-            query = self.quick_filter_files.prompt(index_items, self.args.query)
-            
+            query = self.quick_filter_files.prompt(
+                index_items, self.args.query)
+
             # 使用流式输出处理
             stream_generator = stream_chat_with_continue(
                 self.index_manager.index_filter_llm,
                 [{"role": "user", "content": query}],
                 {}
             )
-            
+
             # 获取完整响应
             full_response, last_meta = stream_out(
                 stream_generator,
                 model_name=model_name,
-                title=self.printer.get_message_from_key_with_format("quick_filter_title", model_name=model_name),
+                title=self.printer.get_message_from_key_with_format(
+                    "quick_filter_title", model_name=model_name),
                 args=self.args
-            )                
+            )
             # 解析结果
             file_number_list = to_model(full_response, FileNumberList)
-            end_time = time.monotonic()            
-            # 打印 token 统计信息
+            end_time = time.monotonic()
+
+            # 计算总成本
+            total_input_cost = 0.0
+            total_output_cost = 0.0
+
+            for name in model_names:
+                info = model_info_map.get(name, {})
+                # 计算公式:token数 * 单价 / 1000000
+                total_input_cost += (last_meta.input_tokens_count *
+                                     info.get("input_price", 0.0)) / 1000000
+                total_output_cost += (last_meta.generated_tokens_count *
+                                      info.get("output_price", 0.0)) / 1000000
+
+            # 四舍五入到4位小数
+            total_input_cost = round(total_input_cost, 4)
+            total_output_cost = round(total_output_cost, 4)
+
+            # 打印 token 统计信息和成本
             self.printer.print_in_terminal(
-                "quick_filter_stats", 
+                "quick_filter_stats",
                 style="blue",
                 elapsed_time=f"{end_time - start_time:.2f}",
                 input_tokens=last_meta.input_tokens_count,
-                output_tokens=last_meta.generated_tokens_count
+                output_tokens=last_meta.generated_tokens_count,
+                input_cost=total_input_cost,
+                output_cost=total_output_cost,
+                model_names=model_name
             )
-            
+
         except Exception as e:
             self.printer.print_in_terminal(
                 "quick_filter_failed",
@@ -250,16 +359,17 @@ class QuickFilter():
                 has_error=True,
                 error_message=str(e)
             )
-        
+
         if file_number_list:
             for file_number in file_number_list.file_list:
                 final_files[get_file_path(index_items[file_number].module_name)] = TargetFile(
                     file_path=index_items[file_number].module_name,
-                    reason=self.printer.get_message_from_key("quick_filter_reason")
+                    reason=self.printer.get_message_from_key(
+                        "quick_filter_reason")
                 )
-        end_time = time.monotonic()            
-        self.stats["timings"]["quick_filter"] = end_time - start_time            
+        end_time = time.monotonic()
+        self.stats["timings"]["quick_filter"] = end_time - start_time
         return QuickFilterResult(
             files=final_files,
             has_error=False
-        )    
+        )

autocoder/models.py

@@ -127,11 +127,23 @@ def update_model_input_price(name: str, price: float) -> bool:
     """更新模型输入价格
     
     Args:
-        name: 模型名称
-        price: 输入价格(M/百万input tokens)
+        name (str): 要更新的模型名称，必须与models.json中的记录匹配
+        price (float): 新的输入价格，单位：美元/百万tokens。必须大于等于0
         
     Returns:
-        bool: 是否更新成功
+        bool: 是否成功找到并更新了模型价格
+        
+    Raises:
+        ValueError: 如果price为负数时抛出
+        
+    Example:
+        >>> update_model_input_price("gpt-4", 3.0)
+        True
+        
+    Notes:
+        1. 价格设置后会立即生效并保存到models.json
+        2. 实际费用计算时会按实际使用量精确到小数点后6位
+        3. 设置价格为0表示该模型当前不可用
     """
     if price < 0:
         raise ValueError("Price cannot be negative")
@@ -151,11 +163,23 @@ def update_model_output_price(name: str, price: float) -> bool:
     """更新模型输出价格
     
     Args:
-        name: 模型名称
-        price: 输出价格(M/百万output tokens)
+        name (str): 要更新的模型名称，必须与models.json中的记录匹配
+        price (float): 新的输出价格，单位：美元/百万tokens。必须大于等于0
         
     Returns:
-        bool: 是否更新成功
+        bool: 是否成功找到并更新了模型价格
+        
+    Raises:
+        ValueError: 如果price为负数时抛出
+        
+    Example:
+        >>> update_model_output_price("gpt-4", 6.0)
+        True
+        
+    Notes:
+        1. 输出价格通常比输入价格高30%-50%
+        2. 对于按token计费的API，实际收费按(input_tokens * input_price + output_tokens * output_price)计算
+        3. 价格变更会影响所有依赖模型计费的功能（如成本预测、用量监控等）
     """
     if price < 0:
         raise ValueError("Price cannot be negative")
@@ -180,10 +204,7 @@ def update_model_speed(name: str, speed: float) -> bool:
         
     Returns:
         bool: 是否更新成功
-    """
-    if speed <= 0:
-        raise ValueError("Speed must be positive")
-        
+    """            
     models = load_models()
     updated = False
     for model in models:

autocoder/pyproject/__init__.py

@@ -116,6 +116,7 @@ class PyProject:
             "actions",
             ".vscode",
             ".idea",
+            "venv",
         ]
 
     @byzerllm.prompt()

autocoder/suffixproject/__init__.py

@@ -56,6 +56,7 @@ class SuffixProject:
             ".vscode",
             "actions",
             ".idea",
+            "venv",
         ]
 
     @byzerllm.prompt()

autocoder/tsproject/__init__.py

@@ -48,6 +48,7 @@ class TSProject:
             "actions",
             ".vscode",
             ".idea",
+            "venv",
         ]
 
     @byzerllm.prompt()

autocoder/utils/llms.py

@@ -3,9 +3,15 @@ from typing import Union,Optional
 
 def get_llm_names(llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM,str],target_model_type:Optional[str]=None):
    if target_model_type is None:
+      if isinstance(llm,list):
+         return [_llm.default_model_name for _llm in llm]
       return [llm.default_model_name for llm in [llm] if llm.default_model_name]
+   
    llms = llm.get_sub_client(target_model_type) 
+   
    if llms is None:
+      if isinstance(llm,list):
+         return [_llm.default_model_name for _llm in llm]
       return [llm.default_model_name for llm in [llm] if llm.default_model_name]
    elif isinstance(llms, list):
        return [llm.default_model_name for llm in llms if llm.default_model_name]
@@ -14,6 +20,27 @@ def get_llm_names(llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM,str],tar
    else:
       return [llm.default_model_name for llm in [llms] if llm.default_model_name]
 
+def get_model_info(model_names: str, product_mode: str):    
+    from autocoder import models as models_module
+    def get_model_by_name(model_name: str):
+        try:
+            return models_module.get_model_by_name(model_name)
+        except Exception as e:
+            return None
+    
+    if product_mode == "pro":
+        return None
+
+    if product_mode == "lite":
+        if "," in model_names:
+            # Multiple code models specified
+            model_names = model_names.split(",")
+            for _, model_name in enumerate(model_names):
+                return get_model_by_name(model_name)
+        else:
+            # Single code model
+            return get_model_by_name(model_names)
+
 def get_single_llm(model_names: str, product_mode: str):
     from autocoder import models as models_module
     if product_mode == "pro":

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.254"
+__version__ = "0.1.256"