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

bioguider/agents/consistency_collection_observe_step.py

@@ -1,128 +0,0 @@
-from typing import Callable
-
-from langchain_openai.chat_models.base import BaseChatOpenAI
-from langchain_core.prompts import ChatPromptTemplate
-from bioguider.agents.agent_utils import ObservationResult
-from bioguider.agents.common_agent_2step import CommonAgentTwoSteps
-from bioguider.agents.consistency_collection_task_utils import ConsistencyCollectionWorkflowState
-from bioguider.agents.peo_common_step import PEOCommonStep
-
-CONSISTENCY_EVAL_OBSERVE_SYSTEM_PROMPT = """You are an expert developer specializing in the biomedical domain.
-
-### **Goal**
-Your task is to collect the function, class, and method definitions and docstrings for a given user guide/API documentation.
-
----
-
-### **Intermediate Steps**  
-Here are the results from previous steps:  
-{intermediate_steps}
-
----
-
-### **Instructions**
-1. Your goal is if you have enough information to evaluate the consistency of the user guide/API documentation.
-2. Carefully review the **Goal**, **User Guide/API Documentation**, and **Intermediate Output**.
-3. If you believe you have enough information to evaluate the consistency of the user guide/API documentation:
-
-* Proceed with the following format:
-
-  * Provide your reasoning under **Analysis**
-  * Then give your final answer under **FinalAnswer**
-  * **FinalAnswer** format must exactly match this format:
-    **FinalAnswer**: {{"final_answer": "yes" or "no"}}
-  * Your answer **must exactly match the follwing format** (note: no JSON code block, no additional comments), **do not** make up anything:
-
-  ```
-  **Analysis**: your analysis here 
-  **FinalAnswer**: {{"final_answer": "yes" or "no"}}
-  ```
-4. If you believe you do not have enough information to evaluate the consistency of the user guide/API documentation:
-
-* Provide your reasoning under **Thoughts**:
-
-  ```
-  **Thoughts**: your thoughts here
-  ```
-
-Be precise and support your reasoning with evidence from the input.
-
----
-
-### **Notes**
-We are collecting information over multiple rounds, your thoughts and the output of this step will be persisted, so please **do not rush to provide a Final Answer**.  
-If you find the current information insufficient, share your reasoning or thoughts instead—we’ll continue with the next round accordingly.
-
----
-
-### **Input User Guide/API Documentation**
-{user_guide_api_documentation}
-
----
-
-"""
-
-
-class ConsistencyCollectionObserveStep(PEOCommonStep):
-    def __init__(
-        self,
-        llm: BaseChatOpenAI,
-    ):
-        super().__init__(llm=llm)
-        self.step_name = "Consistency Collection Observe Step"
-
-    def _build_prompt(self, state):
-        user_guide_api_documentation = state["user_guide_api_documentation"]
-        intermediate_steps = self._build_intermediate_steps(state)
-        prompt = ChatPromptTemplate.from_template(CONSISTENCY_EVAL_OBSERVE_SYSTEM_PROMPT)
-        return prompt.format(
-            user_guide_api_documentation=user_guide_api_documentation,
-            intermediate_steps=intermediate_steps,
-        )
-
-    def _collect_final_answer(self, state: ConsistencyCollectionWorkflowState):
-        if not ("final_answer" in state and state["final_answer"] is not None and
-            state["final_answer"].strip().lower() == "yes"):
-            return None
-        
-        final_result = ""
-        if "intermediate_steps" in state and state["intermediate_steps"] is not None:
-            for i in range(len(state["intermediate_steps"])):
-                final_result += state["intermediate_steps"][i]
-                final_result += "\n\n"
-        if "step_output" in state and state["step_output"] is not None:
-            final_result += state["step_output"]
-            final_result += "\n\n"
-        
-        return final_result
-
-            
-    def _execute_directly(self, state: ConsistencyCollectionWorkflowState):
-        system_prompt = self._build_prompt(state)
-        agent = CommonAgentTwoSteps(llm=self.llm)
-        res, _, token_usage, reasoning_process = agent.go(
-            system_prompt=system_prompt,
-            instruction_prompt="Now, let's begin the consistency collection observe step.",
-            schema=ObservationResult,
-        )
-        state["final_answer"] = res.FinalAnswer
-        analysis = res.Analysis
-        thoughts = res.Thoughts
-        state["step_analysis"] = analysis
-        state["step_thoughts"] = thoughts
-        state["step_count"] += 1
-        state["final_assembly_result"] = self._collect_final_answer(state)
-        self._print_step(
-            state,
-            step_output=f"**Observation Reasoning Process {state['step_count']}**\n{reasoning_process}"
-        )
-        self._print_step(
-            state,
-            step_output=f"Final Answer: {res.FinalAnswer if res.FinalAnswer else None}\nAnalysis: {analysis}\nThoughts: {thoughts}",
-        )
-        if state["final_assembly_result"] is not None:
-            self._print_step(
-                state,
-                step_output=f"Final Assembly Result: {state['final_assembly_result']}",
-            )
-        return state, token_usage

bioguider/agents/consistency_collection_plan_step.py

@@ -1,128 +0,0 @@
-from langchain_openai.chat_models.base import BaseChatOpenAI
-
-from langchain.tools import BaseTool
-from langchain_core.prompts import ChatPromptTemplate, StringPromptTemplate
-from bioguider.agents.agent_utils import (
-    convert_plan_to_string, 
-    get_tool_names_and_descriptions,
-    PlanAgentResultJsonSchema,
-    PlanAgentResult,
-)
-from bioguider.agents.common_agent_2step import CommonAgentTwoChainSteps, CommonAgentTwoSteps
-from bioguider.agents.consistency_collection_task_utils import ConsistencyCollectionWorkflowState
-from bioguider.agents.peo_common_step import PEOCommonStep
-
-CONSISTANCE_EVAL_PLAN_SYSTEM_PROMPT = ChatPromptTemplate.from_template("""### **Goal**  
-You are an expert developer specializing in the biomedical domain. 
-Your task is to collect the function, class, and method definitions and docstrings for a given user guide/API documentation.
-
----
-
-### **Function Tools**  
-You have access to the following function tools:  
-{tools}
-
----
-
-### **Intermediate Steps**  
-Here are the results from previous steps:  
-{intermediate_steps}
-
----
-
-### **Intermediate Thoughts**  
-- **Analysis**: {intermediate_analysis}  
-- **Thoughts**: {intermediate_thoughts}
-
----
-
-### **Instructions**
-1. We will iterate through multiple **Plan -> Execution -> Observation** loops as needed.  
-   - All variables and tool outputs are **persisted across rounds**, so you can build on prior results.  
-   - Develop your plan **incrementally**, and reflect on intermediate observations before proceeding.  
-   - Limit each step to **one or two actions** — avoid trying to complete everything in a single step.
-
-2. Your task is to evaluate the consistency of the user guide/API documentation.
-
-3. You may use 
-   - the `retrieve_function_definition_and_docstring` tool to get the function definition and docstring or,
-   - the `retrieve_class_definition_and_docstring` to get the class definition and docstring or,
-   - the `retrieve_class_and_method_definition_and_docstring` to get the class and method definition and docstring.
-
-4. Your plan can only use the above tools, **do not** make up any tools not in the above tools list.
-
-5. If no function, class, or method is found in the given user guide/API documentation, you should return "N/A" as an empty plan.
-   Our tools can only retrieve the **function**, **class**, **method** definition and docstring, **do not** make up any function, class, or method name.
-    
-    
-### **Input User Guide/API Documentation**
-{user_guide_api_documentation}
-
-### **Output Format**
-Your plan **must exactly match** a sequence of steps in the following format, **do not** make up anything:
-
-Step: <tool name>   # Tool name **must be one** of {tool_names}  
-Step Input: <function/class/method name>
-Step Input: <file path, if not sure, just put "N/A">
-
-Step: <tool name>  # Tool name **must be one** of {tool_names}  
-Step Input: <function/class/method name>
-Step Input: <file path, if not sure, just put "N/A">
-...
-
-...
-""")
-
-class ConsistencyCollectionPlanStep(PEOCommonStep):
-    """
-    ConsistencyCollectionPlanStep is a step in the consistency collection plan process.
-    It is responsible for initializing the tools and compiling the step.
-    """
-    
-    def __init__(
-        self, 
-        llm: BaseChatOpenAI,
-        custom_tools: list[BaseTool] | None = None,
-    ):
-        super().__init__(llm)
-        self.step_name = "Consistency Collection Plan Step"
-        self.custom_tools = custom_tools if custom_tools is not None else []
-    
-    def _prepare_system_prompt(self, state: ConsistencyCollectionWorkflowState) -> str:
-        user_guide_api_documentation = state["user_guide_api_documentation"]
-        intermediate_steps = self._build_intermediate_steps(state)
-        step_analysis, step_thoughts = self._build_intermediate_analysis_and_thoughts(state)
-        tool_names, tools_desc = get_tool_names_and_descriptions(self.custom_tools)
-        system_prompt = CONSISTANCE_EVAL_PLAN_SYSTEM_PROMPT.format(
-            tools=tools_desc,
-            intermediate_steps=intermediate_steps,
-            intermediate_analysis=step_analysis,
-            intermediate_thoughts=step_thoughts,
-            tool_names=tool_names,
-            user_guide_api_documentation=user_guide_api_documentation,
-        )
-        self._print_step(
-            state,
-            step_output="**Intermediate Step Output**\n" + intermediate_steps
-        )
-        self._print_step(
-            state,
-            step_output="**Intermediate Step Analysis**\n{step_analysis}\n**Intermediate Step Thoughts**\n{step_thoughts}",
-        )
-        return system_prompt
-
-    def _execute_directly(self, state: ConsistencyCollectionWorkflowState):
-        system_prompt = self._prepare_system_prompt(state)
-        agent = CommonAgentTwoSteps(llm=self.llm)
-        res, _, token_usage, reasoning_process = agent.go(
-            system_prompt=system_prompt,
-            instruction_prompt="Now, let's begin the consistency collection plan step.",
-            schema=PlanAgentResultJsonSchema,
-        )
-        PEOCommonStep._reset_step_state(state)
-        res = PlanAgentResult(**res)
-        self._print_step(state, step_output=f"**Reasoning Process**\n{reasoning_process}")
-        self._print_step(state, step_output=f"**Plan**\n{str(res.actions)}")
-        state["plan_actions"] = convert_plan_to_string(res)
-
-        return state, token_usage

bioguider/agents/consistency_collection_task.py

@@ -1,109 +0,0 @@
-import os
-from typing import Callable, Optional, TypedDict
-from langchain.prompts import ChatPromptTemplate
-from langchain_openai.chat_models.base import BaseChatOpenAI
-from langchain_core.messages import AIMessage
-from langchain.tools import StructuredTool
-from pydantic import BaseModel, Field
-import logging
-from langgraph.graph import StateGraph, START, END
-
-from bioguider.agents.agent_task import AgentTask
-from bioguider.agents.agent_tools import agent_tool
-from bioguider.agents.agent_utils import read_file, summarize_file
-from bioguider.agents.peo_common_step import PEOWorkflowState
-from bioguider.agents.common_agent import CommonAgent
-from bioguider.agents.common_agent_2step import CommonAgentTwoSteps
-from bioguider.agents.consistency_collection_task_utils import (
-    ConsistencyCollectionWorkflowState,
-    retrieve_function_definition_and_docstring_tool,
-    retrieve_class_definition_and_docstring_tool,
-    retrieve_class_and_method_definition_and_docstring_tool,
-    retrieve_method_definition_and_docstring_tool,
-)
-from bioguider.agents.consistency_collection_plan_step import ConsistencyCollectionPlanStep
-from bioguider.agents.consistency_collection_observe_step import ConsistencyCollectionObserveStep
-from bioguider.agents.consistency_collection_execute_step import ConsistencyCollectionExecuteStep
-from bioguider.database.code_structure_db import CodeStructureDb
-
-logger = logging.getLogger(__name__)
-
-class ConsistencyCollectionTask(AgentTask):
-    def __init__(
-        self, 
-        llm: BaseChatOpenAI,
-        code_structure_db: CodeStructureDb,
-        step_callback: Callable | None = None,
-    ):
-        super().__init__(llm=llm, step_callback=step_callback)
-        self.llm = llm
-        self.code_structure_db = code_structure_db
-        
-        func_tool = retrieve_function_definition_and_docstring_tool(llm=llm, code_structure_db=code_structure_db)
-        class_tool = retrieve_class_definition_and_docstring_tool(llm=llm, code_structure_db=code_structure_db)
-        class_and_method_tool = retrieve_class_and_method_definition_and_docstring_tool(llm=llm, code_structure_db=code_structure_db)
-        method_tool = retrieve_method_definition_and_docstring_tool(llm=llm, code_structure_db=code_structure_db)
-        self.tools = [func_tool, class_tool, class_and_method_tool, method_tool]
-        self.custom_tools = [            
-            StructuredTool.from_function(
-                func_tool.run,
-                description=func_tool.__class__.__doc__,
-                name=func_tool.__class__.__name__,
-            ),            
-            StructuredTool.from_function(
-                class_tool.run,
-                description=class_tool.__class__.__doc__,
-                name=class_tool.__class__.__name__,
-            ),            
-            StructuredTool.from_function(
-                class_and_method_tool.run,
-                description=class_and_method_tool.__class__.__doc__,
-                name=class_and_method_tool.__class__.__name__,
-            ),
-            StructuredTool.from_function(
-                method_tool.run,
-                description=method_tool.__class__.__doc__,
-                name=method_tool.__class__.__name__,
-            ),
-        ]
-
-        self.steps = [
-            ConsistencyCollectionPlanStep(llm=llm, custom_tools=self.custom_tools), 
-            ConsistencyCollectionExecuteStep(llm=llm, code_structure_db=code_structure_db, custom_tools=self.custom_tools),
-            ConsistencyCollectionObserveStep(llm=llm)
-        ]
-
-    def _compile(self, repo_path: str, gitignore_path: str):
-        def check_observe_step(state: ConsistencyCollectionWorkflowState):
-            if "final_answer" in state and state["final_answer"] is not None:
-                return END
-            return "plan_step"
-        def check_plan_step(state: ConsistencyCollectionWorkflowState):
-            if "plan_actions" in state and state["plan_actions"] is not None and len(state["plan_actions"]) > 0:
-                return "execute_step"
-            return END
-        
-        graph = StateGraph(ConsistencyCollectionWorkflowState)
-        graph.add_node("plan_step", self.steps[0].execute)
-        graph.add_node("execute_step", self.steps[1].execute)
-        graph.add_node("observe_step", self.steps[2].execute)
-        graph.add_edge(START, "plan_step")
-        graph.add_conditional_edges("plan_step", check_plan_step, {"execute_step", END})
-        graph.add_edge("execute_step", "observe_step")
-        graph.add_conditional_edges("observe_step", check_observe_step, {"plan_step", END})
-
-        self.graph = graph.compile()
-
-    def collect(self, user_guide_api_documentation: str) -> tuple[bool, str | None]:
-        s = self._go_graph({
-            "user_guide_api_documentation": user_guide_api_documentation,
-            "step_count": 0,
-        })
-        # analyze the final assembly result
-        if "final_assembly_result" in s and s["final_assembly_result"] is not None:
-            self._print_step(step_name="Final Assembly Result")
-            self._print_step(step_output=s["final_assembly_result"])
-            return True, s["final_assembly_result"]
-        else:
-            return False, s["thoughts"] if "thoughts" in s else None
-        

bioguider/agents/consistency_collection_task_utils.py

@@ -1,137 +0,0 @@
-import os
-from pathlib import Path
-from typing import Callable, Optional, TypedDict
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_openai.chat_models.base import BaseChatOpenAI
-from langchain_core.messages import AIMessage
-from pydantic import BaseModel, Field
-import logging
-
-from bioguider.agents.agent_tools import agent_tool
-from bioguider.database.code_structure_db import CodeStructureDb
-
-logger = logging.getLogger(__name__)
-
-class ConsistencyCollectionWorkflowState(TypedDict):
-    user_guide_api_documentation: str
-    step_output_callback: Optional[Callable]
-    intermediate_steps: Optional[str]
-    step_output: Optional[str]
-    step_analysis: Optional[str]
-    step_thoughts: Optional[str]
-    plan_actions: Optional[list[dict]]
-
-    final_answer: Optional[str]
-    final_assembly_result: Optional[str]
-    step_count: Optional[int]
-
-class retrieve_method_definition_and_docstring_tool:
-    """ Retrieve the method definition and docstring.
-    If the method is a method of a class, you **must** put the class name as the parent name and better to put the file path as the file path of the class.
-Args:
-    method_name str: the name of the method
-    class_name str: the name of the class that the method is in.
-    file_path str: the path of the file that the method is in. If not sure, just put "N/A"
-Returns:
-    str: the method definition and docstring
-    """
-    def __init__(self, llm: BaseChatOpenAI, code_structure_db: CodeStructureDb):
-        self.llm = llm
-        self.code_structure_db = code_structure_db
-
-    def run(self, method_name: str, class_name: str, file_path: str) -> str:
-        if file_path != "N/A":
-            row = self.code_structure_db.select_by_name_and_parent_and_path(method_name, class_name, file_path)
-            if row is None:
-                return "Can't retrieve method definition and docstring"
-            return f"Method: {row['name']}\nDocstring: {row['doc_string']}\nParams: {row['params']}"
-        else:
-            rows = self.code_structure_db.select_by_name_and_parent(method_name, class_name)
-            if rows is None or len(rows) == 0:
-                return "Can't retrieve method definition and docstring"
-            return f"Method: {rows[0]['name']}\nDocstring: {rows[0]['doc_string']}\nParams: {rows[0]['params']}"
-
-class retrieve_function_definition_and_docstring_tool:
-    """ Retrieve the function definition and docstring
-Args:
-    function_name str: the name of the function
-    file_path str: the path of the file that the function is in. If not sure, just put "N/A"
-Returns:
-    str: the function definition and docstring
-    """
-    def __init__(
-        self, 
-        llm: BaseChatOpenAI,
-        code_structure_db: CodeStructureDb,
-    ):
-        self.llm = llm
-        self.code_structure_db = code_structure_db
-
-    def run(self, function_name: str, file_path: str) -> str:
-        if file_path != "N/A":
-            row = self.code_structure_db.select_by_name_and_path(function_name, file_path)
-            if row is None:
-                return f"No such function {function_name}"
-            return f"Function: {row['name']}\nDocstring: {row['doc_string']}\nParams: {row['params']}"
-        else:
-            rows = self.code_structure_db.select_by_name(function_name)
-            if rows is None or len(rows) == 0:
-                return f"No such function {function_name}"
-            return f"Function: {rows[0]['name']}\nDocstring: {rows[0]['doc_string']}\nParams: {rows[0]['params']}"
-
-class retrieve_class_definition_and_docstring_tool:
-    """ Retrieve the class definition and docstring
-Args:
-    class_name str: the name of the class
-    file_path str: the path of the file that the class is in. If not sure, just put "N/A"
-Returns:
-    str: the class definition and docstring
-    """
-    def __init__(self, llm: BaseChatOpenAI, code_structure_db: CodeStructureDb):
-        self.llm = llm
-        self.code_structure_db = code_structure_db
-
-    def run(self, class_name: str, file_path: str) -> str:
-        if file_path != "N/A":
-            row = self.code_structure_db.select_by_name_and_path(class_name, file_path)
-            if row is None:
-                return f"No such class {class_name}"
-            return f"Class: {row['name']}\nDocstring: {row['doc_string']}\nParams: {row['params']}"
-        else:
-            rows = self.code_structure_db.select_by_name(class_name)
-            if rows is None or len(rows) == 0:
-                return f"No such class {class_name}"
-            return f"Class: {rows[0]['name']}\nDocstring: {rows[0]['doc_string']}\nParams: {rows[0]['params']}"
-
-class retrieve_class_and_method_definition_and_docstring_tool:
-    """ Retrieve the class and all methods definition and docstring
-Args:
-    class_name str: the name of the class
-    file_path str: the path of the file that the class is in. If not sure, just put "N/A"
-Returns:
-    str: the class and method definition and docstring
-    """
-    def __init__(self, llm: BaseChatOpenAI, code_structure_db: CodeStructureDb):
-        self.llm = llm
-        self.code_structure_db = code_structure_db
-
-    def run(self, class_name: str, file_path: str) -> str:
-        if file_path != "N/A":
-            row = self.code_structure_db.select_by_name_and_path(class_name, file_path)
-            if row is None:
-                return f"No such class {class_name}"
-        else:
-            rows = self.code_structure_db.select_by_name(class_name)
-            if rows is None or len(rows) == 0:
-                return f"No such class {class_name}"
-            row = rows[0]
-        
-        parent_path = file_path if file_path is not None and file_path.lower() != "n/a" else row["path"]
-        methods = self.code_structure_db.select_by_parent(
-            class_name, 
-            parent_path
-        )
-        method_definitions = []
-        for method in methods:
-            method_definitions.append(f"Method: {method['name']}\nDocstring: {method['doc_string']}\nParams: {method['params']}\n\n")
-        return f"Class: {row['name']}\nDocstring: {row['doc_string']}\nParams: {row['params']}\nMethods: {method_definitions}"