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

tooluniverse/test/test_medlineplus.py

@@ -0,0 +1,220 @@
+# test_medlineplus.py
+
+from tooluniverse import ToolUniverse
+import json
+
+# Step 1: Initialize ToolUniverse and load all tools (including MedlinePlus tools)
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Step 2: Define example inputs
+VALID_TERM_EN = "diabetes"  # English health topic keyword
+VALID_DB_EN = "healthTopics"  # English health topics database
+VALID_TERM_ES = "diabetes"  # Spanish health topic keyword
+VALID_DB_ES = "healthTopicsSpanish"  # Spanish health topics database
+
+# ICD-10 CM examples
+VALID_CS_ICD10 = "2.16.840.1.113883.6.90"
+VALID_CODE_ICD10 = "E11.9"  # Diabetes without complications
+
+# RXCUI examples
+VALID_CS_RXCUI = "2.16.840.1.113883.6.88"
+VALID_CODE_RXCUI = "637188"  # RXCUI for Chantix
+VALID_DN_RXCUI = "Chantix 0.5 MG Oral Tablet"
+
+# Genetics examples
+VALID_CONDITION = "alzheimer-disease"  # Genetic condition URL slug
+VALID_GENE = "BRCA1"  # Gene URL slug
+
+# Invalid examples
+INVALID_TERM = ""  # Empty keyword
+INVALID_CS = "INVALID_CS"  # Invalid code system
+INVALID_CODE = "INVALID_CODE"  # Invalid code value
+
+
+def print_result(result, tool_name):
+    """Print formatted results"""
+    if isinstance(result, dict):
+        if "error" in result:
+            print("⚠️ Error:", result["error"])
+            if "detail" in result:
+                print("Detail:", result["detail"])
+            return
+
+        # Define output formats
+        formats = {
+            "MedlinePlus_search_topics_by_keyword": {
+                "title": "📚 Health Topic Search Results",
+                "items": "topics",
+                "fields": {
+                    "title": "Title",
+                    "meta_desc": "Description",
+                    "url": "Link",
+                    "language": "Language",
+                    "rank": "Rank",
+                    "also_called": "Also Known As",
+                    "summary": "Detailed Summary",
+                    "groups": "Categories",
+                },
+            },
+            "MedlinePlus_connect_lookup_by_code": {
+                "title": "🔍 Code Lookup Results",
+                "items": "responses",
+                "fields": {"title": "Title", "summary": "Summary", "url": "Link"},
+            },
+            "MedlinePlus_get_genetics_condition_by_name": {
+                "title": "🧬 Genetic Condition Information",
+                "fields": {
+                    "name": "Condition Name",
+                    "description": "Description",
+                    "genes": "Related Genes",
+                    "synonyms": "Synonyms",
+                    "ghr_page": "Detailed Information Page",
+                },
+            },
+            "MedlinePlus_get_genetics_gene_by_name": {
+                "title": "🧬 Gene Information",
+                "fields": {
+                    "name": "Gene Name",
+                    "function": "Function Description",
+                    "health_conditions": "Related Health Conditions",
+                    "synonyms": "Synonyms",
+                    "ghr_page": "Detailed Information Page",
+                },
+            },
+            "MedlinePlus_get_genetics_index": {
+                "title": "📋 Genetics Topics List",
+                "items": "topics",
+                "fields": {"name": "Name", "url": "Link"},
+            },
+        }
+
+        # Get tool output format
+        fmt = formats.get(tool_name, {})
+        if not fmt:
+            print("\nRaw Response:")
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return
+
+        # Print title
+        print(f"\n{fmt['title']}:")
+
+        # Handle list type responses
+        if "items" in fmt:
+            items = result.get(fmt["items"], [])
+            if not items:
+                print("No related content found")
+                return
+            for i, item in enumerate(items, 1):
+                print(f"\n{i}. {item.get(list(fmt['fields'].keys())[0], '')}")
+                for field, label in fmt["fields"].items():
+                    value = item.get(field, "")
+                    if isinstance(value, list):
+                        print(f"   {label}:")
+                        for v in value:
+                            print(f"   - {v}")
+                    else:
+                        print(f"   {label}: {value}")
+            return
+
+        # Handle dictionary type responses
+        for field, label in fmt["fields"].items():
+            value = result.get(field, "")
+            if isinstance(value, list):
+                print(f"\n{label}:")
+                for item in value:
+                    print(f"- {item}")
+            else:
+                print(f"\n{label}: {value}")
+
+    elif isinstance(result, str):
+        print("\nRaw Response Text:")
+        print(result)
+    else:
+        print("\nOther Type Response:")
+        print(result)
+
+
+# Step 3: Define test case list
+test_queries = [
+    # Health topic search - using simpler search terms
+    {
+        "name": "MedlinePlus_search_topics_by_keyword",
+        "arguments": {"term": "heart", "db": "healthTopics", "rettype": "topic"},
+    },
+    {
+        "name": "MedlinePlus_search_topics_by_keyword",
+        "arguments": {"term": "diabetes", "db": "healthTopics", "rettype": "topic"},
+    },
+    {
+        "name": "MedlinePlus_search_topics_by_keyword",
+        "arguments": {"term": "cancer", "db": "healthTopics", "rettype": "brief"},
+    },
+    {
+        "name": "MedlinePlus_search_topics_by_keyword",
+        "arguments": {
+            "term": "diabetes",
+            "db": "healthTopicsSpanish",
+            "rettype": "topic",
+        },
+    },
+    # Code lookup
+    {
+        "name": "MedlinePlus_connect_lookup_by_code",
+        "arguments": {
+            "cs": "2.16.840.1.113883.6.90",
+            "c": "E11.9",
+            "language": "en",
+            "format": "json",
+        },
+    },
+    {
+        "name": "MedlinePlus_connect_lookup_by_code",
+        "arguments": {
+            "cs": "2.16.840.1.113883.6.88",
+            "c": "637188",
+            "dn": "Chantix 0.5 MG Oral Tablet",
+            "language": "en",
+            "format": "xml",
+        },
+    },
+    # Genetics information
+    {
+        "name": "MedlinePlus_get_genetics_condition_by_name",
+        "arguments": {"condition": "alzheimer-disease", "format": "json"},
+    },
+    {
+        "name": "MedlinePlus_get_genetics_gene_by_name",
+        "arguments": {"gene": "BRCA1", "format": "json"},
+    },
+    {"name": "MedlinePlus_get_genetics_index", "arguments": {}},
+    # Error testing
+    {
+        "name": "MedlinePlus_search_topics_by_keyword",
+        "arguments": {"term": "", "db": "healthTopics", "rettype": "topic"},
+    },
+    {
+        "name": "MedlinePlus_connect_lookup_by_code",
+        "arguments": {
+            "cs": "INVALID_CS",
+            "c": "INVALID_CODE",
+            "language": "en",
+            "format": "json",
+        },
+    },
+]
+
+# Step 4: Loop through all test cases and print example output
+for idx, query in enumerate(test_queries):
+    print(f"\n{'='*80}")
+    print(f"[{idx+1}] Running tool: {query['name']}")
+    print(f"Arguments: {query['arguments']}")
+    print(f"{'='*80}")
+
+    try:
+        result = tooluni.run(query)
+        print_result(result, query["name"])
+    except Exception as e:
+        print("⚠️ Exception:", e)
+
+print("\n🎉 MedlinePlus Testing Complete!")

tooluniverse/test/test_openalex_tool.py

@@ -0,0 +1,32 @@
+# === openfda_test_all_tools.py ===
+
+from tooluniverse import ToolUniverse
+
+# Step 1: Initialize tool universe
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Step 2: Define test queries for the openalex tool
+test_queries = [
+    {
+        "name": "openalex_literature_search",
+        "arguments": {
+            "search_keywords": "cancer",
+            "max_results": 10,
+            "year_from": 2020,
+            "year_to": 2023,
+            "open_access": True,
+        },
+    },
+]
+
+# Step 3: Run all test queries
+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)
+    )  # Print snippet if result is big

tooluniverse/test/test_opentargets.py

@@ -0,0 +1,28 @@
+from tooluniverse import ToolUniverse
+
+# Step 1: Initialize tool universe
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Step 2: Define test queries for the opentargets tool
+test_queries = [
+    {"name": "Tool_Finder", "arguments": {"diseaseName": "Bardet-Biedl syndrome"}},
+    {
+        "name": "OpenTargets_get_drug_adverse_events_by_chemblId",
+        "arguments": {"chemblId": "CHEMBL980"},
+    },
+]
+
+# Step 3: Run all test queries
+for idx, query in enumerate(test_queries):
+    # try:
+    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)
+    )  # Print snippet if result is big
+# except Exception as e:
+#     print(f"❌ Failed. Error: {str(e)}")

tooluniverse/test/test_pubchem_tool.py

@@ -0,0 +1,116 @@
+# test_pubchem_tools.py
+
+from tooluniverse import ToolUniverse
+
+# Step 1: Initialize ToolUniverse and load all tools (including PubChem tools)
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Step 2: Define example inputs
+# Please confirm before execution:
+#  - 2244 (Aspirin) is actually available in PubChem
+#  - "Aspirin" matches its CID
+#  - "CC(=O)OC1=CC=CC=C1C(=O)O" is the standard SMILES for aspirin
+VALID_CID = 1983  # 2244                  # Aspirin CID
+VALID_NAME = "Aspirin"  # Name query
+VALID_SMILES = (
+    "C1=NC2=C(N1)C(=O)N=C(N2)N"  # "CC(=O)OC1=CC=CC=C1C(=O)O"  # Aspirin SMILES
+)
+VALID_SUBSTRUCTURE = "c1ccccc1"  # Benzene ring substructure
+VALID_THRESHOLD = 0.95  # 90              # 90% similarity threshold (integer)
+INVALID_CID = -1  # Intentionally invalid
+
+# For XRefs test, specify at least one external resource, e.g. "RegistryID", "RN"
+VALID_XREF_TYPES = ["RegistryID", "RN"]
+
+# Step 3: Define test case list
+test_queries = [
+    # 1. Get molecular properties by CID
+    {"name": "PubChem_get_compound_properties_by_CID", "arguments": {"cid": VALID_CID}},
+    # 1.5 Get associated patents by CID
+    {"name": "PubChem_get_associated_patents_by_CID", "arguments": {"cid": VALID_CID}},
+    {
+        "name": "get_webpage_title",
+        "arguments": {"url": "https://pubchem.ncbi.nlm.nih.gov/patent/US6015577"},
+    },
+    # 2. Query CID by name
+    {"name": "PubChem_get_CID_by_compound_name", "arguments": {"name": VALID_NAME}},
+    # 3. Query CID by SMILES
+    {"name": "PubChem_get_CID_by_SMILES", "arguments": {"smiles": VALID_SMILES}},
+    # 4. Substructure search
+    {
+        "name": "PubChem_search_compounds_by_substructure",
+        "arguments": {"smiles": VALID_SUBSTRUCTURE},
+    },
+    # 5. Similarity search (using SMILES and threshold)
+    {
+        "name": "PubChem_search_compounds_by_similarity",
+        "arguments": {"smiles": VALID_SMILES, "threshold": VALID_THRESHOLD},
+    },
+    # 6. Get 2D structure image (PNG)
+    {
+        "name": "PubChem_get_compound_2D_image_by_CID",
+        "arguments": {"cid": VALID_CID, "image_size": "150x150"},
+    },
+    # 7. Get synonyms
+    {"name": "PubChem_get_compound_synonyms_by_CID", "arguments": {"cid": VALID_CID}},
+    # 8. Get external references (XRefs), need to pass at least one resource name
+    {
+        "name": "PubChem_get_compound_xrefs_by_CID",
+        "arguments": {"cid": VALID_CID, "xref_types": VALID_XREF_TYPES},
+    },
+    # 9. Invalid CID test → expect error
+    {
+        "name": "PubChem_get_compound_properties_by_CID",
+        "arguments": {"cid": INVALID_CID},
+    },
+]
+
+# Step 4: Loop through all test cases and print example output
+for idx, query in enumerate(test_queries):
+    print(
+        f"\n[{idx+1}] Running tool: {query['name']} with arguments: {query['arguments']}"
+    )
+    result = tooluni.run(query)
+
+    # Check if contains "error"
+    if isinstance(result, dict) and "error" in result:
+        print("⚠️ Received error response:")
+        print(result)
+        continue
+
+    # Otherwise print example based on return type
+    print("✅ Success. Example output snippet:")
+    if isinstance(result, dict):
+        # Dictionary: print first 3 key-value pairs
+        print("Returned JSON, example first 3 key-value pairs:")
+        # cnt = 0
+        # for k, v in result.items():
+        #     print(f"  {k}: {v}")
+        #     cnt += 1
+        #     if cnt >= 3:
+        #         break
+        print(result)
+    elif isinstance(result, list):
+        # List: print length and first item
+        print(f"Returned list with {len(result)} items, example first item:")
+        print(result[0])
+    elif isinstance(result, str):
+        # Text (CSV, TXT): print first line
+        # snippet = result.strip().split("\n")[0]
+        # print(f"Returned text (first line): {snippet} …")
+        print(result)
+    elif isinstance(result, (bytes, bytearray)):
+        # Binary (PNG): check PNG file header
+        if result.startswith(b"\x89PNG"):
+            print(
+                f"Returned PNG image ({len(result)} bytes), file header matches PNG signature."
+            )
+        else:
+            print(f"Returned binary ({len(result)} bytes).")
+    else:
+        # Other unexpected cases
+        repr_str = repr(result)
+        print(repr_str if len(repr_str) <= 200 else repr_str[:200] + "…")
+
+print("\n🎉 PubChem testing completed!")

tooluniverse/test/test_pubtator_tool.py

@@ -0,0 +1,37 @@
+from tooluniverse import ToolUniverse
+
+# Step 1: Initialize tool universe and load available tools
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Define test queries based on the updated pubtator_tools.json
+test_queries = [
+    {
+        "name": "PubTator3_EntityAutocomplete",
+        "arguments": {"text": "BRAF", "entity_type": "GENE", "max_results": 5},
+    },
+    {
+        "name": "PubTator3_EntityAutocomplete",
+        "arguments": {"text": "TP53"},  # only required parameter
+    },
+    {
+        "name": "PubTator3_LiteratureSearch",
+        "arguments": {"query_text": "cancer", "page": 0, "page_size": 10},
+    },
+    {
+        "name": "PubTator3_LiteratureSearch",
+        "arguments": {"query_text": "diabetes"},  # minimal required args
+    },
+]
+
+# Run individual test queries
+for idx, query in enumerate(test_queries):
+    try:
+        print(
+            f"\n[{idx+1}] Running tool: {query['name']} with arguments: {query['arguments']}"
+        )
+        result = tooluni.run(query)
+        print("✅ Success. Output snippet:")
+        print(result if isinstance(result, dict) else str(result)[:500])
+    except Exception as e:
+        print(f"❌ Failed running {query['name']}. Error: {e}")

tooluniverse/test/test_rcsb_pdb_tool.py

@@ -0,0 +1,86 @@
+from tooluniverse import ToolUniverse
+
+# Step 1: Initialize tool universe
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Step 2: Define test queries
+# commented out = already tested but didn't add return_Schema. uncommented = not tested.
+test_queries = [
+    {"name": "get_sequence_by_pdb_id", "arguments": {"pdb_id": "1XYZ"}},
+    {"name": "get_protein_metadata_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_polymer_entity_ids_by_pdb_id", "arguments": {"pdb_id": "1A3N"}},
+    {
+        "name": "get_polymer_entity_type_by_entity_id",
+        "arguments": {"entity_id": "1A8M_1"},
+    },
+    {"name": "get_source_organism_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_citation_info_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_sequence_lengths_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_mutation_annotations_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {
+        "name": "get_em_3d_fitting_and_reconstruction_details",
+        "arguments": {"pdb_id": "6VXX"},
+    },
+    {"name": "get_assembly_summary", "arguments": {"assembly_id": "1A8M-1"}},
+    {"name": "get_assembly_info_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_taxonomy_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_release_deposit_dates_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_host_organism_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_ec_number_by_entity_id", "arguments": {"entity_id": "1T5D_1"}},
+    {"name": "get_gene_name_by_entity_id", "arguments": {"entity_id": "3W2S_1"}},
+    {
+        "name": "get_polymer_molecular_weight_by_entity_id",
+        "arguments": {"entity_id": "1A8M_1"},
+    },
+    {"name": "get_ligand_bond_count_by_pdb_id", "arguments": {"pdb_id": "1T5D"}},
+    {
+        "name": "get_crystal_growth_conditions_by_pdb_id",
+        "arguments": {"pdb_id": "1A8M"},
+    },
+    {"name": "get_polymer_entity_annotations", "arguments": {"entity_id": "1T5D_1"}},
+    {
+        "name": "get_oligosaccharide_descriptors_by_entity_id",
+        "arguments": {"entity_id": "5FMB_2"},
+    },
+    {
+        "name": "get_sequence_positional_features_by_instance_id",
+        "arguments": {"instance_id": "1NDO.A"},
+    },
+    {
+        "name": "get_crystallographic_properties_by_pdb_id",
+        "arguments": {"pdb_id": "1A8M"},
+    },
+    {
+        "name": "get_structure_validation_metrics_by_pdb_id",
+        "arguments": {"pdb_id": "1A8M"},
+    },
+    {"name": "get_structure_title_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_polymer_entity_count_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_emdb_ids_by_pdb_id", "arguments": {"pdb_id": "6VXX"}},
+    {
+        "name": "get_uniprot_accession_by_entity_id",
+        "arguments": {"entity_id": "1A8M_1"},
+    },
+    {"name": "get_crystallization_ph_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_space_group_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_protein_classification_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {
+        "name": "get_structure_determination_software_by_pdb_id",
+        "arguments": {"pdb_id": "1A8M"},
+    },
+    {"name": "get_refinement_resolution_by_pdb_id", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_binding_affinity_by_pdb_id", "arguments": {"pdb_id": "3W2S"}},
+    {"name": "get_ligand_smiles_by_chem_comp_id", "arguments": {"chem_comp_id": "ATP"}},
+    {"name": "get_core_refinement_statistics", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_target_cofactor_info", "arguments": {"pdb_id": "1A8M"}},
+    {"name": "get_chem_comp_audit_info", "arguments": {"pdb_id": "1T5D"}},
+    {"name": "get_chem_comp_charge_and_ambiguity", "arguments": {"pdb_id": "1T5D"}},
+]
+
+# Step 3: Run test queries
+for query in test_queries:
+    result = tooluni.run(query)
+    print(f"Query: {query}")
+    print("--" * 20)
+    print(f"Result: {result}")

tooluniverse/test/test_reactome.py

@@ -0,0 +1,54 @@
+# test_reactome.py
+
+from tooluniverse import ToolUniverse
+
+# Step 1: Initialize ToolUniverse and load all tools (including Reactome tools)
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+# Step 2: Define some IDs that are valid in Content Service
+VALID_PATHWAY_FOR_REACTIONS = (
+    "R-HSA-73817"  # This ID returns reactions, but info and participants will 404
+)
+
+# Step 3: Define test queries for Reactome tools
+test_queries = [
+    # 3. Get all Reactions under a Pathway (using verified valid ID)
+    {
+        "name": "Reactome_get_pathway_reactions",
+        "arguments": {"stId": VALID_PATHWAY_FOR_REACTIONS},
+    },
+]
+
+# Step 4: Run all test queries
+for idx, query in enumerate(test_queries):
+    print(
+        f"\n[{idx+1}] Running tool: {query['name']} with arguments: {query['arguments']}"
+    )
+    result = tooluni.run(query)
+
+    # If result contains "error" key, consider it as "server error", print and continue to next
+    if isinstance(result, dict) and "error" in result:
+        print("⚠️ Received error response:")
+        print(result)
+        continue
+
+    # Otherwise treat as "normal response", print example output
+    print("✅ Success. Example output snippet:")
+    if isinstance(result, list):
+        print(f"List with {len(result)} items, example first item:")
+        print(result[0])
+    elif isinstance(result, dict):
+        print("Returned dictionary, example first 3 key-value pairs:")
+        count = 0
+        for k, v in result.items():
+            print(f"  {k}: {v}")
+            count += 1
+            if count >= 3:
+                break
+    else:
+        # If result is None or other type, print repr directly
+        s = repr(result)
+        print(s if len(s) <= 200 else s[:200] + "…")
+
+print("\n🎉 Reactome testing completed!")

tooluniverse/test/test_semantic_scholar_tool.py

@@ -0,0 +1,24 @@
+from tooluniverse import ToolUniverse
+
+# ...existing code to initialize the ToolUniverse...
+tooluni = ToolUniverse()
+tooluni.load_tools()
+
+test_queries = [
+    {
+        "name": "SemanticScholar_search_papers",
+        "arguments": {
+            "query": "cancer immunotherapy",
+            "limit": 3,
+            # "api_key": "YOUR_API_KEY"  # Uncomment and add your API key if available
+        },
+    }
+]
+
+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))