bioguider 0.2.15__py3-none-any.whl → 0.2.16__py3-none-any.whl

bioguider/agents/agent_utils.py

@@ -3,7 +3,6 @@ import json
 from json import JSONDecodeError
 import os
 import re
-import subprocess
 from typing import List, Optional, Tuple, Union
 from langchain_openai import AzureChatOpenAI
 from langchain_deepseek import ChatDeepSeek
@@ -25,6 +24,7 @@ from bioguider.utils.constants import DEFAULT_TOKEN_USAGE, MAX_FILE_LENGTH, MAX_
 from bioguider.utils.file_utils import get_file_type
 from ..utils.gitignore_checker import GitignoreChecker
 from ..database.summarized_file_db import SummarizedFilesDb
+from bioguider.agents.common_conversation import CommonConversation
 
 logger = logging.getLogger(__name__)
 
@@ -238,19 +238,6 @@ def summarize_file(
     
     return out, token_usage
 
-def increase_token_usage(
-    token_usage: Optional[dict] = None,
-    incremental: dict = {**DEFAULT_TOKEN_USAGE},
-):
-    if token_usage is None:
-        token_usage = {**DEFAULT_TOKEN_USAGE}
-    token_usage["total_tokens"] += incremental["total_tokens"]
-    token_usage["completion_tokens"] += incremental["completion_tokens"]
-    token_usage["prompt_tokens"] += incremental["prompt_tokens"]
-
-    return token_usage
-
-
   # Set up a prompt template
 class CustomPromptTemplate(StringPromptTemplate):
     # The template to use
@@ -355,30 +342,6 @@ def convert_plan_to_string(plan: PlanAgentResult) -> str:
         plan_str += action_str
     return plan_str
 
-def run_command(command: list, cwd: str = None, timeout: int = None):
-    """
-    Run a shell command with optional timeout and return stdout, stderr, and return code.
-    """
-    try:
-        result = subprocess.run(
-            command,
-            cwd=cwd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=timeout
-        )
-        return result.stdout, result.stderr, result.returncode
-    except subprocess.TimeoutExpired as e:
-        return e.stdout or "", e.stderr or f"Command timed out after {timeout} seconds", -1
-
-def escape_braces(text: str) -> str:
-    # First replace single } not part of }} with }}
-    text = re.sub(r'(?<!})}(?!})', '}}', text)
-    # Then replace single { not part of {{
-    text = re.sub(r'(?<!{){(?!{)', '{{', text)
-    return text
-
 STRING_TO_OBJECT_SYSTEM_PROMPT = """
 You are an expert to understand data. You will be provided a text, and your task is to extracted structured data from the provided text.
 
@@ -426,20 +389,41 @@ def try_parse_with_llm(llm: BaseChatOpenAI, input_text: str, schema: any):
     system_prompt = ChatPromptTemplate.from_template(
         STRING_TO_OBJECT_SYSTEM_PROMPT
     ).format(input_text=input_text)
-    prompt = ChatPromptTemplate.from_messages([
-        ("system", system_prompt)
-    ])
-    agent = prompt | llm.with_structured_output(schema)
-    callback_handler = OpenAICallbackHandler()
+    
+    conversation = CommonConversation(llm=llm)
+    res, token_usage = conversation.generate_with_schema(
+        system_prompt=system_prompt,
+        instruction_prompt="Let's start to parse the input text.",
+        schema=schema,
+    )
+    return res, token_usage
+
+def read_license_file(repo_path: str) -> tuple[str | None, str|None]:
+    # find hardcoded license file
+    hardcoded_license_files = [
+        "LICENSE",
+        "LICENSE.txt",
+        "LICENSE.md",
+        "LICENSE.rst",
+    ]
+    license_files = []
+    for file in hardcoded_license_files:
+        if os.path.exists(os.path.join(repo_path, file)):
+            with open(os.path.join(repo_path, file), "r") as f:
+                license_files.append((f.read(), os.path.join(repo_path, file)))
+    
+    max_item = max(license_files, key=lambda x: len(x[0])) if len(license_files) > 0 else (None, None)
+    if max_item[0] is not None:
+        return max_item[0], max_item[1]
+
+    # find in root directory
+    for root, _, files in os.walk(repo_path):
+        for file in files:
+            if file.lower() == "license":
+                with open(os.path.join(root, file), "r") as f:
+                    return f.read(), os.path.join(root, file)
+            if file[:8].lower() == "license.":
+                with open(os.path.join(root, file), "r") as f:
+                    return f.read(), os.path.join(root, file)
+    return None, None
 
-    try:
-        res = agent.invoke(
-            input={},
-            config={
-                "callbacks": [callback_handler],
-            },
-        )
-        return res, vars(callback_handler)
-    except Exception as e:
-        logger.error(e)
-        return None

bioguider/agents/collection_observe_step.py

@@ -95,7 +95,7 @@ class CollectionObserveStep(PEOCommonStep):
     def _execute_directly(self, state: CollectionWorkflowState):
         step_count = state["step_count"]
         instruction = "Now, we have reached max recursion limit, please give me the **final answer** based on the current information" \
-            if step_count == MAX_STEP_COUNT - 2 else "Let's begin thinking."
+            if step_count == MAX_STEP_COUNT/3 - 2 else "Let's begin thinking."
         system_prompt = self._build_prompt(state)
         agent = CommonAgentTwoSteps(llm=self.llm)
         res, _, token_usage, reasoning_process = agent.go(

bioguider/agents/common_agent.py

@@ -1,3 +1,4 @@
+
 from typing import Any, Callable, Optional
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_openai.chat_models.base import BaseChatOpenAI
@@ -7,10 +8,7 @@ from pydantic import BaseModel, Field
 from tenacity import retry, stop_after_attempt, wait_incrementing
 import logging
 
-from bioguider.agents.agent_utils import (
-    escape_braces,
-    increase_token_usage,
-)
+from bioguider.utils.utils import escape_braces, increase_token_usage
 
 logger = logging.getLogger(__name__)
 
@@ -19,13 +17,11 @@ class RetryException(Exception):
 
     pass
 
-
 class CommonAgentResult(BaseModel):
     reasoning_process: str = Field(
         description="A detailed explanation of the thought process or reasoning steps taken to reach a conclusion."
     )
 
-
 class CommonAgent:
     def __init__(self, llm: BaseChatOpenAI):
         self.llm = llm
@@ -138,22 +134,4 @@ class CommonAgent:
                 logger.error(str(e))
                 raise e
         return res, processed_res, self.token_usage, None
-    
-class CommonConversation:
-    def __init__(self, llm: BaseChatOpenAI):
-        self.llm = llm
-
-    def generate(self, system_prompt: str, instruction_prompt: str):
-        msgs = [
-            SystemMessage(system_prompt),
-            HumanMessage(instruction_prompt),
-        ]
-        msgs_template = ChatPromptTemplate.from_messages(messages=msgs)
-        callback_handler = OpenAICallbackHandler()
-        result = self.llm.generate(
-            messages=[msgs],
-            callbacks=[callback_handler]
-        )
-        response = result.generations[0][0].text
-        token_usage = result.llm_output.get("token_usage")
-        return response, token_usage
+    

bioguider/agents/common_agent_2step.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, Field
 from tenacity import retry, stop_after_attempt, wait_incrementing
 import logging
 
-from bioguider.agents.agent_utils import escape_braces
+from bioguider.utils.utils import escape_braces
 from bioguider.agents.common_agent import (
     CommonAgent,
     RetryException,

bioguider/agents/common_conversation.py

@@ -0,0 +1,43 @@
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai.chat_models.base import BaseChatOpenAI
+from langchain_community.callbacks.openai_info import OpenAICallbackHandler
+from bioguider.utils.utils import escape_braces
+
+class CommonConversation:
+    def __init__(self, llm: BaseChatOpenAI):
+        self.llm = llm
+
+    def generate(self, system_prompt: str, instruction_prompt: str):
+        msgs = [
+            SystemMessage(system_prompt),
+            HumanMessage(instruction_prompt),
+        ]
+        callback_handler = OpenAICallbackHandler()
+        result = self.llm.generate(
+            messages=[msgs],
+            callbacks=[callback_handler]
+        )
+        response = result.generations[0][0].text
+        token_usage = result.llm_output.get("token_usage")
+        return response, token_usage
+    
+    def generate_with_schema(self, system_prompt: str, instruction_prompt: str, schema: any):
+        system_prompt = escape_braces(system_prompt)
+        instruction_prompt = escape_braces(instruction_prompt)
+        msgs = [
+            SystemMessage(system_prompt),
+            HumanMessage(instruction_prompt),
+        ]
+        msgs_template = ChatPromptTemplate.from_messages(messages=msgs)
+        callback_handler = OpenAICallbackHandler()
+        agent = msgs_template | self.llm.with_structured_output(schema)
+        result = agent.invoke(
+            input={},
+            config={
+                "callbacks": [callback_handler],
+            },
+        )
+        token_usage = vars(callback_handler)
+        return result, token_usage
+

bioguider/agents/dockergeneration_observe_step.py

@@ -4,7 +4,8 @@ from langchain.prompts import ChatPromptTemplate
 from pydantic import BaseModel, Field
 
 from bioguider.utils.constants import DEFAULT_TOKEN_USAGE
-from bioguider.agents.agent_utils import run_command, read_file
+from bioguider.agents.agent_utils import read_file
+from bioguider.utils.utils import run_command
 from bioguider.agents.dockergeneration_task_utils import DockerGenerationWorkflowState
 from bioguider.agents.common_agent_2step import CommonAgentTwoChainSteps, CommonAgentTwoSteps
 from bioguider.agents.peo_common_step import PEOCommonStep

bioguider/agents/evaluation_installation_task.py

@@ -1,24 +1,25 @@
 import os
 from pathlib import Path
 import logging
-from typing import Callable, Optional
-from abc import ABC, abstractmethod
 from langchain.prompts import ChatPromptTemplate
-from langchain_openai.chat_models.base import BaseChatOpenAI
-from pydantic import BaseModel, Field
 from markdownify import markdownify as md
 
 from bioguider.agents.agent_utils import read_file
 from bioguider.agents.collection_task import CollectionTask
 from bioguider.agents.prompt_utils import EVALUATION_INSTRUCTION, CollectionGoalItemEnum
-from bioguider.utils.constants import DEFAULT_TOKEN_USAGE, ProjectMetadata
+from bioguider.utils.constants import (
+    DEFAULT_TOKEN_USAGE, 
+    ProjectMetadata,
+    StructuredEvaluationInstallationResult,
+    FreeEvaluationInstallationResult,
+    EvaluationInstallationResult,
+)
 from bioguider.rag.data_pipeline import count_tokens
 from .common_agent_2step import CommonAgentTwoSteps, CommonAgentTwoChainSteps
-from .common_agent import CommonConversation
-from ..utils.pyphen_utils import PyphenReadability
-from ..utils.gitignore_checker import GitignoreChecker
+
 from .evaluation_task import EvaluationTask
-from .agent_utils import increase_token_usage, read_file
+from .agent_utils import read_file
+from bioguider.utils.utils import increase_token_usage
 
 
 logger = logging.getLogger(__name__)
@@ -43,7 +44,10 @@ Your task is to analyze the provided files related to installation and generate
 4. **Compatible Operating System**: Is the compatible operating system described?
    * Output: `Yes` or `No`
 
-5. **Overall Score**: Give an overall quality rating of the Installation information.
+5. **Hardware Requirements**: Is the hardware requirements described?
+   * Output: `Yes` or `No`
+
+6. **Overall Score**: Give an overall quality rating of the Installation information.
    * Output: `Poor`, `Fair`, `Good`, or `Excellent`
 
 ---
@@ -58,6 +62,7 @@ Your final report must **exactly match** the following format. Do not add or omi
   * number: [Number]
   * suggestions: <suggestion to improve **dependency information** like missing dependencies
 **Compatible Operating System:** [Yes / No]
+**Hardware Requirements:** [Yes / No]
 **Overall Score:** [Poor / Fair / Good / Excellent]
 
 ---
@@ -68,43 +73,45 @@ Your final report must **exactly match** the following format. Do not add or omi
 """
 
 
-EVALUATION_INSTALLATION_SYSTEM_PROMPT = """
+FREE_EVALUATION_INSTALLATION_SYSTEM_PROMPT = """
 You are an expert in evaluating the quality of **installation instructions** in software repositories.
 Your task is to analyze the provided content of installation-related files and generate a **comprehensive, structured quality report**.
+You will be given:
+1. The content of installation-related files.
+2. A structured evaluation of the installation-related files and its reasoning process.
 
 ---
 
-### Evaluation Criteria
-
-Please assess the installation information using the following criteria. For each, provide a concise evaluation and specific feedback:
-
-1. **Ease of Access**
-   * Is the installation information clearly presented and easy to locate within the repository?
-   * Is it included in a top-level README, a dedicated INSTALL.md file, or other accessible locations?
+### **Instructions**
+1. Based on the provided structured evaluation and its reasoning process, generate a free evaluation of the installation-related files.
+2. Focus on the explanation of assessment in structured evaluation and how to improve the installation-related files based on the structured evaluation and its reasoning process.
+   * For each suggestion to improve the installation-related files, you **must provide some examples** of the original text snippet and the improving comments.
+3. For each item in the structured evaluation, provide a detailed assessment followed by specific, actionable comments for improvement.
+4. Your improvement suggestions must also include the original text snippet and the improving comments.
+5. Your improvement suggestions must also include suggestions to improve readability.
+6. If you think the it is good enough, you can say so.
 
-2. **Clarity of Dependency Specification**
-   * Are all software and library dependencies clearly listed?
-   * Are installation methods (e.g., `pip`, `conda`, `apt`) for those dependencies explicitly provided?
+---
 
-3. **Hardware Requirements**
-   * Does the documentation specify hardware needs (e.g., GPU, memory, OS) if relevant?
+### **Output Format**
+Your output must **exactly match** the following format. Do not add or omit any sections.
 
-4. **Step-by-Step Installation Guide**
-   * Is there a clear, ordered set of instructions for installing the software?
-   * Are example commands or configuration steps provided to help users follow along?
+**FinalAnswer**
+**Ease of Access:** 
+  <Your assessment and suggestion here>
+**Clarity of Dependency Specification:**
+  <Your assessment and suggestion here>
+**Hardware Requirements:**
+  <Your assessment and suggestion here>
+**Installation Guide:**
+  <Your assessment and suggestion here>  
+**Compatible Operating System:**
+  <Your assessment and suggestion here>
 
 ---
 
-### Output Format
-
-Your response **must exactly follow** the structure below:
-
-**FinalAnswer**
-**Overall Score:** [Poor / Fair / Good / Excellent]  
-**Ease of Access:** <your comments>  
-**Clarity of Dependency Specification:** <your comments>  
-**Hardware Requirements:** <your comments>  
-**Installation Guide:** <your comments>  
+### **Structured Evaluation and Reasoning Process**
+{structured_evaluation_and_reasoning_process}
 
 ---
 
@@ -113,54 +120,6 @@ Your response **must exactly follow** the structure below:
 
 """
 
-class StructuredEvaluationInstallationResult(BaseModel):
-    install_available: Optional[bool]=Field(description="A boolean value. Is the installation documents accessible and present?")
-    install_tutorial: Optional[bool]=Field(description="A boolean value. Is the installation tutorial provided?")
-    dependency_number: Optional[int]=Field(description="A number. It is the number of dependencies that are required to install.")
-    dependency_suggestions: Optional[str]=Field(description="A string value. It is the specific improvements if necessary, such as missing dependencies")
-    compatible_os: Optional[bool]=Field(description="A boolean value. Is compatible operating system described?")
-    overall_score: Optional[str]=Field(description="A overall scroll for the installation quality, could be `Poor`, `Fair`, `Good`, or `Excellent`")
-
-class EvaluationInstallationResult(BaseModel):
-    ease_of_access: Optional[str]=Field(description="Is the installation information easy to access")
-    score: Optional[str]=Field(description="An overall score, could be Poor, Fair, Good or Excellent")
-    clarity_of_dependency: Optional[str]=Field(description="Are all dependencies clearly listed")
-    hardware_requirements: Optional[str]=Field(description="Are all hardware requirements clearly specified")
-    installation_guide: Optional[str]=Field(description="Is there a clear, ordered set of instructions for installing the software")
-
-EvaluationInstallationResultSchema = {
-    "title": "EvaluationREADMEResult",
-    "type": "object",
-    "properties": {
-        "ease_of_access": {
-            "anyOf": [{"type": "string"}, {"type": "null"}],
-            "description": "Is the installation information easy to access",
-            "title": "Ease of Access"
-        },
-        "score": {
-            "anyOf": [{"type": "string"}, {"type": "null"}],
-            "description": "An overall score, could be Poor, Fair, Good or Excellent",
-            "title": "Score"
-        },
-        "clarity_of_dependency": {
-            "anyOf": [{"type": "string"}, {"type": "null"}],
-            "description": "Are all dependencies clearly listed",
-            "title": "Clarity of Dependency",
-        },
-        "hardware_requirements": {
-            "anyOf": [{"type": "string"}, {"type": "null"}],
-            "description": "Are all hardware requirements clearly specified",
-            "title": "Hardware Requirements"
-        },
-        "installation_guide": {
-            "anyOf": [{"type": "string"}, {"type": "null"}],
-            "description": "Is there a clear, ordered set of instructions for installing the software",
-            "title": "Installation Guide"
-        }
-    },
-    "required": ["ease_of_access", "score", "clarity_of_dependency", "hardware_requirements", "installation_guide"]
-}
-
 class EvaluationInstallationTask(EvaluationTask):
     def __init__(
         self, 
@@ -217,25 +176,30 @@ class EvaluationInstallationTask(EvaluationTask):
         self.print_step(token_usage=token_usage)
 
         return {
-            "structured_evaluation": res,
-            "structured_reasoning_process": reasoning_process,
+            "evaluation": res,
+            "reasoning_process": reasoning_process,
         }, token_usage
     
-    def _free_evaluate(self, files: list[str] | None=None) -> tuple[dict|None, dict]:
+    def _free_evaluate(
+        self, 
+        files: list[str] | None=None,
+        structured_evaluation_and_reasoning_process: str | None=None,
+    ) -> tuple[dict|None, dict]:
         if files is None or len(files) == 0:
             return None, {**DEFAULT_TOKEN_USAGE}
         
+        structured_evaluation_and_reasoning_process = structured_evaluation_and_reasoning_process or "N/A"
         files_content = self._collect_install_files_content(files)
-        system_prompt = ChatPromptTemplate.from_template(EVALUATION_INSTALLATION_SYSTEM_PROMPT).format(
-            installation_files_content=files_content
+        system_prompt = ChatPromptTemplate.from_template(FREE_EVALUATION_INSTALLATION_SYSTEM_PROMPT).format(
+            installation_files_content=files_content,
+            structured_evaluation_and_reasoning_process=structured_evaluation_and_reasoning_process,
         )
         agent = CommonAgentTwoChainSteps(llm=self.llm)
         res, _, token_usage, reasoning_process = agent.go(
             system_prompt=system_prompt,
             instruction_prompt=EVALUATION_INSTRUCTION,
-            schema=EvaluationInstallationResultSchema,
+            schema=FreeEvaluationInstallationResult,
         )
-        res = EvaluationInstallationResult(**res)
         self.print_step(step_output=reasoning_process)
         self.print_step(token_usage=token_usage)
         evaluation = {
@@ -244,15 +208,20 @@ class EvaluationInstallationTask(EvaluationTask):
         }
         return evaluation, token_usage
     
-    def _evaluate(self, files: list[str] | None = None) -> tuple[dict | None, dict, list[str]]:
-        evaluation, token_usage = self._free_evaluate(files)
-        structured_evaluation, structured_token_usage = self._structured_evaluate(files)
+    def _evaluate(self, files: list[str] | None = None) -> tuple[EvaluationInstallationResult | None, dict, list[str]]:
+        total_token_usage = {**DEFAULT_TOKEN_USAGE}
 
-        combined_evaluation = {
-            **evaluation,
-            **structured_evaluation,
-        }
-        total_token_usage = increase_token_usage(token_usage, structured_token_usage)
+        structured_evaluation, structured_token_usage = self._structured_evaluate(files)
+        total_token_usage = increase_token_usage(total_token_usage, structured_token_usage)
+        evaluation, token_usage = self._free_evaluate(files, structured_evaluation["reasoning_process"])
+        total_token_usage = increase_token_usage(total_token_usage, token_usage)
+
+        combined_evaluation = EvaluationInstallationResult(
+            structured_evaluation=structured_evaluation["evaluation"],
+            free_evaluation=evaluation["evaluation"],
+            structured_reasoning_process=structured_evaluation["reasoning_process"],
+            free_reasoning_process=evaluation["reasoning_process"],
+        )
 
         return combined_evaluation, total_token_usage, files