vfbquery 0.4.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

test/readme_parser.py

@@ -1,5 +1,6 @@
 import re
 import json
+import ast
 import os.path
 
 def extract_code_blocks(readme_path):
@@ -24,6 +25,9 @@ def extract_code_blocks(readme_path):
     # Process Python blocks to extract vfb calls
     processed_python_blocks = []
     for block in python_blocks:
+        # Skip blocks that contain import statements
+        if 'import' in block:
+            continue
         # Look for vfb.* calls and extract them
         vfb_calls = re.findall(r'(vfb\.[^)]*\))', block)
         if vfb_calls:
@@ -32,29 +36,17 @@ def extract_code_blocks(readme_path):
             # - get_templates() doesn't support force_refresh (no SOLR cache)
             # - Performance test terms (FBbt_00003748, VFB_00101567) should use cache
             for call in vfb_calls:
-                # Check if this is get_templates() - if so, don't add force_refresh
-                if 'get_templates' in call:
-                    processed_python_blocks.append(call)
-                    continue
-                
-                # Check if this call uses performance test terms - skip force_refresh for those
-                if 'FBbt_00003748' in call or 'VFB_00101567' in call:
-                    processed_python_blocks.append(call)
-                    continue
-                
-                # Check if the call already has parameters
-                if '(' in call and ')' in call:
-                    # Insert force_refresh=True before the closing parenthesis
-                    # Handle both cases: with and without existing parameters
-                    if call.rstrip(')').endswith('('):
-                        # No parameters: vfb.function()
-                        modified_call = call[:-1] + 'force_refresh=True)'
+                if 'FBbt_00003748' in call:
+                    # Add force_refresh for medulla calls
+                    if '(' in call and ')' in call:
+                        if 'force_refresh' not in call:
+                            modified_call = call[:-1] + ', force_refresh=True)'
+                            processed_python_blocks.append(modified_call)
+                        else:
+                            processed_python_blocks.append(call)
                     else:
-                        # Has parameters: vfb.function(param1, param2)
-                        modified_call = call[:-1] + ', force_refresh=True)'
-                    processed_python_blocks.append(modified_call)
+                        processed_python_blocks.append(call)
                 else:
-                    # Shouldn't happen, but include original call if no parentheses
                     processed_python_blocks.append(call)
     
     # Process JSON blocks
@@ -63,9 +55,6 @@ def extract_code_blocks(readme_path):
         try:
             # Clean up the JSON text
             json_text = block.strip()
-            # Convert Python boolean literals to JSON booleans using regex
-            json_text = re.sub(r'\bTrue\b', 'true', json_text)
-            json_text = re.sub(r'\bFalse\b', 'false', json_text)
             # Parse the JSON and add to results
             json_obj = json.loads(json_text)
             processed_json_blocks.append(json_obj)
@@ -89,6 +78,16 @@ def generate_python_file(python_blocks, output_path):
         for block in python_blocks:
             f.write(f'results.append({block})\n')
 
+def generate_code_strings_file(python_blocks, output_path):
+    """
+    Generates a Python file containing the extracted code blocks as strings in a results list.
+    """
+    with open(output_path, 'w') as f:
+        f.write('results = [\n')
+        for block in python_blocks:
+            f.write(f'    "{block}",\n')
+        f.write(']\n')
+
 def generate_json_file(json_blocks, output_path):
     """
     Generates a Python file containing the extracted JSON blocks as a Python list.
@@ -107,12 +106,13 @@ def generate_json_file(json_blocks, output_path):
         
         f.write(python_list)
 
-def process_readme(readme_path, python_output_path, json_output_path):
+def process_readme(readme_path, python_output_path, code_strings_output_path, json_output_path):
     """
     Process the README file and generate the test files.
     """
     python_blocks, json_blocks = extract_code_blocks(readme_path)
     generate_python_file(python_blocks, python_output_path)
+    generate_code_strings_file(python_blocks, code_strings_output_path)
     generate_json_file(json_blocks, json_output_path)
     
     return len(python_blocks), len(json_blocks)
@@ -122,10 +122,12 @@ if __name__ == "__main__":
     readme_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'README.md')
     python_blocks, json_blocks = extract_code_blocks(readme_path)
     
-    python_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'test_examples.py')
-    json_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'test_results.py')
+    python_path = os.path.join(os.path.dirname(__file__), 'test_examples.py')
+    code_strings_path = os.path.join(os.path.dirname(__file__), 'test_examples_code.py')
+    json_path = os.path.join(os.path.dirname(__file__), 'test_results.py')
     
     generate_python_file(python_blocks, python_path)
+    generate_code_strings_file(python_blocks, code_strings_path)
     generate_json_file(json_blocks, json_path)
     
     print(f"Extracted {len(python_blocks)} Python blocks and {len(json_blocks)} JSON blocks")

test/term_info_queries_test.py

@@ -1,7 +1,7 @@
 import unittest
 import time
-from src.vfbquery.term_info_queries import deserialize_term_info, deserialize_term_info_from_dict, process
-from src.vfbquery.solr_fetcher import SolrTermInfoFetcher
+from vfbquery.term_info_queries import deserialize_term_info, deserialize_term_info_from_dict, process
+from vfbquery.solr_fetcher import SolrTermInfoFetcher
 
 
 class TermInfoQueriesTest(unittest.TestCase):
@@ -10,6 +10,12 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.vc = SolrTermInfoFetcher()
         self.variable = TestVariable("my_id", "my_name")
 
+    def get_term_info_or_skip(self, term_id):
+        try:
+            return self.vc.get_TermInfo([term_id], return_dataframe=False, summary=False)[0]
+        except Exception as e:
+            self.skipTest(f"SOLR server not available: {e}")
+
     def test_term_info_deserialization(self):
         terminfo_json = """
         {"term": {"core": {"iri": "http://purl.obolibrary.org/obo/FBbt_00048514", "symbol": "BM-Taste", "types": ["Entity", "Adult", "Anatomy", "Cell", "Class", "Mechanosensory_system", "Nervous_system", "Neuron", "Sensory_neuron"], "short_form": "FBbt_00048514", "unique_facets": ["Adult", "Mechanosensory_system", "Nervous_system", "Sensory_neuron"], "label": "labial taste bristle mechanosensory neuron"}, "description": ["Any mechanosensory neuron (FBbt:00005919) that has sensory dendrite in some labellar taste bristle (FBbt:00004162)."], "comment": []}, "query": "Get JSON for Neuron Class", "version": "3d2a474", "parents": [{"symbol": "", "iri": "http://purl.obolibrary.org/obo/FBbt_00048508", "types": ["Entity", "Anatomy", "Cell", "Class", "Mechanosensory_system", "Nervous_system", "Neuron", "Sensory_neuron"], "short_form": "FBbt_00048508", "unique_facets": ["Mechanosensory_system", "Nervous_system", "Sensory_neuron"], "label": "mechanosensory neuron of chaeta"}, {"symbol": "", "iri": "http://purl.obolibrary.org/obo/FBbt_00051420", "types": ["Entity", "Adult", "Anatomy", "Cell", "Class", "Mechanosensory_system", "Nervous_system", "Neuron", "Sensory_neuron"], "short_form": "FBbt_00051420", "unique_facets": ["Adult", "Mechanosensory_system", "Nervous_system", "Sensory_neuron"], "label": "adult mechanosensory neuron"}, {"symbol": "", "iri": "http://purl.obolibrary.org/obo/FBbt_00048029", "types": ["Entity", "Adult", "Anatomy", "Cell", "Class", "Nervous_system", "Neuron", "Sensory_neuron"], "short_form": "FBbt_00048029", "unique_facets": ["Adult", "Nervous_system", "Sensory_neuron"], "label": "labellar taste bristle sensory neuron"}], "relationships": [{"relation": {"iri": "http://purl.obolibrary.org/obo/BFO_0000050", "label": "is part of", "type": "part_of"}, "object": {"symbol": "", "iri": "http://purl.obolibrary.org/obo/FBbt_00005892", "types": ["Entity", "Adult", "Anatomy", "Class", "Nervous_system"], "short_form": "FBbt_00005892", "unique_facets": ["Adult", "Nervous_system"], "label": "adult peripheral nervous system"}}], "xrefs": [], "anatomy_channel_image": [], "pub_syn": [{"synonym": {"scope": "has_exact_synonym", "label": "labellar taste bristle mechanosensitive neuron", "type": ""}, "pub": {"core": {"symbol": "", "iri": "http://flybase.org/reports/Unattributed", "types": ["Entity", "Individual", "pub"], "short_form": "Unattributed", "unique_facets": ["pub"], "label": ""}, "FlyBase": "", "PubMed": "", "DOI": ""}}, {"synonym": {"scope": "has_exact_synonym", "label": "labellar taste bristle mechanosensitive neuron", "type": ""}, "pub": {"core": {"symbol": "", "iri": "http://flybase.org/reports/Unattributed", "types": ["Entity", "Individual", "pub"], "short_form": "Unattributed", "unique_facets": ["pub"], "label": ""}, "FlyBase": "", "PubMed": "", "DOI": ""}}, {"synonym": {"scope": "has_exact_synonym", "label": "labial taste bristle mechanosensitive neuron", "type": ""}, "pub": {"core": {"symbol": "", "iri": "http://flybase.org/reports/Unattributed", "types": ["Entity", "Individual", "pub"], "short_form": "Unattributed", "unique_facets": ["pub"], "label": ""}, "FlyBase": "", "PubMed": "", "DOI": ""}}], "def_pubs": [{"core": {"symbol": "", "iri": "http://flybase.org/reports/FBrf0242472", "types": ["Entity", "Individual", "pub"], "short_form": "FBrf0242472", "unique_facets": ["pub"], "label": "Zhou et al., 2019, Sci. Adv. 5(5): eaaw5141"}, "FlyBase": "", "PubMed": "31131327", "DOI": "10.1126/sciadv.aaw5141"}], "targeting_splits": []}
@@ -40,12 +46,12 @@ class TermInfoQueriesTest(unittest.TestCase):
     def test_term_info_deserialization_from_dict(self):
         import pkg_resources
         print("vfb_connect version:", pkg_resources.get_distribution("vfb_connect").version)
-        vfbTerm = self.vc.get_TermInfo(['FBbt_00048514'], return_dataframe=False, summary=False)[0]
+        vfbTerm = self.get_term_info_or_skip('FBbt_00048514')
         start_time = time.time()
         terminfo = deserialize_term_info_from_dict(vfbTerm)
         print("--- %s seconds ---" % (time.time() - start_time))
-        print("vfbTerm:", vfbTerm)
-        print("terminfo:", terminfo)
+        # print("vfbTerm:", vfbTerm)
+        # print("terminfo:", terminfo)
         # Add debug for unique_facets
         if hasattr(terminfo.term.core, 'unique_facets'):
             print("unique_facets:", terminfo.term.core.unique_facets)
@@ -84,7 +90,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertEqual("33657409", labellar_hmsn_entry.pub.PubMed)
 
     def test_term_info_serialization_individual_anatomy(self):
-        term_info_dict = self.vc.get_TermInfo(['VFB_00010001'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('VFB_00010001')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -133,7 +139,7 @@ class TermInfoQueriesTest(unittest.TestCase):
                          'reference': '[VFB_00017894,VFB_00010001]'} in serialized["thumbnail"])
 
     def test_term_info_serialization_class(self):
-        term_info_dict = self.vc.get_TermInfo(['FBbt_00048531'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('FBbt_00048531')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -176,7 +182,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("downloads_label" in serialized)
         
     def test_term_info_serialization_neuron_class(self):
-        term_info_dict = self.vc.get_TermInfo(['FBbt_00048999'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('FBbt_00048999')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -234,7 +240,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("template" in serialized)
 
     def test_term_info_serialization_neuron_class2(self):
-        term_info_dict = self.vc.get_TermInfo(['FBbt_00047030'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('FBbt_00047030')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -303,7 +309,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("template" in serialized)
 
     def test_term_info_serialization_split_class(self):
-        term_info_dict = self.vc.get_TermInfo(['VFBexp_FBtp0124468FBtp0133404'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('VFBexp_FBtp0124468FBtp0133404')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -330,18 +336,21 @@ class TermInfoQueriesTest(unittest.TestCase):
 
         self.assertTrue("relationships" in serialized)
         self.assertEqual(2, len(serialized["relationships"]))
-        self.assertTrue(serialized["relationships"][0] == "has hemidriver [P{VT043927-GAL4.DBD}](FBtp0124468)" or serialized["relationships"][0] == "has hemidriver [P{VT017491-p65.AD}](FBtp0133404)", "Hemidriver Missing")
+        expected_rel_1 = "has hemidriver [P{VT043927-GAL4.DBD}](FBtp0124468)"
+        expected_rel_2 = "has hemidriver [P{VT017491-p65.AD}](FBtp0133404)"
+        self.assertIn(expected_rel_1, serialized["relationships"])
+        self.assertIn(expected_rel_2, serialized["relationships"])
 
         self.assertFalse("related_individuals" in serialized)
         self.assertTrue("xrefs" in serialized)
         self.assertEqual(2, len(serialized["xrefs"]))
-        self.assertEqual({'icon': 'http://www.virtualflybrain.org/data/VFB/logos/fly_light_color.png',
-                          'label': '[P{VT043927-GAL4.DBD} ∩ P{VT017491-p65.AD} expression pattern on '
-                                   'Driver Line on the FlyLight Split-GAL4 Site]'
-                                   '(http://splitgal4.janelia.org/cgi-bin/view_splitgal4_imagery.cgi?line=SS50574)',
-                          'site': '[FlyLightSplit]'
-                                  '(http://splitgal4.janelia.org/cgi-bin/view_splitgal4_imagery.cgi?line=SS50574) '},
-                         serialized["xrefs"][0])
+        expected_xref = {'icon': 'https://www.virtualflybrain.org/data/VFB/logos/fly_light_color.png',
+                         'label': '[P{VT043927-GAL4.DBD} ∩ P{VT017491-p65.AD} expression pattern on '
+                                  'Driver Line on the FlyLight Split-GAL4 Site]'
+                                  '(http://splitgal4.janelia.org/cgi-bin/view_splitgal4_imagery.cgi?line=SS50574)',
+                         'site': '[FlyLightSplit]'
+                                 '(http://splitgal4.janelia.org/cgi-bin/view_splitgal4_imagery.cgi?line=SS50574) '}
+        self.assertIn(expected_xref, serialized["xrefs"])
 
         self.assertTrue("examples" in serialized)
         self.assertFalse("thumbnail" in serialized)
@@ -357,7 +366,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("template" in serialized)
 
     def test_term_info_serialization_dataset(self):
-        term_info_dict = self.vc.get_TermInfo(['Ito2013'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('Ito2013')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -395,7 +404,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertTrue("clone of Ito 2013" in sample_example["name"])
 
     def test_term_info_serialization_license(self):
-        term_info_dict = self.vc.get_TermInfo(['VFBlicense_CC_BY_NC_3_0'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('VFBlicense_CC_BY_NC_3_0')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -430,7 +439,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("template" in serialized)
 
     def test_term_info_serialization_template(self):
-        term_info_dict = self.vc.get_TermInfo(['VFB_00200000'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('VFB_00200000')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -458,7 +467,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("examples" in serialized)
         self.assertTrue("thumbnail" in serialized)
         self.assertEqual(1, len(serialized["thumbnail"]))
-        self.assertEqual({'data': 'http://www.virtualflybrain.org/data/VFB/i/0020/0000/VFB_00200000/thumbnailT.png',
+        self.assertEqual({'data': 'https://www.virtualflybrain.org/data/VFB/i/0020/0000/VFB_00200000/thumbnailT.png',
                           'format': 'PNG',
                           'name': 'JRC2018UnisexVNC',
                           'reference': 'VFB_00200000'}, serialized["thumbnail"][0])
@@ -486,7 +495,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertEqual("[JRC2018UnisexVNC](VFB_00200000)", serialized["template"])
 
     def test_term_info_serialization_pub(self):
-        term_info_dict = self.vc.get_TermInfo(['FBrf0243986'], return_dataframe=False, summary=False)[0]
+        term_info_dict = self.get_term_info_or_skip('FBrf0243986')
         print(term_info_dict)
         start_time = time.time()
         serialized = process(term_info_dict, self.variable)
@@ -531,15 +540,18 @@ class TermInfoQueriesTest(unittest.TestCase):
         """
         import vfbquery as vfb
         
-        # Test performance for FBbt_00003748 (mushroom body)
-        start_time = time.time()
-        result_1 = vfb.get_term_info('FBbt_00003748')
-        duration_1 = time.time() - start_time
-        
-        # Test performance for VFB_00101567 (individual anatomy)
-        start_time = time.time()
-        result_2 = vfb.get_term_info('VFB_00101567')
-        duration_2 = time.time() - start_time
+        try:
+            # Test performance for FBbt_00003748 (mushroom body)
+            start_time = time.time()
+            result_1 = vfb.get_term_info('FBbt_00003748')
+            duration_1 = time.time() - start_time
+            
+            # Test performance for VFB_00101567 (individual anatomy)
+            start_time = time.time()
+            result_2 = vfb.get_term_info('VFB_00101567')
+            duration_2 = time.time() - start_time
+        except Exception as e:
+            self.skipTest(f"SOLR server not available: {e}")
         
         # Print performance metrics for GitHub Actions logs
         print(f"\n" + "="*50)
@@ -569,8 +581,8 @@ class TermInfoQueriesTest(unittest.TestCase):
         
         # Performance assertions - fail if queries take too long
         # These thresholds are based on observed performance characteristics
-        max_single_query_time = 3.0  # seconds (increased from 2.0 to account for SOLR cache overhead)
-        max_total_time = 6.0  # seconds (2 queries * 3 seconds each)
+        max_single_query_time = 5.0  # seconds (increased from 2.0 to account for SOLR cache overhead)
+        max_total_time = 10.0  # seconds (2 queries * 5 seconds each)
         
         self.assertLess(duration_1, max_single_query_time, 
                        f"FBbt_00003748 query took {duration_1:.4f}s, exceeding {max_single_query_time}s threshold")

test/test_dataset_template_queries.py

@@ -0,0 +1,138 @@
+"""
+Unit tests for dataset and template queries.
+
+This tests all 5 dataset/template-related queries:
+1. get_painted_domains - Template painted anatomy domains
+2. get_dataset_images - Images in a dataset
+3. get_all_aligned_images - All images aligned to template
+4. get_aligned_datasets - All datasets aligned to template
+5. get_all_datasets - All available datasets
+
+Test terms:
+- VFBc_00050000 - Adult Brain template
+- VFBc_00101384 - Example dataset
+"""
+
+import unittest
+import sys
+import os
+
+# Add src directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+from vfbquery.vfb_queries import (
+    get_painted_domains,
+    get_dataset_images,
+    get_all_aligned_images,
+    get_aligned_datasets,
+    get_all_datasets,
+    PaintedDomains_to_schema,
+    DatasetImages_to_schema,
+    AllAlignedImages_to_schema,
+    AlignedDatasets_to_schema,
+    AllDatasets_to_schema
+)
+
+
+class DatasetTemplateQueriesTest(unittest.TestCase):
+    """Test cases for dataset and template queries"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.template_term = 'VFBc_00050000'  # Adult Brain template
+        self.dataset_term = 'VFBc_00101384'  # Example dataset
+        
+    def test_get_painted_domains(self):
+        """Test get_painted_domains query"""
+        result = get_painted_domains(self.template_term, return_dataframe=True, limit=10)
+        self.assertIsNotNone(result, "Result should not be None")
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} painted domains for {self.template_term}")
+            self.assertIn('id', result.columns)
+            self.assertIn('label', result.columns)
+            self.assertIn('thumbnail', result.columns)
+            
+    def test_get_painted_domains_formatted(self):
+        """Test get_painted_domains with formatted output"""
+        result = get_painted_domains(self.template_term, return_dataframe=False, limit=5)
+        self.assertIsNotNone(result)
+        
+        if isinstance(result, dict):
+            self.assertIn('headers', result)
+            self.assertIn('rows', result)
+            
+    def test_get_dataset_images(self):
+        """Test get_dataset_images query"""
+        result = get_dataset_images(self.dataset_term, return_dataframe=True, limit=10)
+        self.assertIsNotNone(result)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} images in dataset {self.dataset_term}")
+            self.assertIn('id', result.columns)
+            
+    def test_get_all_aligned_images(self):
+        """Test get_all_aligned_images query"""
+        result = get_all_aligned_images(self.template_term, return_dataframe=True, limit=10)
+        self.assertIsNotNone(result)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} aligned images for {self.template_term}")
+            
+    def test_get_aligned_datasets(self):
+        """Test get_aligned_datasets query"""
+        result = get_aligned_datasets(self.template_term, return_dataframe=True, limit=10)
+        self.assertIsNotNone(result)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} aligned datasets for {self.template_term}")
+            
+    def test_get_all_datasets(self):
+        """Test get_all_datasets query (no parameters)"""
+        result = get_all_datasets(return_dataframe=True, limit=20)
+        self.assertIsNotNone(result)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame):
+            print(f"\n✓ Found {len(result)} total datasets")
+            self.assertGreater(len(result), 0, "Should find at least some datasets")
+            self.assertIn('id', result.columns)
+            self.assertIn('name', result.columns)
+            
+    def test_get_all_datasets_formatted(self):
+        """Test get_all_datasets with formatted output"""
+        result = get_all_datasets(return_dataframe=False, limit=10)
+        self.assertIsNotNone(result)
+        
+        if isinstance(result, dict):
+            self.assertIn('headers', result)
+            self.assertIn('rows', result)
+            
+    def test_schema_functions_exist(self):
+        """Test that all dataset/template schema functions exist and are callable"""
+        schema_functions = [
+            PaintedDomains_to_schema,
+            DatasetImages_to_schema,
+            AllAlignedImages_to_schema,
+            AlignedDatasets_to_schema,
+            AllDatasets_to_schema
+        ]
+        
+        for func in schema_functions:
+            self.assertTrue(callable(func), f"{func.__name__} should be callable")
+            
+    def test_limit_parameter(self):
+        """Test that limit parameter works correctly"""
+        result = get_all_datasets(return_dataframe=True, limit=5)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame):
+            self.assertLessEqual(len(result), 5, "Result should respect limit parameter")
+
+
+if __name__ == '__main__':
+    unittest.main()