tooluniverse 0.2.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

tooluniverse/test/test_software_tools.py

@@ -0,0 +1,147 @@
+"""
+Test suite for ToolUniverse Software Package Tools
+
+This test validates the PackageTool implementations for popular Python packages.
+It follows the same pattern as other test files in the ToolUniverse test directory.
+
+Usage:
+    python src/tooluniverse/test/test_software_tools.py
+"""
+
+from tooluniverse.execute_function import ToolUniverse
+
+
+def main():
+    print("🧪 Testing ToolUniverse Software Package Tools")
+    print("=" * 60)
+
+    # Step 1: Initialize ToolUniverse with only software tools to reduce noise
+    tooluni = ToolUniverse()
+    tooluni.load_tools(tool_type=["software"])
+
+    # Step 2: Get all software package tools
+    software_tools = [
+        name
+        for name in tooluni.all_tool_dict.keys()
+        if "get_" in name and "_info" in name
+    ]
+    print(f"📦 Found {len(software_tools)} software package tools:")
+    for tool in software_tools:
+        package = tool.replace("get_", "").replace("_info", "").replace("_", "-")
+        print(f"   • {package}")
+
+    # Step 3: Define test queries for the PackageTool-based software tools
+    test_queries = [
+        # Basic tests with examples
+        {"name": "get_numpy_info", "arguments": {"include_examples": True}},
+        {"name": "get_pandas_info", "arguments": {"include_examples": True}},
+        {"name": "get_requests_info", "arguments": {"include_examples": True}},
+        {"name": "get_flask_info", "arguments": {"include_examples": True}},
+        {"name": "get_scikit_learn_info", "arguments": {"include_examples": True}},
+        {"name": "get_matplotlib_info", "arguments": {"include_examples": True}},
+        {"name": "get_pytorch_info", "arguments": {"include_examples": True}},
+        # Test without examples
+        {"name": "get_numpy_info", "arguments": {"include_examples": False}},
+        # Test different source options
+        {"name": "get_pandas_info", "arguments": {"include_examples": False}},
+        {"name": "get_requests_info", "arguments": {"include_examples": True}},
+        {"name": "get_flask_info", "arguments": {"include_examples": False}},
+    ]
+
+    print("\n" + "=" * 60)
+
+    # Step 4: Run all test queries
+    successful_tests = 0
+    failed_tests = 0
+
+    for idx, query in enumerate(test_queries):
+        try:
+            package_name = (
+                query["name"].replace("get_", "").replace("_info", "").replace("_", "-")
+            )
+            print(f"\n[{idx+1}] Testing {package_name}...")
+            print(f"    Tool: {query['name']}")
+            print(f"    Args: {query['arguments']}")
+            print("-" * 50)
+
+            result = tooluni.run(query)
+
+            # Check if the result is successful
+            if (
+                isinstance(result, dict)
+                and "error" not in result
+                and result.get("package_name")
+            ):
+                print("✅ SUCCESS")
+                successful_tests += 1
+
+                # Print key information
+                print(f"   📦 Package: {result.get('package_name', 'Unknown')}")
+                print(
+                    f"   📋 Description: {result.get('description', 'No description')}..."
+                )
+                print(f"   🔧 Import: {result.get('import_name', 'Unknown')}")
+                print(f"   📊 Category: {result.get('category', 'Unknown')}")
+                print(f"   💾 Source: {result.get('source', 'Unknown')}")
+
+                if result.get("installation"):
+                    print(f"   💻 Install: {result['installation'].get('pip', 'N/A')}")
+
+                if result.get("documentation"):
+                    print(f"   📚 Docs: {result['documentation']}")
+
+                if query["arguments"].get("include_examples", False):
+                    if result.get("usage_example"):
+                        print(f"   📝 Example: {len(result['usage_example'])} chars")
+                    if result.get("quick_start"):
+                        print(f"   🚀 Quick start: {len(result['quick_start'])} steps")
+
+            elif isinstance(result, dict) and "error" in result:
+                print("❌ FAILED")
+                print(f"   Error: {result['error']}")
+                failed_tests += 1
+
+            else:
+                print("❌ FAILED")
+                print(f"   Unexpected result type: {type(result)}")
+                failed_tests += 1
+
+        except Exception as e:
+            print("❌ FAILED")
+            print(f"   Exception: {str(e)}")
+            failed_tests += 1
+
+    # Step 5: Summary
+    print("\n" + "=" * 60)
+    print("🎯 TEST SUMMARY")
+    print(f"✅ Successful: {successful_tests}")
+    print(f"❌ Failed: {failed_tests}")
+    print(
+        f"📊 Success Rate: {successful_tests/(successful_tests+failed_tests)*100:.1f}%"
+    )
+
+    print(f"\n📋 Tested {len(software_tools)} packages:")
+    for tool in software_tools:
+        pkg = tool.replace("get_", "").replace("_info", "").replace("_", "-")
+        print(f"   • {pkg}")
+
+    print("\nℹ️  Features Tested:")
+    print("   - PackageTool implementation for popular Python packages")
+    print("   - PyPI API integration with real-time package data")
+    print("   - Local information fallback when API unavailable")
+    print("   - Different parameter combinations (include_examples, source)")
+    print("   - Installation instructions and documentation links")
+    print("   - Usage examples and quick start guides")
+
+    return successful_tests, failed_tests
+
+
+if __name__ == "__main__":
+    successful, failed = main()
+
+    if failed == 0:
+        print("\n🎉 ALL TESTS PASSED! Software tools are working perfectly.")
+    else:
+        print(f"\n⚠️  {failed} test(s) failed. Check output above for details.")
+
+    print("\n✨ Software package tools testing complete!")

tooluniverse/test/test_tool_description_optimizer.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""Minimal test for ToolDescriptionOptimizer on FDA tool"""
+
+import os
+from tooluniverse import ToolUniverse
+
+
+def main():
+    """Run minimal FDA tool tests."""
+    # Setup
+    tu = ToolUniverse()
+    tu.load_tools()
+    os.makedirs("temp_test", exist_ok=True)
+
+    # Get FDA tool
+    tool_name = "FDA_get_active_ingredient_info_by_drug_name"
+    tool_config = tu.get_tool_description(tool_name)
+
+    # Test 1: Multi-round optimization
+    result = tu.run(
+        {
+            "name": "ToolDescriptionOptimizer",
+            "arguments": {
+                "tool_config": tool_config,
+                "max_iterations": 3,
+                "satisfaction_threshold": 8.0,
+            },
+        }
+    )
+    print(
+        f"Multi-round optimization: {result['total_iterations']} rounds, score {result['final_quality_score']}/10"
+    )
+
+    # Test 2: Feedback-driven test generation
+    enhanced_config = tool_config.copy()
+    enhanced_config["_optimization_feedback"] = (
+        "Test with both brand and generic drug names"
+    )
+
+    _ = tu.run_one_function(
+        {"name": "TestCaseGenerator", "arguments": {"tool_config": enhanced_config}}
+    )
+
+    print("Feedback-driven test generation: Complete")
+    print("FDA tool optimization tests: PASSED")
+
+
+if __name__ == "__main__":
+    main()

tooluniverse/test/test_tool_finder.py

@@ -0,0 +1,26 @@
+from tooluniverse import ToolUniverse
+
+# Step 1: Initialize tool universe
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+#
+test_queries = [
+    {
+        "name": "Tool_Finder",
+        "arguments": {
+            "description": "a tool for finding tools related to diseases",
+            "limit": 10,
+            "return_call_result": False,
+        },
+    },
+    {"name": "Tool_Finder_Keyword", "arguments": {"query": "disease", "limit": 5}},
+]
+
+for idx, query in enumerate(test_queries):
+    print(
+        f"\n[{idx+1}] Running tool: {query['name']} with arguments: {query['arguments']}"
+    )
+    result = tooluni.run(query)
+    print("✅ Success. Example output snippet:")
+    print(result if isinstance(result, dict) else str(result))

tooluniverse/test/test_tool_finder_llm.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+Compatibility test for ToolFinderLLM - ensuring seamless replacement of original tool_finder.py
+
+This script tests that ToolFinderLLM has the same interface and behavior as the original
+ToolFinderEmbedding, making it a drop-in replacement.
+"""
+
+import sys
+import traceback
+
+
+def test_compatibility():
+    """Test that ToolFinderLLM matches original tool_finder interface."""
+    print("🧪 Testing ToolFinderLLM compatibility...")
+
+    try:
+        from tooluniverse.execute_function import ToolUniverse
+        from tooluniverse.tool_finder_llm import ToolFinderLLM
+
+        # Initialize ToolUniverse
+        tooluniverse = ToolUniverse()
+        tooluniverse.load_tools()
+
+        # Configure LLM tool finder
+        config = {
+            "name": "ToolFinderLLM",
+            "type": "ToolFinderLLM",
+            "configs": {
+                "api_type": "CHATGPT",
+                "model_id": "gpt-4o-1120",
+                "temperature": 0.1,
+                "max_new_tokens": 2048,
+                "return_json": True,
+            },
+        }
+
+        llm_finder = ToolFinderLLM(config, tooluniverse)
+
+        # Test 1: Basic find_tools() method
+        print("✓ Testing find_tools() method...")
+        result1 = llm_finder.find_tools(
+            message="Find tools for drug safety analysis", rag_num=3
+        )
+        assert isinstance(result1, list), f"Expected list, got {type(result1)}"
+        print(f"  Result type: {type(result1)} ✓")
+
+        # Test 2: find_tools() with return_call_result=True
+        print("✓ Testing find_tools() with return_call_result=True...")
+        result2 = llm_finder.find_tools(
+            message="Find tools for gene analysis", rag_num=2, return_call_result=True
+        )
+        assert isinstance(result2, tuple), f"Expected tuple, got {type(result2)}"
+        assert len(result2) == 2, f"Expected tuple of length 2, got {len(result2)}"
+        prompts, tool_names = result2
+        assert isinstance(
+            prompts, list
+        ), f"Expected prompts as list, got {type(prompts)}"
+        assert isinstance(
+            tool_names, list
+        ), f"Expected tool_names as list, got {type(tool_names)}"
+        print(
+            f"  Result: ({type(prompts)}, {type(tool_names)}) with {len(tool_names)} tools ✓"
+        )
+
+        # Test 3: run() method compatibility
+        print("✓ Testing run() method...")
+        arguments = {
+            "description": "Find tools for protein analysis",
+            "limit": 2,
+            "return_call_result": False,
+        }
+        result3 = llm_finder.run(arguments)
+        assert isinstance(
+            result3, list
+        ), f"Expected list from run(), got {type(result3)}"
+        print(f"  Run method result type: {type(result3)} ✓")
+
+        # Test 4: run() with return_call_result=True
+        print("✓ Testing run() with return_call_result=True...")
+        arguments_with_result = {
+            "description": "Find tools for clinical trials",
+            "limit": 2,
+            "return_call_result": True,
+        }
+        result4 = llm_finder.run(arguments_with_result)
+        assert isinstance(
+            result4, tuple
+        ), f"Expected tuple from run(), got {type(result4)}"
+        print(f"  Run method with return_call_result: {type(result4)} ✓")
+
+        # Test 5: test with picked_tool_names (original interface)
+        print("✓ Testing find_tools() with picked_tool_names...")
+        test_tools = ["EuropePMC_search_articles", "PubChem_get_CID_by_compound_name"]
+        result5 = llm_finder.find_tools(
+            picked_tool_names=test_tools, return_call_result=False
+        )
+        assert isinstance(
+            result5, list
+        ), f"Expected list with picked_tool_names, got {type(result5)}"
+        print(f"  Picked tools result type: {type(result5)} ✓")
+
+        # Test 6: test picked_tool_names with return_call_result=True
+        print(
+            "✓ Testing find_tools() with picked_tool_names and return_call_result=True..."
+        )
+        result6 = llm_finder.find_tools(
+            picked_tool_names=test_tools, return_call_result=True
+        )
+        assert isinstance(
+            result6, tuple
+        ), f"Expected tuple with picked_tool_names, got {type(result6)}"
+        prompts6, names6 = result6
+        assert isinstance(
+            prompts6, list
+        ), f"Expected prompts as list, got {type(prompts6)}"
+        assert isinstance(names6, list), f"Expected names as list, got {type(names6)}"
+        assert len(names6) <= len(
+            test_tools
+        ), f"Expected names count <= input, got {len(names6)} > {len(test_tools)}"
+        print(
+            f"  Picked tools with return_call_result: ({type(prompts6)}, {type(names6)}) ✓"
+        )
+
+        print("\n🎉 All compatibility tests passed!")
+        print("✅ ToolFinderLLM interface matches original ToolFinderEmbedding")
+        return True
+
+    except ImportError as e:
+        print(f"⚠️ ToolUniverse not available: {e}")
+        print("Skipping tests - this is expected in some environments")
+        return True
+
+    except Exception as e:
+        print(f"❌ Compatibility test failed: {e}")
+        traceback.print_exc()
+        return False
+
+
+def test_error_handling():
+    """Test error handling and edge cases."""
+    print("\n🧪 Testing error handling...")
+
+    try:
+        from tooluniverse.execute_function import ToolUniverse
+        from tooluniverse.tool_finder_llm import ToolFinderLLM
+
+        # Initialize ToolUniverse
+        tooluniverse = ToolUniverse()
+        tooluniverse.load_tools()
+
+        config = {
+            "name": "ToolFinderLLM",
+            "type": "ToolFinderLLM",
+            "configs": {
+                "api_type": "CHATGPT",
+                "model_id": "gpt-4o-1120",
+                "temperature": 0.1,
+                "max_new_tokens": 2048,
+                "return_json": True,
+            },
+        }
+
+        llm_finder = ToolFinderLLM(config, tooluniverse)
+
+        # Test with invalid arguments
+        print("✓ Testing error handling with None arguments...")
+        try:
+            # This should raise an assertion error
+            result = llm_finder.find_tools(message=None, picked_tool_names=None)
+            print(f"  ❌ Expected AssertionError but got result: {type(result)}")
+            return False
+        except AssertionError:
+            print("  ✓ AssertionError raised as expected")
+
+        # Test with empty picked_tool_names
+        print("✓ Testing with empty picked_tool_names...")
+        result = llm_finder.find_tools(picked_tool_names=[], return_call_result=False)
+        assert isinstance(
+            result, list
+        ), f"Expected list with empty picked_tool_names, got {type(result)}"
+        assert len(result) == 0, f"Expected empty result, got {len(result)} items"
+        print("  ✓ Empty picked_tool_names handled correctly")
+
+        # Test run() with missing required arguments
+        print("✓ Testing run() with empty arguments...")
+        try:
+            result = llm_finder.run({})
+            print(f"  ❌ Expected AssertionError but got result: {type(result)}")
+            return False
+        except AssertionError:
+            print("  ✓ AssertionError raised as expected for empty arguments")
+
+        print("✅ Error handling tests passed!")
+        return True
+
+    except ImportError as e:
+        print(f"⚠️ ToolUniverse not available: {e}")
+        return True
+
+    except Exception as e:
+        print(f"❌ Error handling test failed: {e}")
+        traceback.print_exc()
+        return False
+
+
+def main():
+    """Run compatibility tests to ensure seamless replacement of original tool_finder."""
+    print("🚀 ToolFinderLLM Compatibility Tests")
+    print("=" * 60)
+
+    tests = [
+        ("Interface Compatibility", test_compatibility),
+        ("Error Handling", test_error_handling),
+    ]
+
+    results = []
+    for test_name, test_func in tests:
+        try:
+            success = test_func()
+            results.append((test_name, success))
+        except Exception as e:
+            print(f"❌ {test_name} crashed: {e}")
+            results.append((test_name, False))
+
+    print("\n" + "=" * 60)
+    print("📊 Test Results Summary:")
+    print("=" * 60)
+
+    passed = 0
+    for test_name, success in results:
+        status = "✅ PASS" if success else "❌ FAIL"
+        print(f"{status} | {test_name}")
+        if success:
+            passed += 1
+
+    print(f"\n🏁 Tests completed: {passed}/{len(results)} passed")
+
+    if passed == len(results):
+        print("🎉 All compatibility tests passed!")
+        print(
+            "✅ ToolFinderLLM can seamlessly replace the original ToolFinderEmbedding"
+        )
+        return 0
+    else:
+        print("⚠️  Some compatibility tests failed.")
+        print("❌ Interface modifications needed before replacement")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tooluniverse/test/test_tools_find.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Simplified SMCP tools/find test script
+
+Test the new search_method parameter functionality:
+- 'auto': Automatically select the best search method
+- 'llm': Use LLM intelligent search
+- 'embedding': Use embedding vector search
+- 'keyword': Use keyword search
+"""
+
+import json
+import asyncio
+import sys
+import os
+
+# Add the src directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+
+def print_test(title):
+    """Print test title"""
+    print(f"\n🔍 {title}")
+    print("=" * 50)
+
+
+def print_result(result):
+    """Print results"""
+    if isinstance(result, dict):
+        # Only show key information
+        if "result" in result:
+            data = result["result"]
+            query = data.get("query", "unknown")
+            method = data.get("search_method", "unknown")
+            count = data.get("total_matches", 0)
+            print(f"✅ Query: '{query}' | Method: {method} | Results: {count}")
+
+            # Show found tool names
+            if "tools" in data and data["tools"]:
+                print("📋 Found tools:")
+                for i, tool in enumerate(data["tools"][:3], 1):  # Only show first 3
+                    print(f"  {i}. {tool.get('name', 'Unknown')}")
+            else:
+                print("❌ No tools found")
+        elif "error" in result:
+            print(f"❌ Error: {result['error']['message']}")
+    else:
+        print(f"Result: {result}")
+
+
+from tooluniverse.smcp import SMCP  # noqa: E402
+
+
+async def test_search_methods():
+    """Test different search methods"""
+    print("🚀 Starting SMCP search functionality tests...")
+
+    # Initialize server
+    print("\n📦 Initializing SMCP server...")
+    server = SMCP(name="Test Server", search_enabled=True)
+    print(f"✅ Server initialized, loaded {len(server._exposed_tools)} tools")
+
+    # Test query
+    query = "protein analysis"
+
+    # Test 1: Auto search method
+    print_test("Test 1: Auto search (search_method='auto')")
+    request = {
+        "jsonrpc": "2.0",
+        "id": "test_auto",
+        "method": "tools/find",
+        "params": {"query": query, "search_method": "auto", "limit": 3},
+    }
+    result = await server._custom_handle_request(request)
+    print_result(result)
+
+    # Test 2: LLM search method
+    print_test("Test 2: LLM intelligent search (search_method='llm')")
+    request = {
+        "jsonrpc": "2.0",
+        "id": "test_llm",
+        "method": "tools/find",
+        "params": {"query": query, "search_method": "llm", "limit": 3},
+    }
+    result = await server._custom_handle_request(request)
+    print_result(result)
+
+    # Test 3: Keyword search method
+    print_test("Test 3: Keyword search (search_method='keyword')")
+    request = {
+        "jsonrpc": "2.0",
+        "id": "test_keyword",
+        "method": "tools/find",
+        "params": {"query": "tool", "search_method": "keyword", "limit": 3},
+    }
+    result = await server._custom_handle_request(request)
+    print_result(result)
+
+    # Test 4: Embedding vector search method
+    print_test("Test 4: Embedding vector search (search_method='embedding')")
+    request = {
+        "jsonrpc": "2.0",
+        "id": "test_embedding",
+        "method": "tools/find",
+        "params": {"query": query, "search_method": "embedding", "limit": 3},
+    }
+    result = await server._custom_handle_request(request)
+    print_result(result)
+
+    # Test 5: Error handling - invalid search method
+    print_test("Test 5: Invalid search method (should fallback)")
+    request = {
+        "jsonrpc": "2.0",
+        "id": "test_invalid",
+        "method": "tools/find",
+        "params": {"query": query, "search_method": "invalid_method", "limit": 3},
+    }
+    result = await server._custom_handle_request(request)
+    print_result(result)
+
+    # Test 6: Error handling - missing required parameter
+    print_test("Test 6: Missing query parameter (should error)")
+    request = {
+        "jsonrpc": "2.0",
+        "id": "test_error",
+        "method": "tools/find",
+        "params": {"search_method": "auto", "limit": 3},  # Missing query
+    }
+    result = await server._custom_handle_request(request)
+    print_result(result)
+
+    print("\n✅ All tests completed!")
+    await server.close()
+
+
+def show_examples():
+    """Show request examples"""
+    print("\n📄 MCP Request Examples:")
+
+    examples = [
+        {
+            "name": "Auto Search",
+            "request": {
+                "jsonrpc": "2.0",
+                "id": "1",
+                "method": "tools/find",
+                "params": {
+                    "query": "protein analysis",
+                    "search_method": "auto",
+                    "limit": 5,
+                },
+            },
+        },
+        {
+            "name": "LLM Search",
+            "request": {
+                "jsonrpc": "2.0",
+                "id": "2",
+                "method": "tools/find",
+                "params": {
+                    "query": "gene expression",
+                    "search_method": "llm",
+                    "limit": 3,
+                },
+            },
+        },
+        {
+            "name": "Keyword Search",
+            "request": {
+                "jsonrpc": "2.0",
+                "id": "3",
+                "method": "tools/find",
+                "params": {"query": "chemical", "search_method": "keyword", "limit": 3},
+            },
+        },
+    ]
+
+    for example in examples:
+        print(f"\n{example['name']}:")
+        print(json.dumps(example["request"], indent=2, ensure_ascii=False))
+
+
+async def main():
+    """Main test function"""
+    print("🧪 Starting SMCP search method functionality tests...")
+
+    # Show examples
+    show_examples()
+
+    # Run tests
+    await test_search_methods()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())