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

test/readme_parser.py

@@ -27,7 +27,35 @@ def extract_code_blocks(readme_path):
         # Look for vfb.* calls and extract them
         vfb_calls = re.findall(r'(vfb\.[^)]*\))', block)
         if vfb_calls:
-            processed_python_blocks.extend(vfb_calls)
+            # Add force_refresh=True to each call to ensure fresh data in tests
+            # Exceptions:
+            # - 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)'
+                    else:
+                        # Has parameters: vfb.function(param1, param2)
+                        modified_call = call[:-1] + ', force_refresh=True)'
+                    processed_python_blocks.append(modified_call)
+                else:
+                    # Shouldn't happen, but include original call if no parentheses
+                    processed_python_blocks.append(call)
     
     # Process JSON blocks
     processed_json_blocks = []

test/term_info_queries_test.py

@@ -524,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.5:
+            performance_level = "🟢 Excellent (< 1.5 seconds)"
+        elif total_time < 3.0:
+            performance_level = "🟡 Good (1.5-3 seconds)"  
+        elif total_time < 6.0:
+            performance_level = "🟠 Acceptable (3-6 seconds)"
+        else:
+            performance_level = "🔴 Slow (> 6 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 = 3.0  # seconds (increased from 2.0 to account for SOLR cache overhead)
+        max_total_time = 6.0  # seconds (2 queries * 3 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,86 @@
 from .vfb_queries import *
+from .solr_result_cache import get_solr_cache
+
+# 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)")
+
+# Convenience function for clearing SOLR cache entries
+def clear_solr_cache(query_type: str, term_id: str) -> bool:
+    """
+    Clear a specific SOLR cache entry to force refresh
+    
+    Args:
+        query_type: Type of query ('term_info', 'instances', etc.)
+        term_id: Term identifier (e.g., 'FBbt_00003748')
+    
+    Returns:
+        True if successfully cleared, False otherwise
+    
+    Example:
+        >>> import vfbquery as vfb
+        >>> vfb.clear_solr_cache('term_info', 'FBbt_00003748')
+        >>> result = vfb.get_term_info('FBbt_00003748')  # Will fetch fresh data
+    """
+    cache = get_solr_cache()
+    return cache.clear_cache_entry(query_type, term_id)
+
+# 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.4"
+__version__ = "0.4.1"