vfbquery 0.3.4__tar.gz → 0.4.0__tar.gz

{vfbquery-0.3.4 → vfbquery-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vfbquery
-Version: 0.3.4
+Version: 0.4.0
 Summary: Wrapper for querying VirtualFlyBrain knowledge graph.
 Home-page: https://github.com/VirtualFlyBrain/VFBquery
 Author: VirtualFlyBrain
@@ -117,25 +117,25 @@ vfb.get_term_info('FBbt_00003748')
                   "id": "VFB_00102107",
                   "label": "[ME on JRC2018Unisex adult brain](VFB_00102107)",
                   "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
-                  "thumbnail": "[![ME on JRC2018Unisex adult brain aligned to JRC2018U](http://www.virtualflybrain.org/data/VFB/i/0010/2107/VFB_00101567/thumbnail.png 'ME on JRC2018Unisex adult brain aligned to JRC2018U')](VFB_00101567,VFB_00102107)"
+                  "thumbnail": "[![ME on JRC2018Unisex adult brain aligned to JRC2018Unisex](http://www.virtualflybrain.org/data/VFB/i/0010/2107/VFB_00101567/thumbnail.png 'ME on JRC2018Unisex adult brain aligned to JRC2018Unisex')](VFB_00101567,VFB_00102107)"
                },
                {
                   "id": "VFB_00101385",
                   "label": "[ME%28R%29 on JRC_FlyEM_Hemibrain](VFB_00101385)",
                   "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
-                  "thumbnail": "[![ME%28R%29 on JRC_FlyEM_Hemibrain aligned to JRCFIB2018Fum](http://www.virtualflybrain.org/data/VFB/i/0010/1385/VFB_00101384/thumbnail.png 'ME(R) on JRC_FlyEM_Hemibrain aligned to JRCFIB2018Fum')](VFB_00101384,VFB_00101385)"
+                  "thumbnail": "[![ME(R) on JRC_FlyEM_Hemibrain aligned to JRC_FlyEM_Hemibrain](http://www.virtualflybrain.org/data/VFB/i/0010/1385/VFB_00101384/thumbnail.png 'ME(R) on JRC_FlyEM_Hemibrain aligned to JRC_FlyEM_Hemibrain')](VFB_00101384,VFB_00101385)"
                },
                {
                   "id": "VFB_00030810",
                   "label": "[medulla on adult brain template Ito2014](VFB_00030810)",
-                  "tags": "Nervous_system|Visual_system|Adult|Synaptic_neuropil_domain",
+                  "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
                   "thumbnail": "[![medulla on adult brain template Ito2014 aligned to adult brain template Ito2014](http://www.virtualflybrain.org/data/VFB/i/0003/0810/VFB_00030786/thumbnail.png 'medulla on adult brain template Ito2014 aligned to adult brain template Ito2014')](VFB_00030786,VFB_00030810)"
                },
                {
                   "id": "VFB_00030624",
                   "label": "[medulla on adult brain template JFRC2](VFB_00030624)",
-                  "tags": "Nervous_system|Visual_system|Adult|Synaptic_neuropil_domain",
-                  "thumbnail": "[![medulla on adult brain template JFRC2 aligned to JFRC2](http://www.virtualflybrain.org/data/VFB/i/0003/0624/VFB_00017894/thumbnail.png 'medulla on adult brain template JFRC2 aligned to JFRC2')](VFB_00017894,VFB_00030624)"
+                  "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
+                  "thumbnail": "[![medulla on adult brain template JFRC2 aligned to adult brain template JFRC2](http://www.virtualflybrain.org/data/VFB/i/0003/0624/VFB_00017894/thumbnail.png 'medulla on adult brain template JFRC2 aligned to adult brain template JFRC2')](VFB_00017894,VFB_00030624)"
                }
             ]
          },

{vfbquery-0.3.4 → vfbquery-0.4.0}/README.md

@@ -97,25 +97,25 @@ vfb.get_term_info('FBbt_00003748')
                   "id": "VFB_00102107",
                   "label": "[ME on JRC2018Unisex adult brain](VFB_00102107)",
                   "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
-                  "thumbnail": "[![ME on JRC2018Unisex adult brain aligned to JRC2018U](http://www.virtualflybrain.org/data/VFB/i/0010/2107/VFB_00101567/thumbnail.png 'ME on JRC2018Unisex adult brain aligned to JRC2018U')](VFB_00101567,VFB_00102107)"
+                  "thumbnail": "[![ME on JRC2018Unisex adult brain aligned to JRC2018Unisex](http://www.virtualflybrain.org/data/VFB/i/0010/2107/VFB_00101567/thumbnail.png 'ME on JRC2018Unisex adult brain aligned to JRC2018Unisex')](VFB_00101567,VFB_00102107)"
                },
                {
                   "id": "VFB_00101385",
                   "label": "[ME%28R%29 on JRC_FlyEM_Hemibrain](VFB_00101385)",
                   "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
-                  "thumbnail": "[![ME%28R%29 on JRC_FlyEM_Hemibrain aligned to JRCFIB2018Fum](http://www.virtualflybrain.org/data/VFB/i/0010/1385/VFB_00101384/thumbnail.png 'ME(R) on JRC_FlyEM_Hemibrain aligned to JRCFIB2018Fum')](VFB_00101384,VFB_00101385)"
+                  "thumbnail": "[![ME(R) on JRC_FlyEM_Hemibrain aligned to JRC_FlyEM_Hemibrain](http://www.virtualflybrain.org/data/VFB/i/0010/1385/VFB_00101384/thumbnail.png 'ME(R) on JRC_FlyEM_Hemibrain aligned to JRC_FlyEM_Hemibrain')](VFB_00101384,VFB_00101385)"
                },
                {
                   "id": "VFB_00030810",
                   "label": "[medulla on adult brain template Ito2014](VFB_00030810)",
-                  "tags": "Nervous_system|Visual_system|Adult|Synaptic_neuropil_domain",
+                  "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
                   "thumbnail": "[![medulla on adult brain template Ito2014 aligned to adult brain template Ito2014](http://www.virtualflybrain.org/data/VFB/i/0003/0810/VFB_00030786/thumbnail.png 'medulla on adult brain template Ito2014 aligned to adult brain template Ito2014')](VFB_00030786,VFB_00030810)"
                },
                {
                   "id": "VFB_00030624",
                   "label": "[medulla on adult brain template JFRC2](VFB_00030624)",
-                  "tags": "Nervous_system|Visual_system|Adult|Synaptic_neuropil_domain",
-                  "thumbnail": "[![medulla on adult brain template JFRC2 aligned to JFRC2](http://www.virtualflybrain.org/data/VFB/i/0003/0624/VFB_00017894/thumbnail.png 'medulla on adult brain template JFRC2 aligned to JFRC2')](VFB_00017894,VFB_00030624)"
+                  "tags": "Nervous_system|Adult|Visual_system|Synaptic_neuropil_domain",
+                  "thumbnail": "[![medulla on adult brain template JFRC2 aligned to adult brain template JFRC2](http://www.virtualflybrain.org/data/VFB/i/0003/0624/VFB_00017894/thumbnail.png 'medulla on adult brain template JFRC2 aligned to adult brain template JFRC2')](VFB_00017894,VFB_00030624)"
                }
             ]
          },
@@ -1292,4 +1292,4 @@ vfb.get_templates(return_dataframe=False)
    ],
    "count": 10
 }
-```
+```

{vfbquery-0.3.4 → vfbquery-0.4.0}/setup.py

@@ -3,7 +3,7 @@ from os import path
 
 here = path.abspath(path.dirname(__file__))
 
-__version__ = "0.3.4"
+__version__ = "0.4.0"
 
 # Get the long description from the README file
 with open(path.join(here, 'README.md')) as f:

{vfbquery-0.3.4 → vfbquery-0.4.0}/src/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.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:
 

vfbquery-0.4.0/src/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)

{vfbquery-0.3.4 → vfbquery-0.4.0}/src/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-0.4.0/src/vfbquery/__init__.py

@@ -0,0 +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.4.0"