tooluniverse 0.1.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

tooluniverse/custom_tool.py

@@ -0,0 +1,81 @@
+"""
+CustomTool implementation for ToolUniverse
+Handles execution of dynamically generated tools with external code files
+"""
+
+import importlib.util
+import os
+from typing import Dict, Any
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("CustomTool")
+class CustomTool(BaseTool):
+    """
+    CustomTool class for executing dynamically generated tools
+    """
+
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.code_file = tool_config.get("code_file")
+        self.name = tool_config.get("name", "CustomTool")
+        self.description = tool_config.get("description", "")
+
+        # Load the external code if code_file is specified
+        self.execute_function = None
+        if self.code_file and os.path.exists(self.code_file):
+            self._load_external_code()
+
+    def _load_external_code(self):
+        """Load the execute_tool function from external Python file"""
+        try:
+            # Load module from file
+            spec = importlib.util.spec_from_file_location(
+                "custom_tool_module", self.code_file
+            )
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            # Get the execute_tool function
+            if hasattr(module, "execute_tool"):
+                self.execute_function = module.execute_tool
+            else:
+                print(f"Warning: No execute_tool function found in {self.code_file}")
+
+        except Exception as e:
+            print(f"Error loading external code from {self.code_file}: {e}")
+
+    def run(self, arguments: Any = None) -> Dict[str, Any]:
+        """
+        Execute the custom tool
+
+        Args:
+            arguments: Input arguments for the tool
+
+        Returns:
+            Dict containing the result of tool execution
+        """
+        try:
+            if self.execute_function:
+                # Use the loaded external function
+                result = self.execute_function(
+                    arguments if arguments is not None else {}
+                )
+                return {"success": True, "result": result, "tool_name": self.name}
+            else:
+                # Fallback to basic processing
+                return {
+                    "success": False,
+                    "error": "No execute_tool function available",
+                    "input_received": arguments,
+                    "tool_name": self.name,
+                }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "input_received": arguments,
+                "tool_name": self.name,
+            }

tooluniverse/dailymed_tool.py

@@ -0,0 +1,108 @@
+# dailymed_tool.py
+
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+DAILYMED_BASE = "https://dailymed.nlm.nih.gov/dailymed/services/v2"
+
+
+@register_tool("SearchSPLTool")
+class SearchSPLTool(BaseTool):
+    """
+    Search SPL list based on multiple filter conditions (drug_name/ndc/rxcui/setid/published_date).
+    Returns original DailyMed API JSON (including metadata + data array).
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = f"{DAILYMED_BASE}/spls.json"
+
+    def run(self, arguments):
+        # Extract possible filter conditions from arguments
+        params = {}
+        # Four common filter fields
+        if arguments.get("drug_name"):
+            params["drug_name"] = arguments["drug_name"]
+        if arguments.get("ndc"):
+            params["ndc"] = arguments["ndc"]
+        if arguments.get("rxcui"):
+            params["rxcui"] = arguments["rxcui"]
+        if arguments.get("setid"):
+            params["setid"] = arguments["setid"]
+
+        # Published date range filter
+        if arguments.get("published_date_gte"):
+            params["published_date[gte]"] = arguments["published_date_gte"]
+        if arguments.get("published_date_eq"):
+            params["published_date[eq]"] = arguments["published_date_eq"]
+
+        # Pagination parameters
+        params["pagesize"] = arguments.get("pagesize", 100)
+        params["page"] = arguments.get("page", 1)
+
+        # Allow query all if no filter conditions and only pagination provided (be careful with return data volume)
+        try:
+            resp = requests.get(self.endpoint, params=params, timeout=10)
+        except Exception as e:
+            return {"error": f"Failed to request DailyMed search_spls: {str(e)}"}
+
+        if resp.status_code != 200:
+            return {
+                "error": f"DailyMed API access failed, HTTP {resp.status_code}",
+                "detail": resp.text,
+            }
+
+        try:
+            result = resp.json()
+        except ValueError:
+            return {
+                "error": "Unable to parse DailyMed returned JSON.",
+                "content": resp.text,
+            }
+
+        # Return original JSON, including metadata + data
+        return result
+
+
+@register_tool("GetSPLBySetIDTool")
+class GetSPLBySetIDTool(BaseTool):
+    """
+    Get complete SPL label based on SPL Set ID, returns content in XML or JSON format.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        # Different suffixes for XML and JSON
+        self.endpoint_template = f"{DAILYMED_BASE}/spls/{{setid}}.{{fmt}}"
+
+    def run(self, arguments):
+        setid = arguments.get("setid")
+        fmt = arguments.get("format", "xml")
+
+        # DailyMed single SPL API only supports XML format
+        if fmt not in ("xml",):
+            return {
+                "error": "DailyMed single SPL API only supports 'xml' format, JSON is not supported."
+            }
+
+        url = self.endpoint_template.format(setid=setid, fmt=fmt)
+        try:
+            resp = requests.get(url, timeout=10)
+        except Exception as e:
+            return {"error": f"Failed to request DailyMed get_spl_by_setid: {str(e)}"}
+
+        if resp.status_code == 404:
+            return {"error": f"SPL label not found for Set ID={setid}."}
+        elif resp.status_code == 415:
+            return {
+                "error": f"DailyMed API does not support requested format. Set ID={setid} only supports XML format."
+            }
+        elif resp.status_code != 200:
+            return {
+                "error": f"DailyMed API access failed, HTTP {resp.status_code}",
+                "detail": resp.text,
+            }
+
+        # Return XML content
+        return {"xml": resp.text}

tooluniverse/data/admetai_tools.json

@@ -0,0 +1,155 @@
+[
+    {
+        "name": "ADMETAI_predict_physicochemical_properties",
+        "description": "Predicts physicochemical properties (molecular weight, logP, hydrogen bond acceptors/donors, Lipinski, QED, stereo centers, TPSA) for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["molecular_weight", "logP", "hydrogen_bond_acceptors", "hydrogen_bond_donors", "Lipinski", "QED", "stereo_centers", "tpsa"]
+    },
+    {
+        "name": "ADMETAI_predict_CYP_interactions",
+        "description": "Predicts CYP enzyme interactions for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["CYP1A2_Veith", "CYP2C19_Veith", "CYP2C9_Substrate_CarbonMangels", "CYP2C9_Veith", "CYP2D6_Substrate_CarbonMangels", "CYP2D6_Veith", "CYP3A4_Substrate_CarbonMangels", "CYP3A4_Veith"]
+    },
+    {
+        "name": "ADMETAI_predict_BBB_penetrance",
+        "description": "Predicts blood-brain barrier (BBB) penetrance for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["BBB_Martins"]
+    },
+    {
+        "name": "ADMETAI_predict_toxicity",
+        "description": "Predicts toxicity endpoints (AMES, Carcinogens_Lagunin, ClinTox, DILI, LD50_Zhu, Skin_Reaction, hERG) for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["AMES", "Carcinogens_Lagunin", "ClinTox", "DILI", "LD50_Zhu", "Skin_Reaction", "hERG"]
+    },
+    {
+        "name": "ADMETAI_predict_bioavailability",
+        "description": "Predicts bioavailability endpoints (Bioavailability_Ma, HIA_Hou, PAMPA_NCATS, Caco2_Wang, Pgp_Broccatelli) for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["Bioavailability_Ma", "HIA_Hou", "PAMPA_NCATS", "Caco2_Wang", "Pgp_Broccatelli"]
+    },
+    {
+        "name": "ADMETAI_predict_clearance_distribution",
+        "description": "Predicts clearance and distribution endpoints (Clearance_Hepatocyte_AZ, Clearance_Microsome_AZ, Half_Life_Obach, VDss_Lombardo, PPBR_AZ) for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["Clearance_Hepatocyte_AZ", "Clearance_Microsome_AZ", "Half_Life_Obach", "VDss_Lombardo", "PPBR_AZ"]
+    },
+    {
+        "name": "ADMETAI_predict_nuclear_receptor_activity",
+        "description": "Predicts nuclear receptor activity endpoints (NR-AR-LBD, NR-AR, NR-AhR, NR-Aromatase, NR-ER-LBD, NR-ER, NR-PPAR-gamma) for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["NR-AR-LBD", "NR-AR", "NR-AhR", "NR-Aromatase", "NR-ER-LBD", "NR-ER", "NR-PPAR-gamma"]
+    },
+    {
+        "name": "ADMETAI_predict_stress_response",
+        "description": "Predicts stress response endpoints (SR-ARE, SR-ATAD5, SR-HSE, SR-MMP, SR-p53) for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["SR-ARE", "SR-ATAD5", "SR-HSE", "SR-MMP", "SR-p53"]
+    },
+    {
+        "name": "ADMETAI_predict_solubility_lipophilicity_hydration",
+        "description": "Predicts solubility, lipophilicity, and hydration endpoints (Solubility_AqSolDB, Lipophilicity_AstraZeneca, HydrationFreeEnergy_FreeSolv) for a given list of molecules in SMILES format.",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "smiles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "The list of SMILES strings."
+                }
+            },
+            "required": ["smiles"]
+        },
+        "type": "ADMETAITool",
+        "columns": ["Solubility_AqSolDB", "Lipophilicity_AstraZeneca", "HydrationFreeEnergy_FreeSolv"]
+    }
+]