auto-coder 0.1.192__py3-none-any.whl → 0.1.194__py3-none-any.whl

autocoder/index/index.py

@@ -39,6 +39,9 @@ class TargetFile(pydantic.BaseModel):
         ..., description="The reason why the file is the target file"
     )
 
+class VerifyFileRelevance(pydantic.BaseModel):
+    relevant_score: int
+    reason: str
 
 class FileList(pydantic.BaseModel):
     file_list: List[TargetFile]
@@ -70,23 +73,67 @@ class IndexManager:
         if not os.path.exists(self.index_dir):
             os.makedirs(self.index_dir)
 
-    @byzerllm.prompt(lambda self: self.llm, render="jinja2")
-    def _get_related_files(self, indices: str, file_paths: str) -> FileList:
+    @byzerllm.prompt()
+    def verify_file_relevance(self, file_content: str, query: str) -> str:
         """
-        下面是所有文件以及对应的符号信息：
+        请验证下面的文件内容是否与用户问题相关:
 
-        {{ indices }}
+        文件内容:
+        {{ file_content }}
 
-        注意，
-        1. 找到的文件名必须出现在上面的文件列表中
-        2. 如果没有相关的文件，返回空即可
+        用户问题:
+        {{ query }}
+
+        相关是指，需要依赖这个文件提供上下文，或者需要修改这个文件才能解决用户的问题。
+        请给出相应的可能性分数：0-10，并结合用户问题，理由控制在50字以内。格式如下:
+
+        ```json
+        {
+            "relevant_score": 0-10, // 相关分数
+            "reason": "这是相关的原因..."
+        }
+        ```
+        """        
+
+    @byzerllm.prompt()
+    def _get_related_files(self, indices: str, file_paths: str) -> str:
+        """
+        下面是所有文件以及对应的符号信息：
+
+        {{ indices }}        
 
         请参考上面的信息，找到被下列文件使用或者引用到的文件列表：
 
         {{ file_paths }}
+
+        请按如下格式进行输出：
+
+        ```json
+        {
+            "file_list": [
+                {
+                    "file_path": "path/to/file.py",
+                    "reason": "The reason why the file is the target file"
+                },
+                {
+                    "file_path": "path/to/file.py",
+                    "reason": "The reason why the file is the target file"
+                }
+            ]
+        }
+        ```
+
+        注意，
+        1. 找到的文件名必须出现在上面的文件列表中
+        2. 原因控制在20字以内
+        3. 如果没有相关的文件，输出如下 json 即可：
+        
+        ```json
+        {"file_list": []}
+        ```
         """
 
-    @byzerllm.prompt(lambda self: self.index_llm, render="jinja2")
+    @byzerllm.prompt()
     def get_all_file_symbols(self, path: str, code: str) -> str:
         """
         你的目标是从给定的代码中获取代码里的符号，需要获取的符号类型包括：
@@ -184,12 +231,12 @@ class IndexManager:
                 )
                 symbols = []
                 for chunk in chunks:
-                    chunk_symbols = self.get_all_file_symbols(source.module_name, chunk)
+                    chunk_symbols = self.get_all_file_symbols.with_llm(self.index_llm).run(source.module_name, chunk)
                     time.sleep(self.anti_quota_limit)
                     symbols.append(chunk_symbols)
                 symbols = "\n".join(symbols)
             else:
-                symbols = self.get_all_file_symbols(source.module_name, source_code)
+                symbols = self.get_all_file_symbols.with_llm(self.index_llm).run(source.module_name, source_code)
                 time.sleep(self.anti_quota_limit)
 
             logger.info(
@@ -309,35 +356,56 @@ class IndexManager:
         current_chunk = []
         current_size = 0
 
-        for item in index_items:
-            symbols_str = item.symbols
-            if includes:
-                symbol_info = extract_symbols(symbols_str)
-                symbols_str = symbols_info_to_str(symbol_info, includes)
+        if max_chunk_size == -1:
+            for item in index_items:
+                symbols_str = item.symbols
+                if includes:
+                    symbol_info = extract_symbols(symbols_str)
+                    symbols_str = symbols_info_to_str(symbol_info, includes)
 
-            item_str = f"##{item.module_name}\n{symbols_str}\n\n"
+                item_str = f"##{item.module_name}\n{symbols_str}\n\n"
 
-            if skip_symbols:
-                item_str = f"{item.module_name}\n"
-            item_size = len(item_str)
+                if skip_symbols:
+                    item_str = f"{item.module_name}\n"                
 
-            if current_size + item_size > max_chunk_size:
-                yield "".join(current_chunk)
-                current_chunk = [item_str]
-                current_size = item_size
-            else:
-                current_chunk.append(item_str)
-                current_size += item_size
+                if len(current_chunk) > self.args.filter_batch_size:
+                    yield "".join(current_chunk)
+                    current_chunk = [item_str]                    
+                else:
+                    current_chunk.append(item_str)                    
 
-        if current_chunk:
-            yield "".join(current_chunk)
+            if current_chunk:
+                yield "".join(current_chunk)
+        else:
+            for item in index_items:
+                symbols_str = item.symbols
+                if includes:
+                    symbol_info = extract_symbols(symbols_str)
+                    symbols_str = symbols_info_to_str(symbol_info, includes)
+
+                item_str = f"##{item.module_name}\n{symbols_str}\n\n"
+
+                if skip_symbols:
+                    item_str = f"{item.module_name}\n"
+                item_size = len(item_str)
+
+                if current_size + item_size > max_chunk_size:
+                    yield "".join(current_chunk)
+                    current_chunk = [item_str]
+                    current_size = item_size
+                else:
+                    current_chunk.append(item_str)
+                    current_size += item_size
+
+            if current_chunk:
+                yield "".join(current_chunk)
 
     def get_related_files(self, file_paths: List[str]):
         all_results = []
         lock = threading.Lock()
 
         def process_chunk(chunk, chunk_count):
-            result = self._get_related_files(chunk, "\n".join(file_paths))
+            result = self._get_related_files.with_llm(self.llm).with_return_type(FileList).run(chunk, "\n".join(file_paths))
             if result is not None:
                 with lock:
                     all_results.extend(result.file_list)
@@ -351,7 +419,7 @@ class IndexManager:
             futures = []
             chunk_count = 0
             for chunk in self._get_meta_str(
-                max_chunk_size=self.max_input_length - 1000
+                max_chunk_size= -1
             ):
                 future = executor.submit(process_chunk, chunk, chunk_count)
                 futures.append(future)
@@ -371,7 +439,7 @@ class IndexManager:
 
         def process_chunk(chunk):
             nonlocal completed_threads
-            result = self._get_target_files_by_query(chunk, query)
+            result = self._get_target_files_by_query.with_llm(self.llm).with_return_type(FileList).run(chunk, query)
             if result is not None:
                 with lock:
                     all_results.extend(result.file_list)
@@ -401,25 +469,21 @@ class IndexManager:
         def w():
             return self._get_meta_str(
                 skip_symbols=False,
-                max_chunk_size=self.max_input_length - 1000,
+                max_chunk_size= -1,
                 includes=[SymbolType.USAGE],
             )
-
-        logger.info("Find the related files by query according to the files...")
-        temp_result, total_threads, completed_threads = self._query_index_with_thread(query, w)
-        logger.info(f"Used {self.args.index_filter_workers} workers in parallel. Completed {completed_threads}/{total_threads} threads.")
+        
+        temp_result, total_threads, completed_threads = self._query_index_with_thread(query, w)        
         all_results.extend(temp_result)
 
         if self.args.index_filter_level >= 1:
-            logger.info("Find the related files by query according to the symbols...")
 
             def w():
                 return self._get_meta_str(
-                    skip_symbols=False, max_chunk_size=self.max_input_length - 1000
+                    skip_symbols=False, max_chunk_size= -1
                 )
 
-            temp_result, total_threads, completed_threads = self._query_index_with_thread(query, w)
-            logger.info(f"Used {self.args.index_filter_workers} workers in parallel. Completed {completed_threads}/{total_threads} threads.")
+            temp_result, total_threads, completed_threads = self._query_index_with_thread(query, w)            
             all_results.extend(temp_result)
 
         all_results = list({file.file_path: file for file in all_results}.values())
@@ -427,8 +491,8 @@ class IndexManager:
         limited_results = all_results[: self.args.index_filter_file_num]
         return FileList(file_list=limited_results)
 
-    @byzerllm.prompt(lambda self: self.llm, check_result=True)
-    def _get_target_files_by_query(self, indices: str, query: str) -> FileList:
+    @byzerllm.prompt()
+    def _get_target_files_by_query(self, indices: str, query: str) -> str:
         """
         下面是已知文件以及对应的符号信息：
 
@@ -438,7 +502,28 @@ class IndexManager:
 
         {{ query }}
 
-        现在，请根据用户的问题以及前面的文件和符号信息，寻找相关文件路径。如果没有找到，返回空即可。
+        现在，请根据用户的问题以及前面的文件和符号信息，寻找相关文件路径。返回结果按如下格式：        
+
+        ```json
+        {
+            "file_list": [
+                {
+                    "file_path": "path/to/file.py",
+                    "reason": "The reason why the file is the target file"
+                },
+                {
+                    "file_path": "path/to/file.py",
+                    "reason": "The reason why the file is the target file"
+                }
+            ]
+        }
+        ```
+        
+        如果没有找到，返回如下 json 即可：
+
+        ```json
+            {"file_list": []}
+        ```
 
         请严格遵循以下步骤：
 
@@ -459,15 +544,9 @@ class IndexManager:
            - 如果找到了相关文件，也包括与之直接相关的依赖文件。
 
         5. 考虑文件用途：
-           - 使用每个文件的 "用途" 信息来判断其与查询的相关性。
+           - 使用每个文件的 "用途" 信息来判断其与查询的相关性。 
 
-        6. 构建结果：
-           - 对于每个相关文件，创建一个TargetFile对象。
-           - 在reason字段中，详细说明为什么这个文件与查询相关。
-
-        7. 返回结果：
-           - 将所有找到的TargetFile对象放入FileList中返回。
-           - 如果没有找到相关文件，返回一个空的FileList。
+        6. 按格式要求返回结果
 
         请确保结果的准确性和完整性，包括所有可能相关的文件。
         """
@@ -476,6 +555,16 @@ class IndexManager:
 def build_index_and_filter_files(
     llm, args: AutoCoderArgs, sources: List[SourceCode]
 ) -> str:
+    # Initialize timing and statistics
+    total_start_time = time.monotonic()
+    stats = {
+        "total_files": len(sources),
+        "indexed_files": 0,
+        "level1_filtered": 0,
+        "level2_filtered": 0,
+        "final_files": 0,
+        "timings": {}
+    }
 
     def get_file_path(file_path):
         if file_path.startswith("##"):
@@ -484,46 +573,97 @@ def build_index_and_filter_files(
 
     final_files: Dict[str, TargetFile] = {}
 
-    ## keep Rest/RAG/Search sources
+    # Phase 1: Process REST/RAG/Search sources
+    logger.info("Phase 1: Processing REST/RAG/Search sources...")
+    phase_start = time.monotonic()
     for source in sources:
         if source.tag in ["REST", "RAG", "SEARCH"]:
             final_files[get_file_path(source.module_name)] = TargetFile(
                 file_path=source.module_name, reason="Rest/Rag/Search"
             )
+    stats["timings"]["process_tagged_sources"] = time.monotonic() - phase_start
 
     if not args.skip_build_index and llm:
-        logger.info("Building index for all files...")
+        # Phase 2: Build index
+        logger.info("Phase 2: Building index for all files...")
+        phase_start = time.monotonic()
         index_manager = IndexManager(llm=llm, sources=sources, args=args)
-        index_manager.build_index()
+        index_data = index_manager.build_index()
+        stats["indexed_files"] = len(index_data) if index_data else 0
+        stats["timings"]["build_index"] = time.monotonic() - phase_start
 
         if not args.skip_filter_index:
-            logger.info(f"Finding related files in the index...")
-            start_time = time.monotonic()
+            # Phase 3: Level 1 filtering - Query-based
+            logger.info("Phase 3: Performing Level 1 filtering (query-based)...")
+            phase_start = time.monotonic()
             target_files = index_manager.get_target_files_by_query(args.query)
 
             if target_files:
                 for file in target_files.file_list:
                     file_path = file.file_path.strip()
                     final_files[get_file_path(file_path)] = file
+                stats["level1_filtered"] = len(target_files.file_list)
+            stats["timings"]["level1_filter"] = time.monotonic() - phase_start
 
+            # Phase 4: Level 2 filtering - Related files
             if target_files is not None and args.index_filter_level >= 2:
-                related_fiels = index_manager.get_related_files(
+                logger.info("Phase 4: Performing Level 2 filtering (related files)...")
+                phase_start = time.monotonic()
+                related_files = index_manager.get_related_files(
                     [file.file_path for file in target_files.file_list]
                 )
-                if related_fiels is not None:
-                    for file in related_fiels.file_list:
+                if related_files is not None:
+                    for file in related_files.file_list:
                         file_path = file.file_path.strip()
                         final_files[get_file_path(file_path)] = file
+                    stats["level2_filtered"] = len(related_files.file_list)
+                stats["timings"]["level2_filter"] = time.monotonic() - phase_start
 
             if not final_files:
-                logger.warning("Warning: No related files found, use all files")
+                logger.warning("No related files found, using all files")
                 for source in sources:
                     final_files[get_file_path(source.module_name)] = TargetFile(
                         file_path=source.module_name,
                         reason="No related files found, use all files",
                     )
 
-            logger.info(f"Find related files took {time.monotonic() - start_time:.2f}s")
+            # Phase 5: Relevance verification
+            logger.info("Phase 5: Performing relevance verification...")
+            phase_start = time.monotonic()
+            verified_files = {}
+            temp_files = list(final_files.values())
+            
+            def verify_single_file(file: TargetFile):
+                for source in sources:
+                    if source.module_name == file.file_path:
+                        file_content = source.source_code
+                        try:
+                            result = index_manager.verify_file_relevance.with_llm(llm).with_return_type(VerifyFileRelevance).run(
+                                file_content=file_content, 
+                                query=args.query
+                            )                            
+                            if result.relevant_score >= args.verify_file_relevance_score:
+                                return file.file_path, TargetFile(
+                                    file_path=file.file_path,
+                                    reason=f"Score:{result.relevant_score}, {result.reason}"
+                                )
+                        except Exception as e:
+                            logger.warning(f"Failed to verify file {file.file_path}: {str(e)}")
+                return None
+
+            with ThreadPoolExecutor(max_workers=args.index_filter_workers) as executor:
+                futures = [executor.submit(verify_single_file, file) for file in temp_files]
+                for future in as_completed(futures):
+                    result = future.result()
+                    if result:
+                        file_path, target_file = result
+                        verified_files[file_path] = target_file
+                        time.sleep(args.anti_quota_limit)
+                        
+            stats["verified_files"] = len(verified_files)
+            stats["timings"]["relevance_verification"] = time.monotonic() - phase_start
+            
+            final_files = verified_files if verified_files else final_files
 
     def display_table_and_get_selections(data):
         from prompt_toolkit.shortcuts import checkboxlist_dialog
@@ -574,12 +714,15 @@ def build_index_and_filter_files(
 
         console.print(panel)
 
+    # Phase 6: File selection and limitation 
+    logger.info("Phase 6: Processing file selection and limits...")
+    phase_start = time.monotonic()
+    
     if args.index_filter_file_num > 0:
-        logger.info(f"args.index_filter_file_num: {args.index_filter_file_num} is not 0, so we need to limit the number of files (total: {len(final_filenames)})")    
+        logger.info(f"Limiting files from {len(final_files)} to {args.index_filter_file_num}")
 
     if args.skip_confirm:
         final_filenames = [file.file_path for file in final_files.values()]
-        # Limit the number of files based on index_filter_file_num
         if args.index_filter_file_num > 0:
             final_filenames = final_filenames[: args.index_filter_file_num]
     else:
@@ -593,10 +736,16 @@ def build_index_and_filter_files(
             final_filenames = []
         else:
             final_filenames = display_table_and_get_selections(target_files_data)
-                
+            
         if args.index_filter_file_num > 0:
             final_filenames = final_filenames[: args.index_filter_file_num]
+    
+    stats["timings"]["file_selection"] = time.monotonic() - phase_start
 
+    # Phase 7: Display results and prepare output
+    logger.info("Phase 7: Preparing final output...")
+    phase_start = time.monotonic()
+    
     try:
         print_selected(
             [
@@ -607,9 +756,9 @@ def build_index_and_filter_files(
         )
     except Exception as e:
         logger.warning(
-            f"Fails to display the selected files. You may not in a terminal environment. Try to use print function to display the selected files. "
+            "Failed to display selected files in terminal mode. Falling back to simple print."
         )
-        print(f"Target Files You Selected")
+        print("Target Files Selected:")
         for file in final_filenames:
             print(f"{file} - {final_files[file].reason}")
 
@@ -623,4 +772,26 @@ def build_index_and_filter_files(
             depulicated_sources.add(file.module_name)
             source_code += f"##File: {file.module_name}\n"
             source_code += f"{file.source_code}\n\n"
+    
+    stats["final_files"] = len(depulicated_sources)
+    stats["timings"]["prepare_output"] = time.monotonic() - phase_start
+    
+    # Calculate total time and print summary
+    total_time = time.monotonic() - total_start_time
+    stats["timings"]["total"] = total_time
+    
+    # Print final statistics
+    logger.info("\n=== Build Index and Filter Files Summary ===")
+    logger.info(f"Total files in project: {stats['total_files']}")
+    logger.info(f"Files indexed: {stats['indexed_files']}")
+    logger.info(f"Files after Level 1 filter: {stats['level1_filtered']}")
+    logger.info(f"Files after Level 2 filter: {stats['level2_filtered']}")
+    logger.info(f"Files after relevance verification: {stats.get('verified_files', 0)}")
+    logger.info(f"Final files selected: {stats['final_files']}")
+    logger.info("\nTime breakdown:")
+    for phase, duration in stats["timings"].items():
+        logger.info(f"  - {phase}: {duration:.2f}s")
+    logger.info(f"Total execution time: {total_time:.2f}s")
+    logger.info("==========================================\n")
+    
     return source_code

autocoder/lang.py

@@ -53,6 +53,7 @@ lang_desc = {
         "index_model_max_input_length":"The maximum length of the input to the index model. Default is 0, which means using the value of model_max_input_length",
         "index_model_anti_quota_limit":"Time to wait in seconds after each API request for the index model. Default is 0, which means using the value of anti_quota_limit",
         "doc_build_parse_required_exts":"The required file extensions for doc build. Default is empty string",
+        "verify_file_relevance_score": "The relevance score threshold for file verification. Default is 6",
         "init_desc": "Initialize a new auto-coder project directory",
         "init_dir": "The directory to initialize the auto-coder project in",
         "index_build_workers": "Number of workers to use for building index",
@@ -69,7 +70,8 @@ lang_desc = {
         "next_desc": "create a new action file based one the last action file",
         "base_dir": "Alternative path for /~/.auto-coder to store or retrieve text embeddings. Using /~/.auto-coder/ if not specified",
         "editblock_similarity": "The similarity threshold of TextSimilarity when merging edit blocks. Default is 0.9",
-        "include_project_structure": "Whether to include the project directory structure in the code generation prompt. Default is False"
+        "include_project_structure": "Whether to include the project directory structure in the code generation prompt. Default is False",
+        "filter_batch_size": "The batch size used when filtering files. Default is 5"
     },
     "zh": {
         "request_id": "Request ID",
@@ -123,8 +125,9 @@ lang_desc = {
         "enable_multi_round_generate":"是否开启多轮对话生成。默认为False",
         "index_model_max_length":"索引模型生成代码的最大长度。默认为0,表示使用model_max_length的值",
         "index_model_max_input_length":"索引模型的最大输入长度。默认为0,表示使用model_max_input_length的值",
-        "index_model_anti_quota_limit":"每次索引模型API请求后等待的秒数。默认为0,表示使用anti_quota_limit的值",
+        "index_model_anti_quota_limit": "每次索引模型API请求后等待的秒数。默认为0,表示使用anti_quota_limit的值",
         "doc_build_parse_required_exts":"doc构建所需的文件扩展名。默认为空字符串",
+        "verify_file_relevance_score": "验证文件相关性的分数阈值。默认为6",
         "init_desc": "初始化一个新的auto-coder项目目录",
         "init_dir": "初始化auto-coder项目的目录",
         "index_build_workers": "用于构建索引的工作线程数",
@@ -141,6 +144,7 @@ lang_desc = {
         "next_from_yaml": "创建新的action文件时要从中复制内容的YAML文件。支持前缀匹配，例如，指定'001'将匹配'001_abc.yml'。",
         "base_dir": "用于替代byzerllm中/~/.auto-coder的路径存放或读取向量化后的文本。不指定则使用默认路径",
         "editblock_similarity": "合并编辑块时TextSimilarity的相似度阈值。默认为0.9",
-        "include_project_structure": "在生成代码的提示中是否包含项目目录结构。默认为False"
+        "include_project_structure": "在生成代码的提示中是否包含项目目录结构。默认为False",
+        "filter_batch_size": "文件过滤时使用的批处理大小。默认为5"
     }
 }

autocoder/pyproject/__init__.py

@@ -163,8 +163,7 @@ class PyProject:
 
     def should_exclude(self, file_path):
         for pattern in self.exclude_patterns:
-            if pattern.search(file_path):
-                logger.info(f"Excluding file: {file_path}")
+            if pattern.search(file_path):                
                 return True
         return False
 

autocoder/suffixproject/__init__.py

@@ -104,8 +104,7 @@ class SuffixProject:
 
     def should_exclude(self, file_path):
         for pattern in self.exclude_patterns:
-            if pattern.search(file_path):
-                logger.info(f"Excluding file: {file_path}")
+            if pattern.search(file_path):                
                 return True
         return False
 

autocoder/tsproject/__init__.py

@@ -92,8 +92,7 @@ class TSProject:
 
     def should_exclude(self, file_path):
         for pattern in self.exclude_patterns:
-            if pattern.search(file_path):
-                logger.info(f"Excluding file: {file_path}")
+            if pattern.search(file_path):                
                 return True
         return False
 

autocoder/utils/queue_communicate.py

@@ -15,12 +15,15 @@ class CommunicateEventType(Enum):
     CODE_END = "code_end"
     CODE_HUMAN_AS_MODEL = "code_human_as_model"
     ASK_HUMAN = "ask_human"
+    CODE_ERROR = "code_error"
 
+TIMEOUT = 600*3
 @dataclass(eq=True, frozen=True)
 class CommunicateEvent:
     event_type: str
     data: str
 
+
 class Singleton(type):
     _instances = {}
     _lock = threading.Lock()
@@ -34,11 +37,31 @@ class Singleton(type):
 
 class QueueCommunicate(metaclass=Singleton):
     def __init__(self):
+        # Structure:
+        # {
+        #    "request_id_1": Queue(),
+        #    "request_id_2": Queue(),
+        #    ...
+        # }
         self.request_queues = {}
+
+        # Structure:
+        # {
+        #    "request_id_1": {
+        #        event1: Queue(),
+        #        event2: Queue(),
+        #        ...
+        #    },
+        #    "request_id_2": {
+        #        event1: Queue(),
+        #        event2: Queue(),
+        #        ...
+        #    }
+        # }
         self.response_queues = {}
         self.lock = threading.Lock()
-        self.send_event_executor = ThreadPoolExecutor(max_workers=10)
-        self.consume_event_executor = ThreadPoolExecutor(max_workers=10)
+        self.send_event_executor = ThreadPoolExecutor(max_workers=100)
+        self.consume_event_executor = ThreadPoolExecutor(max_workers=100)
 
     def shutdown(self):
         self.send_event_executor.shutdown()
@@ -56,7 +79,7 @@ class QueueCommunicate(metaclass=Singleton):
             if request_id in self.response_queues:
                 self.response_queues.pop(request_id)
 
-    def send_event(self, request_id: str, event: Any, timeout: int = 300) -> Any:
+    def send_event(self, request_id: str, event: Any, timeout: int = TIMEOUT) -> Any:
         if not request_id:
             return None
 
@@ -64,8 +87,8 @@ class QueueCommunicate(metaclass=Singleton):
             self._send_event_task, request_id, event
         )
         return future.result(timeout=timeout)
-    
-    def send_event_no_wait(self, request_id: str, event: Any, timeout: int = 300)-> Any:
+
+    def send_event_no_wait(self, request_id: str, event: Any, timeout: int = TIMEOUT) -> Any:
         if not request_id:
             return None
 
@@ -74,7 +97,7 @@ class QueueCommunicate(metaclass=Singleton):
         )
         return future
 
-    def _send_event_task(self, request_id: str, event: Any, timeout: int = 300) -> Any:        
+    def _send_event_task(self, request_id: str, event: Any, timeout: int = TIMEOUT) -> Any:
         with self.lock:
             if request_id not in self.request_queues:
                 self.request_queues[request_id] = Queue()
@@ -87,7 +110,7 @@ class QueueCommunicate(metaclass=Singleton):
             response_queues[event] = response_queue
 
         request_queue.put(event)
-        response = response_queue.get(timeout=timeout)        
+        response = response_queue.get(timeout=timeout)
         return response
 
     def consume_events(self, request_id: str, event_handler: Callable[[Any], Any]):

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.192"
+__version__ = "0.1.194"