tooluniverse 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

tooluniverse/test/test_software_tools.py

@@ -1,147 +0,0 @@
-"""
-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_stdio_hooks.py

@@ -1,285 +0,0 @@
-#!/usr/bin/env python3
-"""
-测试 MCP stdio 模式下关闭和开启 hooks 的情况
-"""
-import subprocess
-import json
-import time
-import sys
-
-
-def run_stdio_test(hooks_enabled=False):
-    """运行 stdio 测试"""
-    print(f"\n{'='*60}")
-    print(f"测试模式: {'开启 hooks' if hooks_enabled else '关闭 hooks'}")
-    print(f"{'='*60}")
-
-    # 构建命令
-    cmd = [
-        sys.executable,
-        "-c",
-        f"""
-import sys
-sys.path.insert(0, 'src')
-from tooluniverse.smcp_server import run_stdio_server
-sys.argv = ['tooluniverse-stdio'] + (['--hooks'] if {hooks_enabled} else [])
-run_stdio_server()
-""",
-    ]
-
-    print(f"启动命令: {' '.join(cmd[:3])} ...")
-
-    # 启动服务器进程
-    process = subprocess.Popen(
-        cmd,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        bufsize=0,
-    )
-
-    try:
-        # 等待服务器启动并读取启动日志
-        time.sleep(3)
-
-        # 读取并丢弃启动日志
-        print("读取启动日志...")
-        while True:
-            line = process.stdout.readline()
-            if not line:
-                break
-            print(f"启动日志: {line.strip()}")
-            if "Starting ToolUniverse SMCP Server" in line:
-                break
-
-        # 发送初始化请求
-        init_request = {
-            "jsonrpc": "2.0",
-            "id": 1,
-            "method": "initialize",
-            "params": {
-                "protocolVersion": "2024-11-05",
-                "capabilities": {},
-                "clientInfo": {"name": "test-client", "version": "1.0.0"},
-            },
-        }
-
-        print("发送初始化请求...")
-        process.stdin.write(json.dumps(init_request) + "\n")
-        process.stdin.flush()
-
-        # 读取初始化响应
-        init_response = process.stdout.readline()
-        print(f"初始化响应: {init_response.strip()}")
-
-        # 发送 tools/list 请求
-        list_request = {"jsonrpc": "2.0", "id": 2, "method": "tools/list"}
-
-        print("发送 tools/list 请求...")
-        process.stdin.write(json.dumps(list_request) + "\n")
-        process.stdin.flush()
-
-        # 读取 tools/list 响应
-        list_response = process.stdout.readline()
-        print(f"tools/list 响应长度: {len(list_response)} 字符")
-
-        # 发送测试工具调用请求
-        test_request = {
-            "jsonrpc": "2.0",
-            "id": 3,
-            "method": "tools/call",
-            "params": {
-                "name": "OpenTargets_get_target_gene_ontology_by_ensemblID",
-                "arguments": {"ensemblId": "ENSG00000012048"},
-            },
-        }
-
-        print("发送测试工具调用请求...")
-        process.stdin.write(json.dumps(test_request) + "\n")
-        process.stdin.flush()
-
-        # 读取工具调用响应（可能需要等待更长时间）
-        print("等待工具调用响应...")
-        start_time = time.time()
-
-        # 读取多行响应，直到找到 JSON 响应
-        tool_response = ""
-        timeout = 30  # 30秒超时
-        while time.time() - start_time < timeout:
-            line = process.stdout.readline()
-            if not line:
-                time.sleep(0.1)
-                continue
-
-            tool_response += line
-            print(f"收到响应行: {repr(line)}")
-
-            # 检查是否是 JSON 响应
-            try:
-                json.loads(line.strip())
-                break
-            except json.JSONDecodeError:
-                continue
-
-        end_time = time.time()
-        response_time = end_time - start_time
-        response_length = len(tool_response)
-
-        print(f"工具调用响应时间: {response_time:.2f} 秒")
-        print(f"工具调用响应长度: {response_length} 字符")
-        print(f"原始响应内容: {repr(tool_response)}")
-
-        # 尝试解析 JSON 响应
-        json_response = None
-        for line in tool_response.split("\n"):
-            if line.strip().startswith('{"jsonrpc"'):
-                try:
-                    json_response = json.loads(line.strip())
-                    break
-                except json.JSONDecodeError:
-                    continue
-
-        if json_response:
-            print("✅ 成功解析 JSON 响应")
-            print(f"响应 ID: {json_response.get('id')}")
-            if "result" in json_response:
-                print("✅ 工具调用成功")
-            elif "error" in json_response:
-                print(f"❌ 工具调用失败: {json_response['error']}")
-        else:
-            print("⚠️ 未找到有效的 JSON 响应")
-
-        # 继续等待实际的工具调用响应
-        print("等待工具调用完成...")
-        time.sleep(5)  # 等待工具执行完成
-
-        # 读取工具调用的实际响应
-        actual_response = ""
-        while True:
-            line = process.stdout.readline()
-            if not line:
-                break
-            actual_response += line
-            print(f"工具响应行: {repr(line)}")
-
-            # 检查是否是 JSON 响应
-            try:
-                json.loads(line.strip())
-                break
-            except json.JSONDecodeError:
-                continue
-
-        if actual_response:
-            print(f"工具调用实际响应长度: {len(actual_response)} 字符")
-
-            # 尝试解析工具调用响应
-            tool_json_response = None
-            for line in actual_response.split("\n"):
-                if line.strip().startswith('{"jsonrpc"'):
-                    try:
-                        tool_json_response = json.loads(line.strip())
-                        break
-                    except json.JSONDecodeError:
-                        continue
-
-            if tool_json_response and "result" in tool_json_response:
-                result_content = tool_json_response["result"]
-                if "content" in result_content:
-                    content_text = str(result_content["content"])
-                    content_length = len(content_text)
-                    print(f"工具响应内容长度: {content_length} 字符")
-
-                    # 检查是否是摘要
-                    if "summary" in content_text.lower() or "摘要" in content_text:
-                        print("✅ 检测到摘要内容")
-                    else:
-                        print("📄 原始内容（未摘要）")
-                else:
-                    print("⚠️ 工具响应中没有 content 字段")
-            else:
-                print("⚠️ 无法解析工具调用响应")
-
-        return {
-            "hooks_enabled": hooks_enabled,
-            "response_time": response_time,
-            "response_length": response_length,
-            "success": True,
-        }
-
-    except Exception as e:
-        print(f"❌ 测试失败: {e}")
-        return {
-            "hooks_enabled": hooks_enabled,
-            "response_time": None,
-            "response_length": None,
-            "success": False,
-            "error": str(e),
-        }
-    finally:
-        # 清理进程
-        try:
-            process.terminate()
-            process.wait(timeout=5)
-        except Exception:
-            process.kill()
-
-
-def main():
-    """主函数"""
-    print("MCP stdio 模式 hooks 测试")
-    print("测试工具: OpenTargets_get_target_gene_ontology_by_ensemblID")
-    print("测试参数: ensemblId=ENSG00000012048")
-
-    # 测试关闭 hooks
-    result_no_hooks = run_stdio_test(hooks_enabled=False)
-
-    # 测试开启 hooks
-    result_with_hooks = run_stdio_test(hooks_enabled=True)
-
-    # 对比结果
-    print(f"\n{'='*60}")
-    print("测试结果对比")
-    print(f"{'='*60}")
-
-    print("关闭 hooks:")
-    if result_no_hooks["success"]:
-        print(
-            f"  ✅ 成功 - 响应时间: {result_no_hooks['response_time']:.2f}s, 长度: {result_no_hooks['response_length']} 字符"
-        )
-    else:
-        print(f"  ❌ 失败 - {result_no_hooks.get('error', '未知错误')}")
-
-    print("开启 hooks:")
-    if result_with_hooks["success"]:
-        print(
-            f"  ✅ 成功 - 响应时间: {result_with_hooks['response_time']:.2f}s, 长度: {result_with_hooks['response_length']} 字符"
-        )
-    else:
-        print(f"  ❌ 失败 - {result_with_hooks.get('error', '未知错误')}")
-
-    # 性能对比
-    if result_no_hooks["success"] and result_with_hooks["success"]:
-        time_diff = (
-            result_with_hooks["response_time"] - result_no_hooks["response_time"]
-        )
-        length_diff = (
-            result_with_hooks["response_length"] - result_no_hooks["response_length"]
-        )
-
-        print("\n性能对比:")
-        print(
-            f"  时间差异: {time_diff:+.2f}s ({'hooks 更慢' if time_diff > 0 else 'hooks 更快'})"
-        )
-        print(
-            f"  长度差异: {length_diff:+d} 字符 ({'hooks 更长' if length_diff > 0 else 'hooks 更短'})"
-        )
-
-        if abs(time_diff) < 1.0:
-            print("  ✅ 时间差异在可接受范围内")
-        else:
-            print("  ⚠️ 时间差异较大，需要进一步优化")
-
-
-if __name__ == "__main__":
-    main()

tooluniverse/test/test_tool_description_optimizer.py

@@ -1,49 +0,0 @@
-#!/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

@@ -1,26 +0,0 @@
-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": {"description": "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))