aiagents4pharma 1.4.0__tar.gz → 1.4.2__tar.gz

{aiagents4pharma-1.4.0 → aiagents4pharma-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aiagents4pharma
-Version: 1.4.0
+Version: 1.4.2
 Summary: AI Agents for drug discovery, drug development, and other pharmaceutical R&D
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{aiagents4pharma-1.4.0 → aiagents4pharma-1.4.2}/aiagents4pharma/talk2biomodels/tools/__init__.py

@@ -1,7 +1,10 @@
 '''
 This file is used to import all the modules in the package.
 '''
+# import everything from the module
+from . import ask_question
 from . import simulate_model
+from . import custom_plotter
+from . import fetch_parameters
 from . import model_description
-from . import ask_question
-from . import plot_figure
+from . import search_models

{aiagents4pharma-1.4.0 → aiagents4pharma-1.4.2}/aiagents4pharma/talk2biomodels/tools/simulate_model.py

@@ -4,13 +4,13 @@
 Tool for simulating a model.
 """
 
-from typing import Type, Union, List, Optional, Tuple
-import basico
+from typing import Type, Union, List, Optional
 from dataclasses import dataclass
+import basico
 from pydantic import BaseModel, Field
 from langchain_core.tools import BaseTool
 import streamlit as st
-import plotly.express as px
+# import plotly.express as px
 from ..models.basico_model import BasicoModel
 
 @dataclass
@@ -91,33 +91,36 @@ class SimulateModelTool(BaseTool):
         Returns:
             str: The result of the simulation.
         """
-        st_session_key = self.st_session_key
+        # st_session_key = self.st_session_key
         # Retrieve the model ID, duration, and interval
         modelid = model_data.modelid if model_data is not None else None
-        duration = time_data.duration if time_data is not None else 100.0
-        interval = time_data.interval if time_data is not None else 10
+        # duration = time_data.duration if time_data is not None else 100.0
+        # interval = time_data.interval if time_data is not None else 10
         # Prepare the dictionary of species data
         # that will be passed to the simulate method
         # of the BasicoModel class
-        dic_species_data = None
-        if species_data is not None:
-            dic_species_data = dict(zip(species_data.species_name,
-                                    species_data.species_concentration))
+        # dic_species_data = None
+        # if species_data is not None:
+        #     dic_species_data = dict(zip(species_data.species_name,
+        #                             species_data.species_concentration))
+        dic_species_data = dict(zip(species_data.species_name, \
+            species_data.species_concentration)) \
+                if species_data is not None else None
         # Retrieve the SBML file path from the Streamlit session state
         # otherwise retrieve it from the model_data object if the user
         # has provided it.
         sbml_file_path = model_data.sbml_file_path if model_data is not None else None
-        if st_session_key:
-            if st_session_key not in st.session_state:
-                return f"Session key {st_session_key} not found in Streamlit session state."
+        if self.st_session_key:
+            if self.st_session_key not in st.session_state:
+                return f"Session key {self.st_session_key} not found in Streamlit session state."
             if 'sbml_file_path' in st.session_state:
                 sbml_file_path = st.session_state.sbml_file_path
         # Check if both modelid and sbml_file_path are None
         if modelid is None and sbml_file_path is None:
             # Then load the model from the Streamlit session state
             # if the streamlit session exists
-            if st_session_key:
-                model_object = st.session_state[st_session_key]
+            if self.st_session_key:
+                model_object = st.session_state[self.st_session_key]
                 # If this model object is None, then return an error message
                 if model_object is None:
                     return "Please provide a BioModels ID or an SBML file path for simulation."
@@ -131,13 +134,13 @@ class SimulateModelTool(BaseTool):
             # model_object = BasicoModel(model_id=modelid)
             model_object = BasicoModel(model_id=modelid)
             # Save the model object in the Streamlit session state
-            st.session_state[st_session_key] = model_object
+            st.session_state[self.st_session_key] = model_object
         elif sbml_file_path:
             # Create a BasicoModel object with the SBML file path
             model_object = BasicoModel(sbml_file_path=sbml_file_path)
             modelid = model_object.model_id
             # Save the model object in the Streamlit session state
-            st.session_state[st_session_key] = model_object
+            st.session_state[self.st_session_key] = model_object
         # Add recurring events (if any) to the model
         if recurring_data is not None:
             for row in recurring_data.data:
@@ -149,29 +152,30 @@ class SimulateModelTool(BaseTool):
                 # print (f'Added event {sn}_{tp} at time {tp} \
                 #        for species {sn} with concentration {sc}')
         # Simulate the model
-        df = model_object.simulate(parameters=dic_species_data,
-                                    duration=duration,
-                                    interval=interval)
+        df = model_object.simulate(
+            parameters=dic_species_data,
+            duration=time_data.duration if time_data is not None else 100.0,
+            interval=time_data.interval if time_data is not None else 10)
         # Convert the DataFrame to long format for plotting
         # and ignore the index column
         df = df.melt(id_vars='Time',
                     var_name='Species',
                     value_name='Concentration')
         # Plot the simulation results using Plotly
-        fig = px.line(df,
-                        x='Time',
-                        y='Concentration',
-                        color='Species',
-                        title=f"Concentration of Species over Time in the model {modelid}",
-                        height=600,
-                        width=800
-        )
+        # fig = px.line(df,
+        #                 x='Time',
+        #                 y='Concentration',
+        #                 color='Species',
+        #                 title=f"Concentration of Species over Time in the model {modelid}",
+        #                 height=600,
+        #                 width=800
+        # )
         # Display the plot in Streamlit
         # st.plotly_chart(fig, use_container_width = False)
-        if modelid is None:
-            modelid = "internal"
-        content = f"Simulation results for the model {modelid}."
-        return content
+        # if modelid is None:
+        #     modelid = "internal"
+        # return f"Simulation results for the model {modelid}."
+        return "Simulation results for the model."
 
     def get_metadata(self):
         """
@@ -182,6 +186,5 @@ class SimulateModelTool(BaseTool):
         """
         return {
             "name": self.name,
-            "description": self.description,
-            "return_direct": self.return_direct,
+            "description": self.description
         }

{aiagents4pharma-1.4.0 → aiagents4pharma-1.4.2}/aiagents4pharma.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aiagents4pharma
-Version: 1.4.0
+Version: 1.4.2
 Summary: AI Agents for drug discovery, drug development, and other pharmaceutical R&D
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{aiagents4pharma-1.4.0 → aiagents4pharma-1.4.2}/aiagents4pharma.egg-info/SOURCES.txt

@@ -17,6 +17,5 @@ aiagents4pharma/talk2biomodels/tools/ask_question.py
 aiagents4pharma/talk2biomodels/tools/custom_plotter.py
 aiagents4pharma/talk2biomodels/tools/fetch_parameters.py
 aiagents4pharma/talk2biomodels/tools/model_description.py
-aiagents4pharma/talk2biomodels/tools/plot_figure.py
 aiagents4pharma/talk2biomodels/tools/search_models.py
 aiagents4pharma/talk2biomodels/tools/simulate_model.py

aiagents4pharma-1.4.2/release_version.txt

@@ -0,0 +1 @@
+v1.4.2

aiagents4pharma-1.4.0/aiagents4pharma/talk2biomodels/tools/plot_figure.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Tool for plotting a figure.
-"""
-
-from typing import Type, Optional
-from dataclasses import dataclass
-import matplotlib.pyplot as plt
-from pydantic import BaseModel, Field
-import streamlit as st
-from langchain_openai import ChatOpenAI
-from langchain_core.tools import BaseTool
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.output_parsers.openai_tools import JsonOutputKeyToolsParser
-from langchain_experimental.tools import PythonAstREPLTool
-from ..models.basico_model import BasicoModel
-
-@dataclass
-class ModelData:
-    """
-    Dataclass for storing the model data.
-    """
-    modelid: Optional[int] = None
-    sbml_file_path: Optional[str] = None
-    model_object: Optional[BasicoModel] = None
-
-class PlotImageInput(BaseModel):
-    """
-    Input schema for the PlotImage tool.
-    """
-    question: str = Field(description="Description of the plot")
-    sys_bio_model: ModelData = Field(description="model data", default=None)
-
-# Note: It's important that every field has type hints. BaseTool is a
-# Pydantic class and not having type hints can lead to unexpected behavior.
-class PlotImageTool(BaseTool):
-    """
-    Tool for plotting a figure.
-    """
-    name: str = "plot_figure"
-    description: str = "A tool to plot or visualize the simulation results."
-    args_schema: Type[BaseModel] = PlotImageInput
-    st_session_key: str = None
-
-    def _run(self,
-             question: str,
-             sys_bio_model: ModelData = ModelData()) -> str:
-        """
-        Run the tool.
-
-        Args:
-            question (str): The question to ask about the model description.
-            sys_bio_model (ModelData): The model data.
-
-        Returns:
-            str: The answer to the question
-        """
-        st_session_key = self.st_session_key
-        # Check if sys_bio_model is provided
-        if sys_bio_model.modelid or sys_bio_model.sbml_file_path or sys_bio_model.model_object:
-            if sys_bio_model.modelid:
-                model_object = BasicoModel(model_id=sys_bio_model.modelid)
-            elif sys_bio_model.sbml_file_path:
-                model_object = BasicoModel(sbml_file_path=sys_bio_model.sbml_file_path)
-            else:
-                model_object = sys_bio_model.model_object
-            if st_session_key:
-                st.session_state[st_session_key] = model_object
-        else:
-            # If the model_object is not provided,
-            # get it from the Streamlit session state
-            if st_session_key:
-                if st_session_key not in st.session_state:
-                    return f"Session key {st_session_key} not found in Streamlit session state."
-                model_object = st.session_state[st_session_key]
-            else:
-                return "Please provide a valid model object or \
-                    Streamlit session key that contains the model object."
-        if model_object is None:
-            return "Please run the simulation first before plotting the figure."
-        if model_object.simulation_results is None:
-            model_object.simulate()
-        df = model_object.simulation_results
-        tool = PythonAstREPLTool(locals={"df": df})
-        llm = ChatOpenAI(model="gpt-3.5-turbo")
-        llm_with_tools = llm.bind_tools([tool], tool_choice=tool.name)
-        system = f"""
-                    You have access to a pandas dataframe `df`.
-                    Here is the output of `df.head().to_markdown()`:
-                    {df.head().to_markdown()}
-                    Given a user question, write the Python code to
-                    plot a figure of the answer using matplolib.
-                    Return ONLY the valid Python code and nothing else.
-                    The firgure size should be equal or smaller than (2, 2).
-                    Show the grid and legend. The font size of the legend should be 6.
-                    Also write a suitable title for the figure. The font size of the title should be 8.
-                    The font size of the x-axis and y-axis labels should be 8.
-                    The font size of the x-axis and y-axis ticks should be 6.
-                    Make sure that the x-axis has at least 10 tick marks.
-                    Use color-blind friendly colors. The figure must be of high quality.
-                    Don't assume you have access to any libraries other
-                    than built-in Python ones, pandas, streamlit and matplotlib.
-                    """
-        prompt = ChatPromptTemplate.from_messages([("system", system), ("human", "{question}")])
-        parser = JsonOutputKeyToolsParser(key_name=tool.name, first_tool_only=True)
-        code_chain = prompt | llm_with_tools | parser
-        response = code_chain.invoke({"question": question})
-        exec(response['query'], globals(), {"df": df, "plt": plt})
-        # load for plotly
-        fig = plt.gcf()
-        if st_session_key:
-            st.pyplot(fig, use_container_width=False)
-            st.dataframe(df)
-        return "Figure plotted successfully"
-
-    def call_run(self,
-            question: str,
-            sys_bio_model: ModelData = ModelData(),
-            st_session_key: str = None) -> str:
-        """
-        Run the tool.
-        """
-        return self._run(question=question,
-                         sys_bio_model=sys_bio_model,
-                         st_session_key=st_session_key)
-
-    def get_metadata(self):
-        """
-        Get metadata for the tool.
-        """
-        return {
-            "name": self.name,
-            "description": self.description
-        }

aiagents4pharma-1.4.0/release_version.txt

@@ -1 +0,0 @@
-v1.4.0