bioguider 0.2.20__py3-none-any.whl → 0.2.21__py3-none-any.whl

bioguider/utils/{file_handler.py → python_file_handler.py}

@@ -1,7 +1,7 @@
 import ast
 import os
 
-class FileHandler:
+class PythonFileHandler:
     def __init__(self, file_path: str):
         self.file_path = file_path
 

bioguider/utils/r_file_handler.py

@@ -0,0 +1,368 @@
+import re
+import os
+from typing import List, Tuple, Optional
+
+class RFileHandler:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    def get_functions_and_classes(self) -> List[Tuple[str, Optional[str], int, int, Optional[str], List[str]]]:
+        """
+        Get the functions and S4 classes in a given R file.
+        Returns a list of tuples, each containing:
+        1. the function or class name,
+        2. parent name (None for R, as R doesn't have nested functions in the same way),
+        3. start line number,
+        4. end line number,
+        5. doc string (roxygen comments),
+        6. params (function parameters).
+        """
+        with open(self.file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        
+        functions_and_classes = []
+        i = 0
+        
+        while i < len(lines):
+            line = lines[i].strip()
+            
+            # Skip empty lines and comments (except roxygen)
+            if not line or (line.startswith('#') and not line.startswith('#\'') and not line.startswith('#@')):
+                i += 1
+                continue
+            
+            # Check for function definitions
+            func_match = self._match_function(lines, i)
+            if func_match:
+                name, start_line, end_line, doc_string, params = func_match
+                functions_and_classes.append((name, None, start_line + 1, end_line + 1, doc_string, params))
+                i = end_line + 1
+                continue
+            
+            # Check for S4 class definitions
+            class_match = self._match_s4_class(lines, i)
+            if class_match:
+                name, start_line, end_line, doc_string = class_match
+                functions_and_classes.append((name, None, start_line + 1, end_line + 1, doc_string, []))
+                i = end_line + 1
+                continue
+            
+            # Check for S3 class methods (functions with class-specific naming)
+            s3_match = self._match_s3_method(lines, i)
+            if s3_match:
+                name, start_line, end_line, doc_string, params = s3_match
+                functions_and_classes.append((name, None, start_line + 1, end_line + 1, doc_string, params))
+                i = end_line + 1
+                continue
+            
+            i += 1
+        
+        return functions_and_classes
+    
+    def _match_function(self, lines: List[str], start_idx: int) -> Optional[Tuple[str, int, int, Optional[str], List[str]]]:
+        """Match function definitions in R code."""
+        # Collect roxygen documentation before function
+        doc_string = self._extract_roxygen_doc(lines, start_idx)
+        doc_start_idx = start_idx
+        
+        # Skip roxygen comments to find function definition
+        while start_idx < len(lines) and (lines[start_idx].strip().startswith('#\'') or 
+                                         lines[start_idx].strip().startswith('#@') or 
+                                         not lines[start_idx].strip()):
+            start_idx += 1
+        
+        if start_idx >= len(lines):
+            return None
+        
+        # Pattern for function definition: name <- function(params) or name = function(params)
+        func_pattern = r'^(\s*)([a-zA-Z_][a-zA-Z0-9_.\$]*)\s*(<-|=)\s*function\s*\('
+        
+        line = lines[start_idx]
+        match = re.match(func_pattern, line)
+        
+        if not match:
+            return None
+        
+        func_name = match.group(2)
+        indent_level = len(match.group(1))
+        
+        # Extract parameters
+        params = self._extract_function_params(lines, start_idx)
+        
+        # Find the end of the function by tracking braces
+        end_idx = self._find_function_end(lines, start_idx, indent_level)
+        
+        return func_name, doc_start_idx, end_idx, doc_string, params
+    
+    def _match_s4_class(self, lines: List[str], start_idx: int) -> Optional[Tuple[str, int, int, Optional[str]]]:
+        """Match S4 class definitions."""
+        doc_string = self._extract_roxygen_doc(lines, start_idx)
+        doc_start_idx = start_idx
+        
+        # Skip documentation to find class definition
+        while start_idx < len(lines) and (lines[start_idx].strip().startswith('#\'') or 
+                                         lines[start_idx].strip().startswith('#@') or 
+                                         not lines[start_idx].strip()):
+            start_idx += 1
+        
+        if start_idx >= len(lines):
+            return None
+        
+        # Pattern for S4 class: setClass("ClassName", ...)
+        class_pattern = r'setClass\s*\(\s*["\']([^"\']+)["\']'
+        
+        line = lines[start_idx]
+        match = re.search(class_pattern, line)
+        
+        if not match:
+            return None
+        
+        class_name = match.group(1)
+        
+        # Find the end by tracking parentheses
+        end_idx = self._find_parentheses_end(lines, start_idx)
+        
+        return class_name, doc_start_idx, end_idx, doc_string
+    
+    def _match_s3_method(self, lines: List[str], start_idx: int) -> Optional[Tuple[str, int, int, Optional[str], List[str]]]:
+        """Match S3 method definitions (method.class pattern)."""
+        doc_string = self._extract_roxygen_doc(lines, start_idx)
+        doc_start_idx = start_idx
+        
+        # Skip documentation
+        while start_idx < len(lines) and (lines[start_idx].strip().startswith('#\'') or 
+                                         lines[start_idx].strip().startswith('#@') or 
+                                         not lines[start_idx].strip()):
+            start_idx += 1
+        
+        if start_idx >= len(lines):
+            return None
+        
+        # Pattern for S3 method: method.class <- function(params)
+        s3_pattern = r'^(\s*)([a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*)\s*(<-|=)\s*function\s*\('
+        
+        line = lines[start_idx]
+        match = re.match(s3_pattern, line)
+        
+        if not match:
+            return None
+        
+        method_name = match.group(2)
+        indent_level = len(match.group(1))
+        
+        # Extract parameters
+        params = self._extract_function_params(lines, start_idx)
+        
+        # Find the end of the function
+        end_idx = self._find_function_end(lines, start_idx, indent_level)
+        
+        return method_name, doc_start_idx, end_idx, doc_string, params
+    
+    def _extract_roxygen_doc(self, lines: List[str], start_idx: int) -> Optional[str]:
+        """Extract roxygen2 documentation comments."""
+        doc_lines = []
+        i = start_idx
+        
+        # Go backwards to find the start of roxygen comments
+        while i > 0 and (lines[i-1].strip().startswith('#\'') or lines[i-1].strip().startswith('#@') or not lines[i-1].strip()):
+            if lines[i-1].strip().startswith('#\'') or lines[i-1].strip().startswith('#@'):
+                i -= 1
+            elif not lines[i-1].strip():
+                i -= 1
+            else:
+                break
+        
+        # Collect roxygen comments
+        while i < len(lines):
+            line = lines[i].strip()
+            if line.startswith('#\'') or line.startswith('#@'):
+                # Remove the roxygen prefix
+                clean_line = re.sub(r'^#[\'@]\s?', '', line)
+                doc_lines.append(clean_line)
+                i += 1
+            elif not line:  # Empty line
+                i += 1
+            else:
+                break
+        
+        return '\n'.join(doc_lines) if doc_lines else None
+    
+    def _extract_function_params(self, lines: List[str], start_idx: int) -> List[str]:
+        """Extract function parameters from function definition."""
+        params = []
+        
+        # Find the function line and extract parameters
+        func_line_complete = ""
+        i = start_idx
+        paren_count = 0
+        found_opening = False
+        
+        while i < len(lines):
+            line = lines[i]
+            func_line_complete += line
+            
+            # Count parentheses to find the complete parameter list
+            for char in line:
+                if char == '(':
+                    paren_count += 1
+                    found_opening = True
+                elif char == ')':
+                    paren_count -= 1
+            
+            if found_opening and paren_count == 0:
+                break
+            i += 1
+        
+        # Extract parameters using regex
+        param_match = re.search(r'function\s*\((.*?)\)', func_line_complete, re.DOTALL)
+        if param_match:
+            param_str = param_match.group(1).strip()
+            if param_str:
+                # Split by comma, but be careful with nested parentheses and quotes
+                params = self._smart_split_params(param_str)
+                # Clean up parameter names (remove default values, whitespace)
+                params = [re.split(r'\s*=\s*', param.strip())[0].strip() for param in params]
+                params = [param for param in params if param and param != '...']
+        
+        return params
+    
+    def _smart_split_params(self, param_str: str) -> List[str]:
+        """Split parameters by comma, handling nested structures."""
+        params = []
+        current_param = ""
+        paren_count = 0
+        quote_char = None
+        
+        for char in param_str:
+            if quote_char:
+                current_param += char
+                if char == quote_char and (len(current_param) == 1 or current_param[-2] != '\\'):
+                    quote_char = None
+            elif char in ['"', "'"]:
+                quote_char = char
+                current_param += char
+            elif char == '(':
+                paren_count += 1
+                current_param += char
+            elif char == ')':
+                paren_count -= 1
+                current_param += char
+            elif char == ',' and paren_count == 0:
+                params.append(current_param.strip())
+                current_param = ""
+            else:
+                current_param += char
+        
+        if current_param.strip():
+            params.append(current_param.strip())
+        
+        return params
+    
+    def _find_function_end(self, lines: List[str], start_idx: int, indent_level: int) -> int:
+        """Find the end of a function by tracking braces and indentation."""
+        brace_count = 0
+        in_function = False
+        i = start_idx
+        
+        while i < len(lines):
+            line = lines[i]
+            
+            # Count braces
+            for char in line:
+                if char == '{':
+                    brace_count += 1
+                    in_function = True
+                elif char == '}':
+                    brace_count -= 1
+            
+            # If we've closed all braces, we're at the end
+            if in_function and brace_count == 0:
+                return i
+            
+            # If no braces are used, look for next function or end of file
+            if not in_function and i > start_idx:
+                stripped = line.strip()
+                if stripped and not stripped.startswith('#'):
+                    # Check if this looks like a new function or assignment at same/higher level
+                    if re.match(r'^(\s*)[a-zA-Z_][a-zA-Z0-9_.\$]*\s*(<-|=)', line):
+                        current_indent = len(re.match(r'^(\s*)', line).group(1))
+                        if current_indent <= indent_level:
+                            return i - 1
+            
+            i += 1
+        
+        return len(lines) - 1
+    
+    def _find_parentheses_end(self, lines: List[str], start_idx: int) -> int:
+        """Find the end of a parenthetical expression."""
+        paren_count = 0
+        i = start_idx
+        
+        while i < len(lines):
+            line = lines[i]
+            for char in line:
+                if char == '(':
+                    paren_count += 1
+                elif char == ')':
+                    paren_count -= 1
+                    if paren_count == 0:
+                        return i
+            i += 1
+        
+        return len(lines) - 1
+    
+    def get_imports(self) -> List[str]:
+        """
+        Get library imports and source statements in R code.
+        Returns a list of library names and sourced files.
+        """
+        imports = []
+        
+        with open(self.file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        
+        for line in lines:
+            line = line.strip()
+            
+            # Match library() calls
+            lib_match = re.search(r'library\s*\(\s*["\']?([^"\')\s]+)["\']?\s*\)', line)
+            if lib_match:
+                imports.append(f"library({lib_match.group(1)})")
+            
+            # Match require() calls
+            req_match = re.search(r'require\s*\(\s*["\']?([^"\')\s]+)["\']?\s*\)', line)
+            if req_match:
+                imports.append(f"require({req_match.group(1)})")
+            
+            # Match source() calls
+            src_match = re.search(r'source\s*\(\s*["\']([^"\']+)["\']\s*\)', line)
+            if src_match:
+                imports.append(f"source({src_match.group(1)})")
+            
+            # Match :: namespace calls (just collect unique packages)
+            ns_matches = re.findall(r'([a-zA-Z_][a-zA-Z0-9_.]*)::', line)
+            for ns in ns_matches:
+                ns_import = f"{ns}::"
+                if ns_import not in imports:
+                    imports.append(ns_import)
+        
+        return imports
+
+
+# Example usage:
+if __name__ == "__main__":
+    # Example R file analysis
+    handler = RFileHandler("example.R")
+    
+    # Get functions and classes
+    functions_and_classes = handler.get_functions_and_classes()
+    print("Functions and Classes:")
+    for item in functions_and_classes:
+        name, parent, start, end, doc, params = item
+        print(f"  {name}: lines {start}-{end}, params: {params}")
+        if doc:
+            print(f"    Doc: {doc[:50]}...")
+    
+    # Get imports
+    imports = handler.get_imports()
+    print(f"\nImports: {imports}")

bioguider/utils/utils.py

@@ -2,6 +2,7 @@ import logging
 import re
 import subprocess
 from typing import Optional
+from pydantic import BaseModel
 import tiktoken
 
 from bioguider.utils.constants import DEFAULT_TOKEN_USAGE
@@ -68,4 +69,36 @@ def increase_token_usage(
 
     return token_usage
 
-    
+def clean_action_input(action_input: str) -> str:
+    replaced_input = ""
+
+    while (True):
+        replaced_input = action_input.strip()
+        replaced_input = replaced_input.strip("`")
+        replaced_input = replaced_input.strip('"')
+        replaced_input = replaced_input.strip()
+        replaced_input = replaced_input.strip("`")
+        replaced_input = replaced_input.strip('"')
+        replaced_input = replaced_input.strip()
+        if (replaced_input == action_input):
+            break
+        action_input = replaced_input
+    
+    action_input = action_input.replace("'", '"')
+    action_input = action_input.replace("`", '"')
+    return action_input
+
+# Convert BaseModel objects to dictionaries for JSON serialization
+def convert_to_serializable(obj):
+    if isinstance(obj, BaseModel):
+        return obj.model_dump()
+    elif hasattr(obj, 'model_dump'):
+        return obj.model_dump()
+    elif isinstance(obj, dict):
+        return {k: convert_to_serializable(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_to_serializable(item) for item in obj]
+    elif isinstance(obj, tuple):
+        return [convert_to_serializable(item) for item in obj]
+    else:
+        return obj

{bioguider-0.2.20.dist-info → bioguider-0.2.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bioguider
-Version: 0.2.20
+Version: 0.2.21
 Summary: An AI-Powered package to help biomedical developers to generate clear documentation
 License: MIT
 Author: Cankun Wang

{bioguider-0.2.20.dist-info → bioguider-0.2.21.dist-info}/RECORD

@@ -2,21 +2,21 @@ bioguider/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bioguider/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bioguider/agents/agent_task.py,sha256=TL0Zx8zOmiAVslmNbfMPQ38qTQ73QospY6Dwrwf8POg,2890
 bioguider/agents/agent_tools.py,sha256=r21wHV6a-Ic2T0dk4YzA-_d7PodHPM3GzRxJqv-llSw,7286
-bioguider/agents/agent_utils.py,sha256=SoYFc5oZGY2QqTDHR1DCgBPiwQpigUOANHmlUCUPzu4,14683
+bioguider/agents/agent_utils.py,sha256=Mj6yr_2y4veWokXrXlAsaP38Ez9sdnZruM8ZnnpjxQ4,14825
 bioguider/agents/collection_execute_step.py,sha256=jE_oSQZI5WDaz0bJjUWoAfqWfVbGUqN--cvITSWCGiI,5614
-bioguider/agents/collection_observe_step.py,sha256=n863HrbVANQVeltffjS2zXv-AfVErC8ZEMfb_78hafk,5140
+bioguider/agents/collection_observe_step.py,sha256=1xOw6N3uIoyh4h4_vcULAc5x5KZ9G-zZo42AhRidyn8,5373
 bioguider/agents/collection_plan_step.py,sha256=Nn0f8AOkEDCDtnhaqE7yCQoi7PVpsHmiUcsIqC0T0dQ,5956
 bioguider/agents/collection_task.py,sha256=MjpTYiQQYUpmQf2UOn-dOCZU3kxypc4uOnzd15wb1Ow,7882
-bioguider/agents/collection_task_utils.py,sha256=_e2EebYhl-UYjZ0rHNf2-p32YlstBSffv32suiuT9LI,5386
+bioguider/agents/collection_task_utils.py,sha256=mCmjHFD4HY1mSwkfqPaJbZ8sm6ijjdhnNKj40xudE98,5424
 bioguider/agents/common_agent.py,sha256=TpfxbYskwuwWrjs1g9RaG7sdA5rOLdiVac7If7uK2sg,4558
 bioguider/agents/common_agent_2step.py,sha256=rGiDzUkmmUIFnmJJxzXK5M5BfIyINHXLZ0pmPRUVqQg,7911
 bioguider/agents/common_conversation.py,sha256=_9l6SunRmOZ_3R4Q8CTO9oE_qmP7aYYKFX1EiFBIrm8,2589
 bioguider/agents/common_step.py,sha256=GdOCbmj1pwh4etg-futVFYVDQuoUG89DnIrw-B6QbzM,2594
-bioguider/agents/consistency_collection_execute_step.py,sha256=SBZjdaIc4AX6ljedd8TsJC-1GoYeI16jaqIcfDnTezs,4938
-bioguider/agents/consistency_collection_observe_step.py,sha256=XghjlSMBpq1Va68jRP8_-ZG0O7UlZy1Qhwai9c0LNoo,5029
-bioguider/agents/consistency_collection_plan_step.py,sha256=NUl0Nl39O5EFibJQQB1oMIVY_Tikh75YNVbyt7ryw6s,5389
-bioguider/agents/consistency_collection_task.py,sha256=WP3GL4iPJ38b5F1zZMHmJALx0pRDcF-9JAmz3OHqi6o,5261
-bioguider/agents/consistency_collection_task_utils.py,sha256=BnpBXmpxmmr8NRaBw5sACipP0mMtj1Qpe2AvcMlX_cg,6143
+bioguider/agents/consistency_collection_step.py,sha256=eZg0aso0hEVioO_c9yk0bDFOPzGXCUoY82YSasqSSmg,3487
+bioguider/agents/consistency_evaluation_task.py,sha256=l4RfC2LwKfSoTQ1V6V2IeJVIy_WaU0k1kXssUpzVwto,1913
+bioguider/agents/consistency_evaluation_task_utils.py,sha256=zWeYKMAQ3rojVvfvKadjq_1icikF_y9TApP5JnTvHls,443
+bioguider/agents/consistency_observe_step.py,sha256=g3m8RZJkDGlczHS6dl19c8zDx6P1NZh1WqRC_NBD7GE,4502
+bioguider/agents/consistency_query_step.py,sha256=uYE_V_e74kqoDSxmIkMpZpBjoZRKRsJPmiqs1xHhRF8,3674
 bioguider/agents/dockergeneration_execute_step.py,sha256=F92jDlkc6KjAvTkX7q1FsCYP8J15SCaNgmwh3YPqfDo,6500
 bioguider/agents/dockergeneration_observe_step.py,sha256=Bo5Td0fzMYLbLki0FvwamzqRFOy4eu3AvIUa8oFApE4,6131
 bioguider/agents/dockergeneration_plan_step.py,sha256=SB8tQM9PkIKsD2o1DFD7bedcxz6r6hSy8n_EVK60Fz0,7235
@@ -27,14 +27,14 @@ bioguider/agents/evaluation_readme_task.py,sha256=pi3oAGJgZhJgJG1xLgiobrk3Uy2a_J
 bioguider/agents/evaluation_submission_requirements_task.py,sha256=J_6C-M2AfYue2C-gWBHl7KqGrTBuFBn9zmMV5vSRk-U,7834
 bioguider/agents/evaluation_task.py,sha256=c3kvc3xgzGbT0C2KpkE-zHBvaxx9zKdmpLzeKHddrds,12690
 bioguider/agents/evaluation_userguide_prompts.py,sha256=eyJUx5nUr8v9k0B5GpKDaX2dBxSLVZGA0fwOWS4Uiow,7154
-bioguider/agents/evaluation_userguide_task.py,sha256=AJ7y5WSMs4EqXpQzyAu_5NPmWK0jl3AeHhRXxdZgpz0,8266
+bioguider/agents/evaluation_userguide_task.py,sha256=5Z2abE_yiy1SvZ-KECLBk2N4nyRGVR4OV1uOhCfO3qU,6382
 bioguider/agents/identification_execute_step.py,sha256=w3IjL8f2WiHCyiLjVSoySnIAXpi1-hK1DLKCnXbAN2Y,5587
 bioguider/agents/identification_observe_step.py,sha256=Me5mhEM4e7FGnVFcluNtqfhIxzng6guGIu39xi1TrS8,4341
 bioguider/agents/identification_plan_step.py,sha256=owsTK1NZIuiZL7QPVknJyp9TBRK-mhnuf2RwK4YzaxU,5442
 bioguider/agents/identification_task.py,sha256=bTbovxxQVpO1TcdcQAxDxwPISuAcXndO7zsvHpJSb64,10147
 bioguider/agents/identification_task_utils.py,sha256=Lf0Rj0L0KSiyJmPAgeSz0vLUFQr6TSFuzgufimEN4H0,630
 bioguider/agents/peo_common_step.py,sha256=iw2c1h7X11WJzSE2tSRg0UAoXH0QOlQDxW9CCzSVMOY,2677
-bioguider/agents/prompt_utils.py,sha256=kTeK0LOsxpEIpQ5PMXY0DOHXJ5Z6ryu0UuJIO4ga9Rg,17743
+bioguider/agents/prompt_utils.py,sha256=eDi3UY52aTfjQ-337tvXHe8wyUOLq7bs2B7mYp9FDkw,18383
 bioguider/agents/python_ast_repl_tool.py,sha256=o7-4P1h8jS8ikhGSA4CI_OWQ2a0Eg5tEdmuAp_qrO-0,2519
 bioguider/agents/rag_collection_task.py,sha256=r_jPAMjQcC7dIydKxX77UuMqjJ3MiVKswNZ-yNw7yx8,5199
 bioguider/conversation.py,sha256=DIvk_d7pz_guuORByK1eaaF09FAK-8shcNTrbSUHz9Y,1779
@@ -53,7 +53,7 @@ bioguider/generation/report_loader.py,sha256=KtJ6JHGPDL-PQoucU8hkVzMSz-B0bHbF2WS
 bioguider/generation/style_analyzer.py,sha256=Vn9FAK1qJBNLolLC1tz362k4UBaPl107BlvkQc8pV2I,983
 bioguider/generation/suggestion_extractor.py,sha256=tfkyWtdbAo-maLCF_wqwBXyh93yjulvDY17FuvTnTjk,7611
 bioguider/generation/test_metrics.py,sha256=fG6H1jVikHEx1YvN5Ds4QbVinudJ5OEYkzrV760oLLQ,3766
-bioguider/managers/evaluation_manager.py,sha256=obsesQdEgxBzTd1Re00kanH1d5_4_vxzXI_ndICgedg,5834
+bioguider/managers/evaluation_manager.py,sha256=xzCjbbYLLOZNjvqXh9JtPIKtIfpyHcHfczcSGe3t30A,5852
 bioguider/managers/generation_manager.py,sha256=EbAJSvUz-SIriVlozuJ6wa5_1aIbbFfpgg3c9Vcz34g,7615
 bioguider/managers/generation_test_manager.py,sha256=0ty8IibdfN90Oj6M6lkYbxASnQxHYb9I3w9eG7hvEsQ,3270
 bioguider/rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -62,15 +62,16 @@ bioguider/rag/data_pipeline.py,sha256=bkJ2IUCgPx_OL2uZtPd6cIBor2VFZEIfGd5kVlmiPj
 bioguider/rag/embedder.py,sha256=jofR8hOj3Aj2IyBQ9y6FeAc84tgq5agbIfCGyFxYpJ8,650
 bioguider/rag/rag.py,sha256=JFPwrJlKDSyd3U3Gce_NSxI5343eNUbqPG9Fs5Pfoq0,4696
 bioguider/settings.py,sha256=BD_iz9aYarxmWUl0XaKl4-D4oTXMhFzljsXLNn2phis,3143
-bioguider/utils/code_structure_builder.py,sha256=TBrsmlUPEwqpi5bSVLrOEwFK1dQ49goYJ1EGYmRrtZ8,1607
-bioguider/utils/constants.py,sha256=Yzo9oFG4P4C83vKl22RsWkIDa4dcitvcCIceusNPIRQ,8928
+bioguider/utils/code_structure_builder.py,sha256=vrTGYu-IpMTKlmioFRz3xVo-vUszQeIaCQ-_R6Cn9HU,1849
+bioguider/utils/constants.py,sha256=NGmqEgxNDL1fe-htJbtHGcU94EVUK28YAupxGYOJO_c,9012
 bioguider/utils/default.gitignore,sha256=XjPdyO2KV8z8iyuqluaNR_70tBQftMpyKL8HboVNyeI,1605
-bioguider/utils/file_handler.py,sha256=xTrJBQ7VY5baIJPpX7YJP0oniPO3y9ltzayqUOQXJ5g,2644
 bioguider/utils/file_utils.py,sha256=9VfAHsz1UkFPtzAmvWZvPl1TMaKIYNjNlLgsfB8tNjg,3683
 bioguider/utils/gitignore_checker.py,sha256=pOYUwsS9D5014LxcZb0cj3s2CAYaD2uF_pYJpaNKcho,6532
 bioguider/utils/pyphen_utils.py,sha256=cdZc3qphkvMDeL5NiZ8Xou13M_uVNP7ifJ-FwxO-0BE,2680
-bioguider/utils/utils.py,sha256=aWtgdvB04gEiJTfQNK4aQPO1mxv2zRZTbDaGUBy9DFc,2275
-bioguider-0.2.20.dist-info/LICENSE,sha256=qzkvZcKwwA5DuSuhXMOm2LcO6BdEr4V7jwFZVL2-jL4,1065
-bioguider-0.2.20.dist-info/METADATA,sha256=jAGUMMHuLYW5_lyvc0tYcvKGYlB9YUG1hqT3Kjaqii0,1868
-bioguider-0.2.20.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-bioguider-0.2.20.dist-info/RECORD,,
+bioguider/utils/python_file_handler.py,sha256=BERiE2RHxpu3gAzv26jr8ZQetkrtnMZOv9SjpQ7WIdg,2650
+bioguider/utils/r_file_handler.py,sha256=7pUJ0tnKMFDVLLqE3T34YF3vsxN7uT7kBEQnN932aiY,14126
+bioguider/utils/utils.py,sha256=1N7Wv_i9spTBQ_FbZnlxsjC8mszbBzaegrmvuKGUISg,3531
+bioguider-0.2.21.dist-info/LICENSE,sha256=qzkvZcKwwA5DuSuhXMOm2LcO6BdEr4V7jwFZVL2-jL4,1065
+bioguider-0.2.21.dist-info/METADATA,sha256=cZk86BBC_rcGPz_a-Qs8liD9Iun__D9pP5UOONzzAtI,1868
+bioguider-0.2.21.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+bioguider-0.2.21.dist-info/RECORD,,

bioguider/agents/consistency_collection_execute_step.py

@@ -1,152 +0,0 @@
-import logging
-
-from langchain_openai.chat_models.base import BaseChatOpenAI
-from langchain.tools import BaseTool, StructuredTool
-from langchain.agents import AgentExecutor, create_react_agent
-from langchain_community.callbacks.openai_info import OpenAICallbackHandler
-
-from bioguider.agents.consistency_collection_task_utils import ConsistencyCollectionWorkflowState
-from bioguider.agents.consistency_collection_task_utils import ConsistencyCollectionWorkflowState
-from bioguider.database.code_structure_db import CodeStructureDb
-from bioguider.utils.constants import DEFAULT_TOKEN_USAGE
-from bioguider.agents.agent_utils import CustomOutputParser, CustomPromptTemplate
-from bioguider.agents.peo_common_step import ( 
-    PEOCommonStep,
-)
-
-logger = logging.getLogger(__name__)
-
-CONSISTENCY_EVAL_EXECUTION_SYSTEM_PROMPT = """You are an expert developer specializing in the biomedical domain.
-
-You are given a **plan** and are expected to complete it using the available tools.
-
----
-
-### **Available Tools**
-{tools}
-
----
-
-### **Your Task**
-
-Your job is to **execute the given plan step by step**, using the tools available to you.
-
----
-
-### **Output Format (Strict Order Required)**
-
-For **each step**, follow the **exact format** below and **do not change the order of the fields** under any circumstances:
-
-```
-Thought: Describe what you are thinking or planning to do next.  
-Action: The tool you are going to use (must be one of: {tool_names})  
-Action Input: The input provided to the selected action  
-Observation: The result returned by the action
-```
-
----
-
-### **Important Instructions**
-1. You may repeat the **Thought → Action → Action Input → Observation** loop as needed.  
-2. Once all steps in the plan have been executed, output all the results using this format:
-3. For each step, **only execute one tool**.
-
-```
-Thought: I have completed the plan.
-Final Answer:
-Action: <tool_name>
-Action Input: <input>
-Action Observation: <Observation1>
----
-Action: <tool_name>
-Action Input: <input>
-Action Observation: <Observation2>
----
-...
-```
-
----
-
-### **Plan**
-{plan_actions}
-
-### **Actions Already Taken**
-{agent_scratchpad}
-
----
-
-{input}
-"""
-
-class ConsistencyCollectionExecuteStep(PEOCommonStep):
-    def __init__(
-        self, 
-        llm: BaseChatOpenAI, 
-        code_structure_db: CodeStructureDb,
-        custom_tools: list[BaseTool] | None = None,
-    ):
-        self.llm = llm
-        self.code_structure_db = code_structure_db
-        self.step_name = "Consistency Collection Execute Step"
-        self.custom_tools = custom_tools if custom_tools is not None else []
-
-    def _execute_directly(self, state: ConsistencyCollectionWorkflowState):
-        plan_actions = state["plan_actions"]
-        prompt = CustomPromptTemplate(
-            template=CONSISTENCY_EVAL_EXECUTION_SYSTEM_PROMPT,
-            tools=self.custom_tools,
-            plan_actions=plan_actions,
-            input_variables=[
-                "tools", "tool_names", "agent_scratchpad",
-                "intermediate_steps", "plan_actions",
-            ],
-        )
-        output_parser = CustomOutputParser()
-        agent = create_react_agent(
-            llm=self.llm,
-            tools=self.custom_tools,
-            prompt=prompt,
-            output_parser=output_parser,
-            stop_sequence=["\nObservation:"],
-        )
-        callback_handler = OpenAICallbackHandler()
-        agent_executor = AgentExecutor(
-            agent=agent,
-            tools=self.custom_tools,
-            max_iterations=30,
-        )
-        response = agent_executor.invoke(
-            input={
-                "plan_actions": plan_actions,
-                "input": "Now, let's begin."
-            },
-            config={
-                "callbacks": [callback_handler],
-                "recursion_limit": 20,
-            },
-        )
-        if "output" in response:
-            output = response["output"]
-            self._print_step(state, step_output=f"**Execute Output:** \n{output}")
-            if "**Final Answer**" in output:
-                final_answer = output.split("**Final Answer:**")[-1].strip().strip(":")
-                step_output = final_answer
-            elif "Final Answer" in output:
-                final_answer = output.split("Final Answer")[-1].strip().strip(":")
-                step_output = final_answer
-            else:
-                step_output = output
-            self._print_step(state, step_output=step_output)
-            state["step_output"] = step_output
-        else:
-            logger.error("No output found in the response.")
-            self._print_step(
-                state,
-                step_output="Error: No output found in the response.",
-            )
-            state["step_output"] = "Error: No output found in the response."
-        
-        token_usage = vars(callback_handler)
-        token_usage = {**DEFAULT_TOKEN_USAGE, **token_usage}
-            
-        return state, token_usage