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

tooluniverse/test/test_compose_lieraturereview.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+Simple demo for SimpleLiteratureTool - Perfect for paper screenshots
+Shows clean, minimal compose tool functionality
+"""
+
+from tooluniverse import ToolUniverse
+
+
+def main():
+    print("🔬 LiteratureReviewAgent Tool Demo")
+    print("=" * 40)
+
+    # Initialize ToolUniverse and load all tools
+    engine = ToolUniverse()
+    engine.load_tools()  # Load all available tools
+
+    # Check available tools
+    all_tools = engine.return_all_loaded_tools()
+    print(f"Total tools loaded: {len(all_tools)}")
+
+    # Get tool names (for dictionary-based tools, extract the 'name' field)
+    tool_names = []
+    for tool in all_tools:
+        if isinstance(tool, dict) and "name" in tool:
+            tool_names.append(tool["name"])
+        elif isinstance(tool, str):
+            tool_names.append(tool)
+
+    # Look for compose tools
+    compose_tools = [
+        t for t in tool_names if "Safety" in t or "Literature" in t or "Simple" in t
+    ]
+    print(f"Compose tools available: {compose_tools}")
+
+    if "LiteratureReviewAgent" in tool_names:
+        # Run the simple compose tool
+        result = engine.run_one_function(
+            {
+                "name": "LiteratureReviewAgent",
+                "arguments": {"research_topic": "CRISPR gene editing"},
+            }
+        )
+        print(result)
+
+        # Display clean results if it's a dict
+        if isinstance(result, dict):
+            print(f"📚 Topic: {result.get('topic', 'N/A')}")
+            print(f"📄 Papers Found: {result.get('papers_found', 0)}")
+            print("🗂️ Sources: Europe PMC, OpenAlex, PubTator")
+            print(
+                f"🤖 AI Summary: {'✅ Generated' if result.get('ai_summary') else '❌ Failed'}"
+            )
+        else:
+            print(f"Result: {result}")
+    else:
+        print("LiteratureReviewAgent not found in loaded tools")
+
+    print("\n✅ Demo Complete!")
+
+
+if __name__ == "__main__":
+    main()

tooluniverse/test/test_compose_tool.py

@@ -0,0 +1,448 @@
+"""
+ComposeTool Test File
+
+This file tests the core functionality of ComposeTool:
+1. Basic ComposeTool creation and execution
+2. ComposeTool nested calling (one ComposeTool calling another ComposeTool)
+3. Simple mathematical operations
+
+ComposeTool is a composable tool that supports:
+- Inline code definition (write Python code directly in JSON configuration)
+- External file definition (define complex logic through Python files)
+- Nested calling between tools (using call_tool function)
+
+Usage:
+1. Run the entire test: python test_compose_tool.py
+2. View test results to confirm all functionality works properly
+"""
+
+import sys
+import os
+import json
+
+# Add src directory to Python path to import tooluniverse modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+from tooluniverse.execute_function import ToolUniverse  # noqa: E402
+
+
+def test_nested_calls():
+    """
+    Test ComposeTool nested calling functionality
+
+    This test creates two ComposeTool instances:
+    1. TextTool: receives text, returns uppercase text and length
+    2. CallerTool: calls TextTool to process text, then wraps the result
+
+    Key verification points:
+    - ComposeTool can call other ComposeTool instances
+    - Correct usage of call_tool function
+    - Parameter passing and result return in nested calls
+    """
+    print("Testing ComposeTool nested calling functionality")
+    print("=" * 40)
+
+    # Create a simple text processing tool
+    # This tool receives text and returns uppercase version and length
+    text_tool = {
+        "type": "ComposeTool",
+        "name": "TextTool",
+        "description": "Simple text processing tool",
+        "parameter": {
+            "type": "object",
+            "properties": {"text": {"type": "string", "description": "Input text"}},
+            "required": ["text"],
+        },
+        "composition_code": [
+            "# Get text from arguments",
+            "text = arguments['text']",
+            "# Return processing result: uppercase text and length",
+            "result = {'processed': text.upper(), 'length': len(text)}",
+        ],
+    }
+
+    # Create a caller tool that calls the above TextTool
+    # This demonstrates the nested calling capability of ComposeTool
+    caller_tool = {
+        "type": "ComposeTool",
+        "name": "CallerTool",
+        "description": "Composite tool that calls text tool",
+        "parameter": {
+            "type": "object",
+            "properties": {"input": {"type": "string", "description": "Input text"}},
+            "required": ["input"],
+        },
+        "composition_code": [
+            "# Get input text",
+            "input_text = arguments['input']",
+            "# Use call_tool function to call TextTool",
+            "# call_tool(tool_name, arguments_dict) is the standard way to call other tools in ComposeTool",
+            "text_result = call_tool('TextTool', {'text': input_text})",
+            "# Wrap result, including original input and processing result",
+            "result = {'original': input_text, 'processed_result': text_result}",
+        ],
+    }
+
+    # Initialize ToolUniverse engine
+    engine = ToolUniverse()
+
+    # Register tools to engine
+    # Need to add to both all_tools list and all_tool_dict dictionary
+    engine.all_tools.extend([text_tool, caller_tool])
+    engine.all_tool_dict["TextTool"] = text_tool
+    engine.all_tool_dict["CallerTool"] = caller_tool
+
+    # Run test: call CallerTool, which will internally call TextTool
+    result = engine.run_one_function(
+        {"name": "CallerTool", "arguments": {"input": "hello world"}}
+    )
+
+    print("Nested calling result:")
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+def test_simple_math():
+    """
+    Test ComposeTool's mathematical operations functionality
+
+    This test creates a math tool that supports:
+    1. Array summation
+    2. Array element multiplication
+    3. Default handling for unknown operations
+
+    Key verification points:
+    - Conditional logic processing in ComposeTool
+    - Array data processing
+    - Support for multiple operation types
+    """
+    print("\nTesting simple mathematical operations functionality")
+    print("=" * 40)
+
+    # Create a mathematical operations tool
+    # Supports sum or multiply operations on number arrays
+    math_tool = {
+        "type": "ComposeTool",
+        "name": "MathTool",
+        "description": "Simple mathematical operations tool",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "numbers": {"type": "array", "description": "Array of numbers"},
+                "op": {
+                    "type": "string",
+                    "description": "Operation type: sum (addition) or multiply (multiplication)",
+                },
+            },
+            "required": ["numbers", "op"],
+        },
+        "composition_code": [
+            "# Get number array and operation type from arguments",
+            "numbers = arguments['numbers']",
+            "op = arguments['op']",
+            "",
+            "# Execute different calculations based on operation type",
+            "if op == 'sum':",
+            "    # Sum operation",
+            "    result = {'result': sum(numbers), 'operation': 'sum'}",
+            "elif op == 'multiply':",
+            "    # Multiply operation: start with 1, multiply sequentially",
+            "    result = {'result': 1}",
+            "    for n in numbers:",
+            "        result['result'] *= n",
+            "    result['operation'] = 'multiply'",
+            "else:",
+            "    # Default handling for unknown operations",
+            "    result = {'result': 0, 'operation': 'unknown'}",
+        ],
+    }
+
+    # Initialize engine and register math tool
+    engine = ToolUniverse()
+    engine.all_tools.append(math_tool)
+    engine.all_tool_dict["MathTool"] = math_tool
+
+    # Test sum functionality
+    print("Testing sum operation:")
+    result = engine.run_one_function(
+        {"name": "MathTool", "arguments": {"numbers": [1, 2, 3, 4], "op": "sum"}}
+    )
+    print("  Input: [1, 2, 3, 4], Operation: sum")
+    print(f"  Result: {result}")
+
+    # Test multiply functionality
+    print("\nTesting multiply operation:")
+    result = engine.run_one_function(
+        {"name": "MathTool", "arguments": {"numbers": [2, 3, 4], "op": "multiply"}}
+    )
+    print("  Input: [2, 3, 4], Operation: multiply")
+    print(f"  Result: {result}")
+
+
+def test_config_file_tools():
+    """
+    Test ComposeTool loaded from configuration files
+
+    This test verifies:
+    1. Loading ComposeTool from JSON configuration files
+    2. Configuration file defined tools can run normally
+    3. Demonstrate how to use predefined composite tools
+
+    Configuration file location: src/tooluniverse/data/compose_tools.json
+    """
+    print("\nTesting ComposeTool from configuration files")
+    print("=" * 40)
+
+    # Initialize ToolUniverse engine
+    engine = ToolUniverse()
+
+    # Load compose type tools from configuration files
+    # This automatically loads tools defined in src/tooluniverse/data/compose_tools.json
+    engine.load_tools(tool_type=["compose"])
+
+    # Test DrugSafetyAnalyzer tool from configuration file
+    print("Running DrugSafetyAnalyzer tool from configuration file:")
+    try:
+        result = engine.run_one_function(
+            {
+                "name": "DrugSafetyAnalyzer",
+                "arguments": {"drug_name": "aspirin", "serious_events_only": False},
+            }
+        )
+
+        print("DrugSafetyAnalyzer tool result:")
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    except Exception as e:
+        print(f"DrugSafetyAnalyzer test failed: {e}")
+        print("This is expected if the required atomic tools are not loaded.")
+
+    print(f"\nTotal tools loaded: {len(engine.callable_functions)}")
+    compose_tools = [
+        name
+        for name in engine.callable_functions.keys()
+        if any(
+            tool.get("name") == name and tool.get("type") == "ComposeTool"
+            for tool in engine.all_tools
+        )
+    ]
+    print(f"ComposeTool instances: {compose_tools}")
+
+    # Check available composite tools and test them
+    print(f"\nTotal tools loaded: {len(engine.all_tools)}")
+    compose_tools = [
+        name
+        for name in engine.callable_functions.keys()
+        if any(
+            tool.get("name") == name and tool.get("type") == "ComposeTool"
+            for tool in engine.all_tools
+        )
+    ]
+    print(f"ComposeTool instances available: {compose_tools}")
+
+
+def test_external_file_tools():
+    """
+    Test additional ComposeTool functionality
+
+    This test verifies:
+    1. Additional composite tools from configuration
+    2. Testing ProteinFunctionAnalyzer and LiteratureMetaAnalyzer
+    3. Demonstrate complex biomedical analysis workflows
+    """
+    print("\nTesting additional composite tools")
+    print("=" * 40)
+
+    # Initialize ToolUniverse engine
+    engine = ToolUniverse()
+
+    # Load compose type tools from configuration files
+    engine.load_tools(tool_type=["compose"])
+
+    # Only test tools that are actually loaded
+    compose_tools = [
+        tool for tool in engine.all_tools if tool.get("type") == "ComposeTool"
+    ]
+    print(f"Found {len(compose_tools)} composite tools:")
+    for tool in compose_tools:
+        print(f"  - {tool['name']}: {tool['description']}")
+
+    # Test each available composite tool
+    for tool in compose_tools:
+        tool_name = tool["name"]
+        if tool_name in [
+            "DrugSafetyAnalyzer",
+            "SimpleExample",
+            "TestDependencyLoading",
+        ]:
+            # Skip these as they are tested in other functions
+            continue
+
+        print(f"\nTesting {tool_name}:")
+        try:
+            # Create generic test arguments based on tool requirements
+            test_args = {}
+            if "parameter" in tool and "properties" in tool["parameter"]:
+                for param_name, param_info in tool["parameter"]["properties"].items():
+                    if param_info["type"] == "string":
+                        test_args[param_name] = "test_input"
+                    elif param_info["type"] == "number":
+                        test_args[param_name] = 1
+                    elif param_info["type"] == "boolean":
+                        test_args[param_name] = True
+                    # Add other types as needed
+
+            result = engine.run_one_function(
+                {"name": tool_name, "arguments": test_args}
+            )
+            print(f"{tool_name} result:")
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        except Exception as e:
+            print(f"{tool_name} test failed: {e}")
+            print("This is expected if the required atomic tools are not loaded.")
+
+
+def test_dependency_auto_loading():
+    """
+    Test ComposeTool automatic dependency loading functionality
+
+    This test verifies:
+    1. Automatic detection of tool dependencies
+    2. Auto-loading of missing tool categories
+    3. Error handling for unavailable tools
+    4. Configuration options for dependency behavior
+    """
+    print("\nTesting automatic dependency loading functionality")
+    print("=" * 40)
+
+    # Create a ComposeTool that depends on external tools
+    dependent_tool = {
+        "type": "ComposeTool",
+        "name": "DependentTool",
+        "description": "Tool that depends on external tools",
+        "parameter": {
+            "type": "object",
+            "properties": {"query": {"type": "string", "description": "Search query"}},
+            "required": ["query"],
+        },
+        "auto_load_dependencies": True,
+        "fail_on_missing_tools": False,
+        "required_tools": ["EuropePMC_search_articles"],
+        "composition_code": [
+            "# This tool tries to call EuropePMC tool",
+            "query = arguments['query']",
+            "",
+            "print(f'Testing with query: {query}')",
+            "",
+            "# Try to call external tool",
+            "literature_result = call_tool('EuropePMC_search_articles', {",
+            "    'query': query,",
+            "    'limit': 3",
+            "})",
+            "",
+            "result = {",
+            "    'query': query,",
+            "    'literature_result': literature_result,",
+            "    'success': True,",
+            "    'message': 'Dependency test completed'",
+            "}",
+            "",
+            "print(f'Dependency test completed for query: {query}')",
+        ],
+    }
+
+    # Initialize engine without loading external tools initially
+    engine = ToolUniverse()
+    engine.all_tools.append(dependent_tool)
+    engine.all_tool_dict["DependentTool"] = dependent_tool
+
+    # Test the tool - it should attempt to auto-load dependencies
+    print("Testing tool with auto-loading enabled:")
+    result = engine.run_one_function(
+        {"name": "DependentTool", "arguments": {"query": "artificial intelligence"}}
+    )
+
+    print("Dependency auto-loading test result:")
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+def main():
+    """
+    Main test function with enhanced dependency management testing
+
+    Run all ComposeTool tests:
+    1. Nested calling test - verify inter-tool calling capability
+    2. Mathematical operations test - verify data processing capability
+    3. Configuration file test - verify tool loading from files capability
+    4. Dependency auto-loading test - verify automatic dependency management
+
+    Summary information will be displayed after tests complete
+    """
+    print("ComposeTool Functionality Tests (Enhanced with Dependency Management)")
+    print("=" * 70)
+    print("Test contents:")
+    print("1. Nested calling functionality - ComposeTool calling other ComposeTool")
+    print("2. Mathematical operations functionality - array sum and multiply")
+    print("3. Configuration file functionality - testing available composite tools:")
+    print("   - DrugSafetyAnalyzer: Drug safety analysis with FAERS, PubChem, ChEMBL")
+    print("   - SimpleExample: Simple tool with no external dependencies")
+    print("   - TestDependencyLoading: Tool that tests auto-loading dependencies")
+    print("4. Additional composite tools functionality")
+    print("5. Automatic dependency loading functionality")
+    print("=" * 70)
+
+    try:
+        # Run all tests
+        test_nested_calls()
+        test_simple_math()
+        test_config_file_tools()
+        test_external_file_tools()
+        test_dependency_auto_loading()
+
+        # Display success information
+        print("\n" + "=" * 70)
+        print("✅ All tests completed!")
+        print("=" * 70)
+        print("Enhanced dependency management features:")
+        print("- ✅ Automatic detection of tool dependencies from code")
+        print("- ✅ Auto-loading of missing tool categories")
+        print(
+            "- ✅ Configurable behavior (auto_load_dependencies, fail_on_missing_tools)"
+        )
+        print("- ✅ Graceful error handling for unavailable tools")
+        print("- ✅ Real-time dependency resolution during execution")
+        print(
+            "- ✅ Support for both explicit (required_tools) and implicit dependencies"
+        )
+        print("\nComposeTool capabilities:")
+        print("- Supports both inline code and external file definition methods")
+        print(
+            "- Can implement nested calling between tools through call_tool() function"
+        )
+        print(
+            "- Fully integrated into ToolUniverse framework, usage consistent with other tools"
+        )
+        print("- Supports complex data processing and logic control")
+        print(
+            "- New composite tools demonstrate real-world biomedical analysis workflows"
+        )
+
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        print("\nTroubleshooting tips:")
+        print("1. Ensure all dependency packages are correctly installed")
+        print("2. Check if src/tooluniverse/data/compose_tools.json file exists")
+        print(
+            "3. Check if the new composite tools are properly defined in compose_tools.json"
+        )
+        print(
+            "4. Confirm ComposeTool class is correctly integrated into execute_function.py"
+        )
+        print("5. Note: Auto-loading will attempt to load missing tools automatically")
+        print("6. Use auto_load_dependencies=false to disable automatic loading")
+        print("7. Use fail_on_missing_tools=true for strict dependency checking")
+
+
+if __name__ == "__main__":
+    main()

tooluniverse/test/test_dailymed.py

@@ -0,0 +1,69 @@
+# test_dailymed.py
+
+from tooluniverse import ToolUniverse
+
+# === test_dailymed.py ===
+
+# Step 1: Initialize ToolUniverse and load all tools (including our DailyMed tools)
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Step 2: Define test queries for DailyMed tools
+# NOTE: Before running this script, please confirm that "DailyMed_search_spls" call returns at least one data element,
+#       and extract a valid setid from it. Then replace the example setid below to avoid 404 or 415 errors.
+
+test_queries = [
+    # ---- Tests for DailyMed_search_spls ----
+    # 1. Only pass drug_name, use default pagesize=100, page=1
+    {
+        "name": "DailyMed_search_spls",
+        "arguments": {"drug_name": "TAMSULOSIN HYDROCHLORIDE"},
+    },
+    # 2. Specify drug_name + pagesize=2, check if returns no more than 2 records
+    {
+        "name": "DailyMed_search_spls",
+        "arguments": {"drug_name": "TAMSULOSIN HYDROCHLORIDE", "pagesize": 2},
+    },
+    # 3. Use published_date filter to get recent records
+    {
+        "name": "DailyMed_search_spls",
+        "arguments": {
+            "drug_name": "TAMSULOSIN HYDROCHLORIDE",
+            "published_date_gte": "2025-05-01",
+            "pagesize": 3,
+        },
+    },
+    # ---- Tests for DailyMed_get_spl_by_setid ----
+    # 4. Use setid from first record above (example setid), request XML format
+    {
+        "name": "DailyMed_get_spl_by_setid",
+        "arguments": {
+            # Example setid, please replace with actual first setid from query
+            "setid": "35bbb655-19e2-00c2-e063-6394a90afbe3",
+            "format": "xml",
+        },
+    },
+]
+
+# Step 3: Iterate over all test queries and print results
+for idx, query in enumerate(test_queries):
+    name = query["name"]
+    args = query["arguments"]
+    print(f"\n[{idx+1}] Running tool: {name} with arguments: {args}")
+    try:
+        result = tooluni.run(query)
+        # Print brief results: if dict, print first few lines; otherwise print first 500 chars
+        if isinstance(result, dict):
+            # If contains 'error' key, print complete error dict; otherwise print first 500 chars
+            if "error" in result:
+                print("❌ Error returned:", result)
+            else:
+                snippet = str(result)[:500]
+                print("✅ Success. Result snippet (first 500 chars):")
+                print(snippet)
+        else:
+            snippet = str(result)[:500]
+            print("✅ Success. Result snippet (first 500 chars):")
+            print(snippet)
+    except Exception as e:
+        print(f"❌ Exception occurred: {e}")