vfbquery 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

test/term_info_queries_test.py

@@ -64,7 +64,7 @@ class TermInfoQueriesTest(unittest.TestCase):
 
         self.assertEqual(0, len(terminfo.xrefs))
 
-        self.assertEqual(6, len(terminfo.pub_syn))
+        self.assertEqual(7, 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]
@@ -145,7 +145,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([Spradling, 1993](FBrf0064777), [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([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,13 +166,10 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("examples" in serialized)
         self.assertFalse("thumbnail" in serialized)
         self.assertTrue("references" in serialized)
-        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(1, len(serialized["references"]))
         self.assertEqual({'link': '[King, 1970, Ovarian Development in Drosophila melanogaster. ](FBrf0021038)',
                           'refs': ['http://flybase.org/reports/FBrf0021038'],
-                          'types': ' pub'}, serialized["references"][1])
+                          'types': ' pub'}, serialized["references"][0])
         self.assertFalse("targetingSplits" in serialized)
         self.assertFalse("targetingNeurons" in serialized)
 
@@ -261,7 +258,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertTrue("Turner-Evans et al., 2020" in description)
         
         self.assertTrue("synonyms" in serialized)
-        self.assertEqual(9, len(serialized["synonyms"]))
+        self.assertEqual(10, len(serialized["synonyms"]))
         print(serialized["synonyms"][0])
         self.assertTrue("has_exact_synonym: EB-PB 1 glomerulus-D/Vgall neuron" in serialized["synonyms"])
         self.assertFalse("source" in serialized)
@@ -293,7 +290,7 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("thumbnail" in serialized)
 
         self.assertTrue("references" in serialized)
-        self.assertEqual(6, len(serialized["references"]))
+        self.assertEqual(7, len(serialized["references"]))
 
         self.assertTrue("targetingSplits" in serialized)
         self.assertEqual(6, len(serialized["targetingSplits"]))
@@ -527,6 +524,64 @@ class TermInfoQueriesTest(unittest.TestCase):
         self.assertFalse("filemeta" in serialized)
         self.assertFalse("template" in serialized)
 
+    def test_term_info_performance(self):
+        """
+        Performance test for specific term info queries.
+        Tests the execution time for FBbt_00003748 and VFB_00101567.
+        """
+        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
+        
+        # Print performance metrics for GitHub Actions logs
+        print(f"\n" + "="*50)
+        print(f"Performance Test Results:")
+        print(f"="*50)
+        print(f"FBbt_00003748 query took: {duration_1:.4f} seconds")
+        print(f"VFB_00101567 query took: {duration_2:.4f} seconds")
+        print(f"Total time for both queries: {duration_1 + duration_2:.4f} seconds")
+        
+        # Performance categories
+        total_time = duration_1 + duration_2
+        if total_time < 1.0:
+            performance_level = "🟢 Excellent (< 1 second)"
+        elif total_time < 2.0:
+            performance_level = "🟡 Good (1-2 seconds)"  
+        elif total_time < 4.0:
+            performance_level = "🟠 Acceptable (2-4 seconds)"
+        else:
+            performance_level = "🔴 Slow (> 4 seconds)"
+            
+        print(f"Performance Level: {performance_level}")
+        print(f"="*50)
+        
+        # Basic assertions to ensure the queries succeeded
+        self.assertIsNotNone(result_1, "FBbt_00003748 query returned None")
+        self.assertIsNotNone(result_2, "VFB_00101567 query returned None")
+        
+        # Performance assertions - fail if queries take too long
+        # These thresholds are based on observed performance characteristics
+        max_single_query_time = 2.0  # seconds
+        max_total_time = 4.0  # seconds (2 queries * 2 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")
+        self.assertLess(duration_2, max_single_query_time,
+                       f"VFB_00101567 query took {duration_2:.4f}s, exceeding {max_single_query_time}s threshold")
+        self.assertLess(duration_1 + duration_2, max_total_time,
+                       f"Total query time {duration_1 + duration_2:.4f}s exceeds {max_total_time}s threshold")
+        
+        # Log success
+        print("Performance test completed successfully!")
+
 
 class TestVariable:
 

test/test_default_caching.py

@@ -0,0 +1,173 @@
+"""
+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.
+"""
+
+import unittest
+import os
+import time
+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', 
+               'navis.plotting.vispy', 'navis.plotting.vispy.viewer']:
+    sys.modules[module] = MagicMock()
+
+# Set environment variables
+os.environ.update({
+    'MPLBACKEND': 'Agg',
+    'VISPY_GL_LIB': 'osmesa', 
+    'VISPY_USE_EGL': '0',
+    'VFBQUERY_CACHE_ENABLED': 'true'
+})
+
+
+class TestDefaultCaching(unittest.TestCase):
+    """Test default 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()
+        except ImportError:
+            pass
+    
+    def test_caching_enabled_by_default(self):
+        """Test that 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
+    
+    def test_cache_performance_improvement(self):
+        """Test that 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() 
+        result2 = vfbquery.get_term_info(test_term)
+        warm_time = time.time() - start_time
+        
+        # Verify cache hit
+        self.assertIsNotNone(result2)
+        self.assertEqual(result1, result2)  # Should be identical
+        
+        # Verify performance improvement (warm should be faster)
+        self.assertLess(warm_time, cold_time)
+        
+        # Check cache statistics
+        stats = vfbquery.get_vfbquery_cache_stats()
+        self.assertGreater(stats['hits'], 0)  # Should have cache hits
+        self.assertGreater(stats['hit_rate_percent'], 0)  # Positive hit rate
+    
+    def test_cache_statistics_tracking(self):
+        """Test that 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
+        unique_term = 'FBbt_00005106'  # Use a different term
+        result = vfbquery.get_term_info(unique_term)
+        self.assertIsNotNone(result)
+        
+        # Check that stats were updated
+        updated_stats = vfbquery.get_vfbquery_cache_stats()
+        updated_total = updated_stats['misses'] + updated_stats['hits']
+        
+        self.assertGreaterEqual(updated_stats['memory_cache_items'], initial_items)
+        self.assertGreater(updated_total, initial_total)  # More total requests
+        self.assertGreaterEqual(updated_stats['memory_cache_size_mb'], 0)
+    
+    def test_memory_size_tracking(self):
+        """Test that memory usage 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'])
+    
+    def test_cache_ttl_configuration(self):
+        """Test that 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
+    
+    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 activity
+        stats = vfbquery.get_vfbquery_cache_stats()
+        self.assertGreater(stats['misses'] + stats['hits'], 0)
+    
+    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 __name__ == '__main__':
+    unittest.main(verbosity=2)

test/test_examples_diff.py

@@ -113,7 +113,12 @@ def remove_nulls(data):
             new_dict[k] = cleaned
         return new_dict
     elif isinstance(data, list):
-        return [remove_nulls(item) for item in data if remove_nulls(item) not in [None, {}, []]]
+        filtered = []
+        for item in data:
+            cleaned_item = remove_nulls(item)
+            if cleaned_item is not None and cleaned_item != {} and cleaned_item != []:
+                filtered.append(cleaned_item)
+        return filtered
     return data
 
 def main():

vfbquery/__init__.py

@@ -1,4 +1,65 @@
 from .vfb_queries import *
 
+# Caching enhancements (optional import - don't break if dependencies missing)
+try:
+    from .cache_enhancements import (
+        enable_vfbquery_caching, 
+        disable_vfbquery_caching,
+        clear_vfbquery_cache,
+        get_vfbquery_cache_stats,
+        set_cache_ttl,
+        set_cache_memory_limit,
+        set_cache_max_items,
+        enable_disk_cache,
+        disable_disk_cache,
+        get_cache_config,
+        CacheConfig
+    )
+    from .cached_functions import (
+        get_term_info_cached,
+        get_instances_cached, 
+        patch_vfbquery_with_caching,
+        unpatch_vfbquery_caching
+    )
+    __caching_available__ = True
+    
+    # Enable caching by default with 3-month TTL and 2GB memory cache
+    import os
+    
+    # Check if caching should be disabled via environment variable
+    cache_disabled = os.getenv('VFBQUERY_CACHE_ENABLED', 'true').lower() in ('false', '0', 'no', 'off')
+    
+    if not cache_disabled:
+        # Enable caching with VFB_connect-like defaults
+        enable_vfbquery_caching(
+            cache_ttl_hours=2160,      # 3 months (90 days)
+            memory_cache_size_mb=2048, # 2GB memory cache
+            max_items=10000,           # Max 10k items as safeguard
+            disk_cache_enabled=True    # Persistent across sessions
+        )
+        
+        # Automatically patch existing functions for transparent caching
+        patch_vfbquery_with_caching()
+        
+        print("VFBquery: Caching enabled by default (3-month TTL, 2GB memory)")
+        print("         Disable with: export VFBQUERY_CACHE_ENABLED=false")
+    
+except ImportError:
+    __caching_available__ = False
+    print("VFBquery: Caching not available (dependencies missing)")
+
+# SOLR-based result caching (experimental - for cold start optimization)
+try:
+    from .solr_cache_integration import (
+        enable_solr_result_caching,
+        disable_solr_result_caching, 
+        warmup_solr_cache,
+        get_solr_cache_stats as get_solr_cache_stats_func,
+        cleanup_solr_cache
+    )
+    __solr_caching_available__ = True
+except ImportError:
+    __solr_caching_available__ = False
+
 # Version information
-__version__ = "0.3.3"
+__version__ = "0.4.0"