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

tooluniverse/test/test_idmap_tools.py

@@ -0,0 +1,61 @@
+"""
+Concise Test Script - OpenTargets ID Mapping Tools
+Test three main ID mapping tools:
+1. Get disease IDs by name
+2. Get cross-reference IDs by EFO ID
+3. Bidirectional mapping between external IDs and diseases
+"""
+
+from tooluniverse import ToolUniverse
+
+
+def main():
+    # Initialize tools
+    print("🔧 Initializing ToolUniverse...")
+    tooluni = ToolUniverse()
+    tooluni.load_tools()
+    print("✅ Tools loaded successfully\n")
+
+    # Test cases
+    test_cases = [
+        {
+            "name": "OpenTargets_get_disease_ids_by_name",
+            "arguments": {"name": "neuroblastoma"},
+            "description": "Get disease IDs by name",
+        },
+        {
+            "name": "OpenTargets_get_disease_ids_by_efoId",
+            "arguments": {"efoId": "EFO_0000621"},
+            "description": "Get cross-references by EFO ID",
+        },
+        {
+            "name": "OpenTargets_map_any_disease_id_to_all_other_ids",
+            "arguments": {"inputId": "EFO_0000621"},
+            "description": "Map disease ID to all other IDs",
+        },
+    ]
+
+    # Run tests
+    print("🧪 Starting ID Mapping tools tests:\n")
+
+    for i, test in enumerate(test_cases, 1):
+        print(f"[{i}] {test['description']}")
+        print(f"    Tool: {test['name']}")
+        print(f"    Arguments: {test['arguments']}")
+
+        try:
+            result = tooluni.run(test)
+            if result:
+                print("    ✅ Success")
+                print(f"    📊 Result: {str(result)}")
+            else:
+                print("    ⚠️  No data returned")
+        except Exception as e:
+            print(f"    ❌ Failed: {str(e)}")
+        print()
+
+    print("🎉 Testing completed!")
+
+
+if __name__ == "__main__":
+    main()

tooluniverse/test/test_mcp_server.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Test script: Verify that the generated FastMCP server is working properly
+
+This script will start the MCP server and send some test requests
+"""
+
+import asyncio
+import aiohttp
+import sys
+import subprocess
+from pathlib import Path
+
+# Test MCP server URL
+MCP_SERVER_URL = "http://127.0.0.1:8000"
+
+
+async def test_mcp_server():
+    """Test basic functionality of MCP server"""
+
+    print("🚀 Starting FastMCP server test...")
+
+    # Wait for server to start
+    print("⏳ Waiting for server to start...")
+    await asyncio.sleep(3)
+
+    async with aiohttp.ClientSession() as session:
+        # Test 1: Get tool list
+        print("\n📋 Test 1: Get available tool list")
+        tools_request = {
+            "jsonrpc": "2.0",
+            "id": "test-1",
+            "method": "tools/list",
+            "params": {},
+        }
+
+        try:
+            async with session.post(
+                f"{MCP_SERVER_URL}/mcp/",
+                json=tools_request,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    tools = result.get("result", {}).get("tools", [])
+                    print(
+                        f"✅ Successfully retrieved tool list, {len(tools)} tools in total"
+                    )
+
+                    # Show first few tools
+                    for _i, tool in enumerate(tools[:3]):
+                        print(
+                            f"   - {tool.get('name', 'unknown')}: {tool.get('description', 'no description')[:80]}..."
+                        )
+
+                    if len(tools) > 3:
+                        print(f"   ... and {len(tools) - 3} more tools")
+
+                else:
+                    print(f"❌ Failed to get tool list, status code: {response.status}")
+                    print(f"Response: {await response.text()}")
+                    return False
+
+        except Exception as e:
+            print(f"❌ Failed to connect to server: {e}")
+            return False
+
+        # Test 2: Call a simple tool
+        print("\n🔧 Test 2: Call a tool function")
+        tool_request = {
+            "jsonrpc": "2.0",
+            "id": "test-2",
+            "method": "tools/call",
+            "params": {
+                "name": "get_phenotype_by_HPO_ID",
+                "arguments": {"id": "HP:0000001"},  # Test HPO ID
+            },
+        }
+
+        try:
+            async with session.post(
+                f"{MCP_SERVER_URL}/mcp/",
+                json=tool_request,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    if "error" in result:
+                        print(f"⚠️  Tool execution returned error: {result['error']}")
+                    else:
+                        print("✅ Tool call successful")
+                        print(
+                            f"   Return result type: {type(result.get('result', {}))}"
+                        )
+                else:
+                    print(f"❌ Tool call failed, status code: {response.status}")
+                    print(f"Response: {await response.text()}")
+
+        except Exception as e:
+            print(f"❌ Tool call exception: {e}")
+
+        # Test 3: Call FDA tool
+        print("\n💊 Test 3: Call FDA drug query tool")
+        fda_request = {
+            "jsonrpc": "2.0",
+            "id": "test-3",
+            "method": "tools/call",
+            "params": {
+                "name": "FDA_get_active_ingredient_info_by_drug_name",
+                "arguments": {"drug_name": "aspirin", "limit": 5, "skip": 0},
+            },
+        }
+
+        try:
+            async with session.post(
+                f"{MCP_SERVER_URL}/mcp/",
+                json=fda_request,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    if "error" in result:
+                        print(
+                            f"⚠️  FDA tool execution returned error: {result['error']}"
+                        )
+                    else:
+                        print("✅ FDA tool call successful")
+                        print(
+                            f"   Return result type: {type(result.get('result', {}))}"
+                        )
+                else:
+                    print(f"❌ FDA tool call failed, status code: {response.status}")
+
+        except Exception as e:
+            print(f"❌ FDA tool call exception: {e}")
+
+    print("\n🎉 Test completed!")
+    return True
+
+
+def start_mcp_server():
+    """Start MCP server"""
+    print("🚀 Starting MCP server...")
+
+    # Modify the generated file, add correct startup code
+    server_file = Path(__file__).parent / "mcp_server_test.py"
+
+    server_code = """#!/usr/bin/env python3
+# Import generated MCP wrapper
+import sys
+import os
+sys.path.append(os.path.dirname(__file__))
+
+# Read generated code and execute
+with open("mcp_wrappers_generated.txt", "r") as f:
+    generated_code = f.read()
+
+# Execute generated code
+exec(generated_code)
+
+# Start server
+if __name__ == "__main__":
+    print("🚀 Starting ToolUniverse MCP server...")
+    print(f"Server address: http://127.0.0.1:8000")
+    print("Press Ctrl+C to stop server")
+    run_server()
+"""
+
+    with open(server_file, "w") as f:
+        f.write(server_code)
+
+    # Start server process
+    return subprocess.Popen(
+        [sys.executable, str(server_file)],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+
+async def main():
+    """Main function"""
+    print("🧪 FastMCP Server Test Tool")
+    print("=" * 50)
+
+    # Start server
+    server_process = start_mcp_server()
+
+    try:
+        # Run tests
+        success = await test_mcp_server()
+
+        if success:
+            print("\n✅ All tests passed! MCP server is working properly.")
+        else:
+            print("\n❌ Some tests failed, please check server configuration.")
+
+    except KeyboardInterrupt:
+        print("\n⏹️  Test interrupted by user")
+    finally:
+        # Cleanup: terminate server process
+        print("\n🧹 Cleanup: closing server...")
+        server_process.terminate()
+        try:
+            server_process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            server_process.kill()
+        print("✅ Server closed")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tooluniverse/test/test_mcp_tool.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+"""
+Test file for MCP Tools in ToolUniverse
+
+This file tests the MCP (Model Context Protocol) integration functionality,
+including MCPClientTool and MCPAutoLoaderTool.
+
+Usage:
+    python test_mcp_tool.py
+"""
+
+from tooluniverse import ToolUniverse
+from typing import Any, Dict, List
+import time
+import json
+
+# Step 1: Initialize tool universe
+print("🔧 Initializing ToolUniverse...")
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+print("✅ ToolUniverse initialized successfully")
+print(f"📊 Total tools loaded: {len(tooluni.all_tool_dict)}")
+
+# Step 2: Check if MCP tools are available
+mcp_tools = [
+    name for name in list(tooluni.all_tool_dict.keys()) if "mcp" in name.lower()
+]
+print(f"🔍 Found {len(mcp_tools)} MCP-related tools: {mcp_tools}")
+
+# Step 3: Define test queries for MCP tools
+test_queries: List[Dict[str, Any]] = [
+    # Test mock MCP tools (these should work without requiring external servers)
+    # {
+    #     "name": "mcp_mock_calculator",
+    #     "arguments": {
+    #         "operation": "add",
+    #         "a": 10,
+    #         "b": 5
+    #     }
+    # },
+    # {
+    #     "name": "mcp_mock_greeter",
+    #     "arguments": {
+    #         "name": "ToolUniverse User"
+    #     }
+    # },
+    # Test auto-discovered MCP tools from server 1
+    # {
+    #     "name": "mcp_s1_calculate",
+    #     "arguments": {
+    #         "expression": "2 + 3 * 4"
+    #     }
+    # },
+    # {
+    #     "name": "mcp_s1_get_weather",
+    #     "arguments": {
+    #         "city": "New York",
+    #         "units": "celsius"
+    #     }
+    # },
+    # Test MCP client tool (if available)
+    # {
+    #     "name": "mcp_client_example",
+    #     "arguments": {
+    #         "operation": "list_tools"
+    #     }
+    # },
+    # Test MCPAutoLoaderTool - Discover tools (will show connection errors if servers not running)
+    # {
+    #     "name": "mcp_auto_loader_server1",
+    #     "arguments": {
+    #         "operation": "discover"
+    #     }
+    # },
+    # {
+    #     "name": "mcp_mock_greeter",
+    #     "arguments": {
+    #         "name": "ToolUniverse User"
+    #     }
+    # },
+    # # Test MCP client tool (if available)
+    # {
+    #     "name": "mcp_client_example",
+    #     "arguments": {
+    #         "operation": "list_tools"
+    #     }
+    # },
+    # # Test MCPAutoLoaderTool - Discover tools (will show connection errors if servers not running)
+    # {
+    #     "name": "mcp_auto_loader_server1",
+    #     "arguments": {
+    #         "operation": "discover"
+    #     }
+    # },
+    # Test MCP client with simple operations
+    # {
+    #     "name": "mcp_client_example",
+    #     "arguments": {
+    #         "operation": "call_tool",
+    #         "tool_name": "get_weather",
+    #         "tool_arguments": {
+    #             "city": "New York",
+    #             "units": "celsius"
+    #         }
+    #     }
+    # },
+    # # Test calculator operation
+    # {
+    #     "name": "mcp_client_example",
+    #     "arguments": {
+    #         "operation": "call_tool",
+    #         "tool_name": "calculate",
+    #         "tool_arguments": {
+    #             "expression": "10 * 5 + 2"
+    #         }
+    #     }
+    # },
+    # # Test Official SDK server (if running)
+    # {
+    #     "name": "mcp_auto_loader_official_sdk",
+    #     "arguments": {
+    #         "operation": "discover"
+    #     }
+    # },
+    # # Test file listing operation
+    # {
+    #     "name": "mcp_client_example",
+    #     "arguments": {
+    #         "operation": "call_tool",
+    #         "tool_name": "list_files",
+    #         "tool_arguments": {
+    #             "directory": ".",
+    #             "pattern": "*.py"
+    #         }
+    #     }
+    # }
+    # Test US Patent and Trademark Office (USPTO) tools (if uspto_downloader_MCP.py is running)
+    {
+        "name": "mcp_download_abst",
+        "arguments": {"query": {"applicationNumberText": "19053071"}},
+    },
+    {
+        "name": "mcp_download_claims",
+        "arguments": {"query": {"applicationNumberText": "19053071"}},
+    },
+    # {
+    #     "name": "mcp_download_full_text",
+    #     "arguments": {
+    #         "query": {"applicationNumberText": "19053071"}
+    #     }
+    # },
+    {
+        "name": "mcp_download_full_text",
+        "arguments": {
+            "query": {
+                "applicationNumberText": "18837017"
+            }  # This one should not have a full text document
+        },
+    },
+    # # Test Boltz2 tool (if boltz_mcp_server.py is running)
+    # {
+    #     "name": "mcp_run_boltz2",
+    #     "arguments": {
+    #         "query": {
+    #             "protein_sequence": "MLSRLFRMHGLFVASHPWEVIVGTVTLTICMMSMNMFTGNNKICGWNYECPKFEEDVLSSDIIILTITRCIAILYIYFQFQNLRQLGSKYILGIAGLFTIFSSFVFSTVVIHFLDKELTGLNEALPFFLLLIDLSRASTLAKFALSSNSQDEVRENIARGMAILGPTFTLDALVECLVIGVGTMSGVRQLEIMCCFGCMSVLANYFVFMTFFPACVSLVLELSRESREGRPIWQLSHFARVLEEEENKPNPVTQRVKMIMSLGLVLVHAHSRWIADPSPQNSTADTSKVSLGLDENVSKRIEPSVSLWQFYLSKMISMDIEQVITLSLALLLAVKYIFFEQTETESTLSLKNPITSPVVTQKKVPDNCCRREPMLVRNNQKCDSVEEETGINRERKVEVIKPLVAETDTPNRATFVVGNSSLLDTSSVLVTQEPEIELPREPRPNEECLQILGNAEKGAKFLSDAEIIQLVNAKHIPAYKLETLMETHERGVSIRRQLLSKKLSEPSSLQYLPYRDYNYSLVMGACCENVIGYMPIPVGVAGPLCLDEKEFQVPMATTEGCLVASTNRGCRAIGLGGGASSRVLADGMTRGPVVRLPRACDSAEVKAWLETSEGFAVIKEAFDSTSRFARLQKLHTSIAGRNLYIRFQSRSGDAMGMNMISKGTEKALSKLHEYFPEMQILAVSGNYCTDKKPAAINWIEGRGKSVVCEAVIPAKVVREVLKTTTEAMIEVNINKNLVGSAMAGSIGGYNAHAANIVTAIYIACGQDAAQNVGSSNCITLMEASGPTNEDLYISCTMPSIEIGTVGGGTNLLPQQACLQMLGVQGACKDNPGENARQLARIVCGTVMAGELSLMAALAAGHLVKSHMIHNRSKINLQDLQGACTKKTA",
+    #             "ligands": [
+    #                 {"id": "L1", "smiles": "CC[C@H](C)C(=O)O[C@H]1C[C@@H](C=C2[C@H]1[C@H]([C@H](C=C2)C)CC[C@H](C[C@H](CC(=O)O)O)O)O"},
+    #             ],
+    #             "use_potentials": True,
+    #             "diffusion_samples": 1,
+    #             "return_structure": False
+    #         }
+    #     }
+    # }
+]
+
+# Step 4: Run test queries with error handling
+print(f"\n🧪 Running {len(test_queries)} MCP tool tests...")
+print("=" * 60)
+
+successful_tests = 0
+failed_tests = 0
+
+for idx, query in enumerate(test_queries):
+    print(f"\n[Test {idx+1}/{len(test_queries)}] {query['name']}")
+    print(f"Operation: {query['arguments'].get('operation', 'N/A')}")
+
+    if "tool_name" in query["arguments"]:
+        print(f"Tool: {query['arguments']['tool_name']}")
+
+    try:
+        # Add timeout to prevent hanging
+        start_time = time.time()
+        result = tooluni.run(query)
+        execution_time = time.time() - start_time
+
+        print(f"✅ Success in {execution_time:.2f}s")
+
+        # Format output nicely
+        if isinstance(result, dict):
+            if "error" in result:
+                print(f"⚠️  Tool returned error: {result['error']}")
+            else:
+                # Show a snippet of the result
+                result_str = json.dumps(result, indent=2)
+                print(f"📊 Result: {result_str}")
+        else:
+            result_str = str(result)
+            print(f"📊 Result: {result_str}")
+
+        if "error" not in result:
+            successful_tests += 1
+        else:
+            failed_tests += 1
+            print(f"❌ Test failed with error: {result['error']}")
+
+    except Exception as e:
+        print(f"❌ Failed: {str(e)}")
+        failed_tests += 1
+
+    # Small delay between tests
+    time.sleep(0.5)
+
+# Step 5: Test Summary
+print("\n" + "=" * 60)
+print("🎯 MCP Tool Test Summary")
+print("=" * 60)
+print(f"✅ Successful tests: {successful_tests}")
+print(f"❌ Failed tests: {failed_tests}")
+print(
+    f"📊 Success rate: {(successful_tests/(successful_tests + failed_tests)*100):.1f}%"
+)
+
+# if failed_tests > 0:
+#     print("\n💡 Tips for failed tests:")
+#     print("- Make sure MCP servers are running (e.g., python fastmcp_official_example.py)")
+#     print("- Check server URLs and ports in mcp_client_tools.json")
+#     print("- Verify network connectivity to MCP servers")
+#     print("- Some tools may require specific arguments or server capabilities")
+
+# print("\n🔧 Available MCP tools in ToolUniverse:")
+# for tool_name in mcp_tools:
+#     tool_config = tooluni.all_tool_dict.get(tool_name, {})
+#     print(f"  - {tool_name}: {tool_config.get('description', 'No description')}")
+
+print("\n✨ MCP integration test completed!")