vfbquery 0.5.0__py3-none-any.whl → 0.5.2__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,35 +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
-                # NOTE: FBbt_00003748 (medulla) now needs force_refresh to get updated queries
-                if 'VFB_00101567' in call:
-                    processed_python_blocks.append(call)
-                    continue
-                
-                # Check if the call already has parameters
-                if '(' in call and ')' in call:
-                    # Check if force_refresh is already present
-                    if 'force_refresh' in call:
-                        # Already has force_refresh, use as-is
-                        processed_python_blocks.append(call)
-                    else:
-                        # 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)'
-                        else:
-                            # Has parameters: vfb.function(param1, param2)
+                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)
+                            processed_python_blocks.append(modified_call)
+                        else:
+                            processed_python_blocks.append(call)
+                    else:
+                        processed_python_blocks.append(call)
                 else:
-                    # Shouldn't happen, but include original call if no parentheses
                     processed_python_blocks.append(call)
     
     # Process JSON blocks
@@ -69,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)
@@ -95,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.
@@ -113,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)
@@ -128,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,7 +46,7 @@ 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))
@@ -64,7 +70,7 @@ class TermInfoQueriesTest(unittest.TestCase):
 
         self.assertEqual(0, len(terminfo.xrefs))
 
-        self.assertEqual(7, len(terminfo.pub_syn))
+        self.assertEqual(8, len(terminfo.pub_syn))
         
         # Check that we have the expected synonym labels (order-independent)
         synonym_labels = [entry.synonym.label for entry in terminfo.pub_syn]
@@ -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)
@@ -145,7 +151,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("link" in serialized)
         self.assertEqual(4, len(serialized["types"]))
         self.assertTrue("Anatomy" in serialized["types"])
-        self.assertEqual("Cyst composed of two cyst cells following the division of a newly-formed cystoblast in the germarium. The two cells are connected by a cytoplasmic bridge.\n([King, 1970](FBrf0021038))", serialized["description"])
+        self.assertEqual("Cyst composed of two cyst cells following the division of a newly-formed cystoblast in the germarium. The two cells are connected by a cytoplasmic bridge.\n([Spradling, 1993](FBrf0064777), [King, 1970](FBrf0021038))", serialized["description"])
         self.assertTrue("synonyms" in serialized)
         self.assertEqual(1, len(serialized["synonyms"]))
         self.assertEqual("has_exact_synonym: germarial 2-cell cluster ([King, 1970](FBrf0021038))", serialized["synonyms"][0])
@@ -166,17 +172,20 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("examples" in serialized)
         self.assertFalse("thumbnail" in serialized)
         self.assertTrue("references" in serialized)
-        self.assertEqual(1, len(serialized["references"]))
+        self.assertEqual(2, len(serialized["references"]))
+        self.assertEqual({'link': '[Spradling, 1993, Bate, Martinez Arias, 1993: 1--70](FBrf0064777)',
+                          'refs': ['http://flybase.org/reports/FBrf0064777'],
+                          'types': ' pub'}, serialized["references"][0])
         self.assertEqual({'link': '[King, 1970, Ovarian Development in Drosophila melanogaster. ](FBrf0021038)',
                           'refs': ['http://flybase.org/reports/FBrf0021038'],
-                          'types': ' pub'}, serialized["references"][0])
+                          'types': ' pub'}, serialized["references"][1])
         self.assertFalse("targetingSplits" in serialized)
         self.assertFalse("targetingNeurons" in serialized)
 
         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 +243,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 +312,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 +339,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 +369,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 +407,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 +442,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 +470,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 +498,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 +543,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)

test/test_default_caching.py

@@ -1,8 +1,8 @@
 """
 Test VFBquery default caching functionality.
 
-These tests ensure that the default 3-month TTL, 2GB memory caching
-system works correctly and provides expected performance benefits.
+These tests ensure that the SOLR-based caching system works correctly
+and provides expected performance benefits with 3-month TTL.
 """
 
 import unittest
@@ -12,165 +12,166 @@ from unittest.mock import MagicMock
 import sys
 
 # Mock vispy imports before importing vfbquery
-for module in ['vispy', 'vispy.scene', 'vispy.util', 'vispy.util.fonts', 
-               'vispy.util.fonts._triage', 'vispy.util.fonts._quartz', 
-               'vispy.ext', 'vispy.ext.cocoapy', 'navis', 'navis.plotting', 
+for module in ['vispy', 'vispy.scene', 'vispy.util', 'vispy.util.fonts',
+               'vispy.util.fonts._triage', 'vispy.util.fonts._quartz',
+               'vispy.ext', 'vispy.ext.cocoapy', 'navis', 'navis.plotting',
                'navis.plotting.vispy', 'navis.plotting.vispy.viewer']:
     sys.modules[module] = MagicMock()
 
 # Set environment variables
 os.environ.update({
     'MPLBACKEND': 'Agg',
-    'VISPY_GL_LIB': 'osmesa', 
+    'VISPY_GL_LIB': 'osmesa',
     'VISPY_USE_EGL': '0',
     'VFBQUERY_CACHE_ENABLED': 'true'
 })
 
 
 class TestDefaultCaching(unittest.TestCase):
-    """Test default caching behavior in VFBquery."""
-    
+    """Test default SOLR caching behavior in VFBquery."""
+
     def setUp(self):
         """Set up test environment."""
         # Clear any existing cache before each test
         try:
             import vfbquery
-            if hasattr(vfbquery, 'clear_vfbquery_cache'):
-                vfbquery.clear_vfbquery_cache()
+            if hasattr(vfbquery, 'clear_solr_cache'):
+                # Clear cache for a test term
+                vfbquery.clear_solr_cache('term_info', 'FBbt_00003748')
         except ImportError:
             pass
-    
+
     def test_caching_enabled_by_default(self):
-        """Test that caching is automatically enabled when importing vfbquery."""
+        """Test that SOLR caching is automatically enabled when importing vfbquery."""
         import vfbquery
-        
-        # Check that caching functions are available
-        self.assertTrue(hasattr(vfbquery, 'get_vfbquery_cache_stats'))
-        self.assertTrue(hasattr(vfbquery, 'enable_vfbquery_caching'))
-        
-        # Check that cache stats show caching is enabled
-        stats = vfbquery.get_vfbquery_cache_stats()
-        self.assertTrue(stats['enabled'])
-        self.assertEqual(stats['cache_ttl_days'], 90.0)  # 3 months
-        self.assertEqual(stats['memory_cache_limit_mb'], 2048)  # 2GB
+
+        # Check that SOLR caching functions are available
+        self.assertTrue(hasattr(vfbquery, 'get_solr_cache'))
+        self.assertTrue(hasattr(vfbquery, 'clear_solr_cache'))
+        self.assertTrue(hasattr(vfbquery, 'get_solr_cache_stats_func'))
+
+        # Check that caching is enabled (we can't easily check SOLR stats without network calls)
+        # But we can verify the infrastructure is in place
+        self.assertTrue(hasattr(vfbquery, '__caching_available__'))
+        self.assertTrue(vfbquery.__caching_available__)
     
     def test_cache_performance_improvement(self):
-        """Test that caching provides performance improvement."""
+        """Test that SOLR caching provides performance improvement."""
         import vfbquery
-        
+
         test_term = 'FBbt_00003748'  # medulla
-        
+
         # First call (cold - populates cache)
         start_time = time.time()
         result1 = vfbquery.get_term_info(test_term)
         cold_time = time.time() - start_time
-        
+
         # Verify we got a result
         self.assertIsNotNone(result1)
         if result1 is not None:
             self.assertIn('Name', result1)
-        
+
         # Second call (warm - should hit cache)
-        start_time = time.time() 
+        start_time = time.time()
         result2 = vfbquery.get_term_info(test_term)
         warm_time = time.time() - start_time
-        
+
         # Verify caching is working (results should be identical)
         self.assertIsNotNone(result2)
         self.assertEqual(result1, result2)  # Should be identical
-        
+
         # Note: Performance improvement may vary due to network conditions
         # The main test is that caching prevents redundant computation
-        
-        # Check cache statistics (memory cache stats, not SOLR cache stats)
-        stats = vfbquery.get_vfbquery_cache_stats()
-        # Note: get_term_info uses SOLR caching, not memory caching, so hits will be 0
-        # We verify caching works through performance improvement instead
+
+        # Check SOLR cache statistics
+        solr_stats = vfbquery.get_solr_cache_stats_func()
+        self.assertIsInstance(solr_stats, dict)
+        self.assertIn('total_cache_documents', solr_stats)
     
     def test_cache_statistics_tracking(self):
-        """Test that cache statistics are properly tracked."""
+        """Test that SOLR cache statistics are properly tracked."""
         import vfbquery
-        
-        # Clear cache and get fresh baseline
-        vfbquery.clear_vfbquery_cache()
-        initial_stats = vfbquery.get_vfbquery_cache_stats()
-        initial_items = initial_stats['memory_cache_items']
-        initial_total = initial_stats['misses'] + initial_stats['hits']
-        
-        # Make a unique query that won't be cached
+
+        # Get baseline SOLR stats
+        initial_stats = vfbquery.get_solr_cache_stats_func()
+        initial_docs = initial_stats['total_cache_documents']
+
+        # Make a unique query that should populate cache
         unique_term = 'FBbt_00005106'  # Use a different term
         result = vfbquery.get_term_info(unique_term)
         self.assertIsNotNone(result)
-        
-        # Check that stats were updated (at least one request was made)
-        updated_stats = vfbquery.get_vfbquery_cache_stats()
-        updated_total = updated_stats['misses'] + updated_stats['hits']
-        
-        # At minimum, we should have at least 1 request recorded
-        self.assertGreaterEqual(updated_total, initial_total)
-        self.assertGreaterEqual(updated_stats['memory_cache_size_mb'], 0)
+
+        # Check that SOLR stats were updated (may take time to reflect)
+        # We mainly verify the stats function works and returns reasonable data
+        updated_stats = vfbquery.get_solr_cache_stats_func()
+        self.assertIsInstance(updated_stats, dict)
+        self.assertIn('total_cache_documents', updated_stats)
+        self.assertIn('cache_efficiency', updated_stats)
     
     def test_memory_size_tracking(self):
-        """Test that memory usage is properly tracked."""
+        """Test that SOLR cache size is properly tracked."""
         import vfbquery
-        
-        # Clear cache to start fresh
-        vfbquery.clear_vfbquery_cache()
-        
+
         # Cache a few different terms
         test_terms = ['FBbt_00003748', 'VFB_00101567']
-        
+
         for term in test_terms:
-            vfbquery.get_term_info(term)
-            stats = vfbquery.get_vfbquery_cache_stats()
-            
-            # Memory size should be tracked
-            self.assertGreaterEqual(stats['memory_cache_size_mb'], 0)
-            self.assertLessEqual(stats['memory_cache_size_mb'], stats['memory_cache_limit_mb'])
+            result = vfbquery.get_term_info(term)
+            self.assertIsNotNone(result)
+
+            # Check SOLR cache stats are available
+            stats = vfbquery.get_solr_cache_stats_func()
+            self.assertIsInstance(stats, dict)
+            self.assertIn('estimated_size_mb', stats)
+            self.assertGreaterEqual(stats['estimated_size_mb'], 0)
     
     def test_cache_ttl_configuration(self):
-        """Test that cache TTL is properly configured."""
+        """Test that SOLR cache TTL is properly configured."""
         import vfbquery
-        
-        stats = vfbquery.get_vfbquery_cache_stats()
-        
-        # Should be configured for 3 months (90 days)
-        self.assertEqual(stats['cache_ttl_days'], 90.0)
-        self.assertEqual(stats['cache_ttl_hours'], 2160)  # 90 * 24
+
+        # Get SOLR cache instance to check TTL
+        solr_cache = vfbquery.get_solr_cache()
+        self.assertIsNotNone(solr_cache)
+
+        # Check that TTL is configured (we can't easily check the exact value without accessing private attributes)
+        # But we can verify the cache object exists and has expected methods
+        self.assertTrue(hasattr(solr_cache, 'ttl_hours'))
+        self.assertTrue(hasattr(solr_cache, 'cache_result'))
+        self.assertTrue(hasattr(solr_cache, 'get_cached_result'))
     
     def test_transparent_caching(self):
         """Test that regular VFBquery functions are transparently cached."""
         import vfbquery
-        
+
         # Test that get_term_info and get_instances are using cached versions
         test_term = 'FBbt_00003748'
-        
+
         # These should work with caching transparently
         term_info = vfbquery.get_term_info(test_term)
         self.assertIsNotNone(term_info)
-        
+
         instances = vfbquery.get_instances(test_term, limit=5)
         self.assertIsNotNone(instances)
-        
-        # Cache should show some activity (at least the functions were called)
-        stats = vfbquery.get_vfbquery_cache_stats()
-        # We don't check specific hit/miss counts since caching implementation varies
-        # Just verify caching infrastructure is working
-        self.assertIsInstance(stats, dict)
-        self.assertIn('enabled', stats)
-        self.assertTrue(stats['enabled'])
+
+        # SOLR cache should be accessible
+        solr_stats = vfbquery.get_solr_cache_stats_func()
+        self.assertIsInstance(solr_stats, dict)
+        self.assertIn('total_cache_documents', solr_stats)
     
     def test_cache_disable_environment_variable(self):
         """Test that caching can be disabled via environment variable."""
         # This test would need to be run in a separate process to test
         # the environment variable behavior at import time
         # For now, just verify the current state respects the env var
-        
+
         cache_enabled = os.getenv('VFBQUERY_CACHE_ENABLED', 'true').lower()
         if cache_enabled not in ('false', '0', 'no', 'off'):
             import vfbquery
-            stats = vfbquery.get_vfbquery_cache_stats()
-            self.assertTrue(stats['enabled'])
+            # If caching is enabled, SOLR cache should be available
+            solr_cache = vfbquery.get_solr_cache()
+            self.assertIsNotNone(solr_cache)
+            self.assertTrue(hasattr(vfbquery, '__caching_available__'))
+            self.assertTrue(vfbquery.__caching_available__)
 
 
 if __name__ == '__main__':

test/test_examples_code.py

@@ -0,0 +1,7 @@
+results = [
+    "vfb.get_term_info('FBbt_00003748', force_refresh=True)",
+    "vfb.get_term_info('VFB_00000001')",
+    "vfb.get_term_info('VFB_00101567')",
+    "vfb.get_instances('FBbt_00003748', return_dataframe=False, force_refresh=True)",
+    "vfb.get_templates(return_dataframe=False)",
+]