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

test/test_images_neurons.py

@@ -0,0 +1,152 @@
+"""
+Unit tests for the ImagesNeurons query.
+
+This tests the ImagesNeurons query which retrieves individual neuron images 
+(instances) with parts in a synaptic neuropil or domain.
+
+Test term: FBbt_00007401 (antennal lobe) - a synaptic neuropil
+"""
+
+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_images_neurons,
+    ImagesNeurons_to_schema,
+    get_term_info
+)
+
+
+class ImagesNeuronsTest(unittest.TestCase):
+    """Test cases for ImagesNeurons query"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.test_term = 'FBbt_00007401'  # antennal lobe - synaptic neuropil with individual images
+        
+    def test_get_images_neurons_execution(self):
+        """Test that get_images_neurons executes and returns results"""
+        result = get_images_neurons(self.test_term, return_dataframe=True, limit=3)
+        
+        # Should return a DataFrame
+        self.assertIsNotNone(result, "Result should not be None")
+        
+        # Check result type - handle both DataFrame and dict (from cache)
+        import pandas as pd
+        if isinstance(result, pd.DataFrame):
+            # DataFrame result
+            if len(result) > 0:
+                print(f"\n✓ Found {len(result)} individual neuron images for {self.test_term}")
+                
+                # Verify DataFrame has expected columns
+                self.assertIn('id', result.columns, "Result should have 'id' column")
+                self.assertIn('label', result.columns, "Result should have 'label' column")
+                
+                # Print first few results for verification
+                print("\nSample results:")
+                for idx, row in result.head(3).iterrows():
+                    print(f"  - {row.get('label', 'N/A')} ({row.get('id', 'N/A')})")
+            else:
+                print(f"\n⚠ No individual neuron images found for {self.test_term} (this may be expected)")
+        elif isinstance(result, dict):
+            # Dict result (from cache)
+            count = result.get('count', 0)
+            rows = result.get('rows', [])
+            print(f"\n✓ Found {count} total individual neuron images for {self.test_term} (showing {len(rows)})")
+            if rows:
+                print("\nSample results:")
+                for row in rows[:3]:
+                    print(f"  - {row.get('label', 'N/A')} ({row.get('id', 'N/A')})")
+        else:
+            self.fail(f"Unexpected result type: {type(result)}")
+    
+    def test_images_neurons_schema(self):
+        """Test that ImagesNeurons_to_schema generates correct schema"""
+        name = "antennal lobe"
+        take_default = {"short_form": self.test_term}
+        
+        schema = ImagesNeurons_to_schema(name, take_default)
+        
+        # Verify schema structure
+        self.assertEqual(schema.query, "ImagesNeurons")
+        self.assertEqual(schema.label, f"Images of neurons with some part in {name}")
+        self.assertEqual(schema.function, "get_images_neurons")
+        self.assertEqual(schema.preview, 5)
+        self.assertIn("id", schema.preview_columns)
+        self.assertIn("label", schema.preview_columns)
+        
+        print(f"\n✓ Schema generated correctly")
+        print(f"  Query: {schema.query}")
+        print(f"  Label: {schema.label}")
+        print(f"  Function: {schema.function}")
+    
+    def test_term_info_integration(self):
+        """Test that ImagesNeurons query appears in term_info for synaptic neuropils"""
+        term_info = get_term_info(self.test_term, preview=True)
+        
+        # Should have queries
+        self.assertIn('Queries', term_info, "term_info should have 'Queries' key")
+        
+        # Look for ImagesNeurons query
+        query_names = [q['query'] for q in term_info['Queries']]
+        print(f"\n✓ Queries available for {self.test_term}: {query_names}")
+        
+        if 'ImagesNeurons' in query_names:
+            images_query = next(q for q in term_info['Queries'] if q['query'] == 'ImagesNeurons')
+            print(f"✓ ImagesNeurons query found: {images_query['label']}")
+            
+            # Verify preview results if available
+            if 'preview_results' in images_query:
+                preview = images_query['preview_results']
+                # Handle both 'data' and 'rows' keys
+                data_key = 'data' if 'data' in preview else 'rows'
+                if data_key in preview and len(preview[data_key]) > 0:
+                    print(f"  Preview has {len(preview[data_key])} individual neuron images")
+                    print(f"  Sample: {preview[data_key][0]}")
+        else:
+            print(f"⚠ ImagesNeurons query not found in term_info")
+            print(f"  Available queries: {query_names}")
+            print(f"  SuperTypes: {term_info.get('SuperTypes', [])}")
+    
+    def test_images_neurons_preview(self):
+        """Test preview results format"""
+        result = get_images_neurons(self.test_term, return_dataframe=False, limit=5)
+        
+        # Should be a dict with specific structure
+        self.assertIsInstance(result, dict, "Result should be a dictionary")
+        self.assertIn('rows', result, "Result should have 'rows' key")
+        self.assertIn('headers', result, "Result should have 'headers' key")
+        self.assertIn('count', result, "Result should have 'count' key")
+        
+        if result['count'] > 0:
+            print(f"\n✓ Preview format validated")
+            print(f"  Total count: {result['count']}")
+            print(f"  Returned rows: {len(result['rows'])}")
+            print(f"  Headers: {list(result['headers'].keys())}")
+        else:
+            print(f"\n⚠ No results in preview (this may be expected)")
+    
+    def test_multiple_terms(self):
+        """Test query with multiple synaptic neuropil terms"""
+        test_terms = [
+            ('FBbt_00007401', 'antennal lobe'),
+            ('FBbt_00003982', 'medulla'),  # another synaptic neuropil
+        ]
+        
+        print("\n✓ Testing ImagesNeurons with multiple terms:")
+        for term_id, term_name in test_terms:
+            try:
+                result = get_images_neurons(term_id, return_dataframe=True, limit=10)
+                count = len(result) if result is not None else 0
+                print(f"  - {term_name} ({term_id}): {count} individual neuron images")
+            except Exception as e:
+                print(f"  - {term_name} ({term_id}): Error - {e}")
+
+
+if __name__ == '__main__':
+    # Run tests with verbose output
+    unittest.main(verbosity=2)

test/test_images_that_develop_from.py

@@ -0,0 +1,112 @@
+"""
+Test suite for ImagesThatDevelopFrom query.
+
+This query uses Owlery instances endpoint to find individual neuron images
+that develop from a specified neuroblast.
+"""
+
+import unittest
+import sys
+import os
+
+# Add src to path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from vfbquery.vfb_queries import (
+    get_images_that_develop_from,
+    get_term_info,
+    ImagesThatDevelopFrom_to_schema
+)
+
+
+class TestImagesThatDevelopFrom(unittest.TestCase):
+    """Test cases for ImagesThatDevelopFrom query functionality."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        # FBbt_00001419 is neuroblast MNB - has 336 neuron images that develop from it
+        self.test_neuroblast = "FBbt_00001419"  # neuroblast MNB
+        
+    def test_schema_generation(self):
+        """Test that the schema function generates correct Query object."""
+        schema = ImagesThatDevelopFrom_to_schema("test neuroblast", {"short_form": self.test_neuroblast})
+        
+        self.assertEqual(schema.query, "ImagesThatDevelopFrom")
+        self.assertEqual(schema.function, "get_images_that_develop_from")
+        self.assertIn("test neuroblast", schema.label)
+        self.assertEqual(schema.preview, 5)
+        self.assertIn("id", schema.preview_columns)
+        self.assertIn("thumbnail", schema.preview_columns)
+        
+    def test_get_images_that_develop_from_execution(self):
+        """Test that the query executes without errors."""
+        try:
+            # Execute query with limit to keep test fast
+            result = get_images_that_develop_from(self.test_neuroblast, return_dataframe=True, limit=10)
+            
+            # Result should be either a DataFrame or dict
+            self.assertIsNotNone(result)
+            
+            # If we get results, check structure
+            if hasattr(result, 'empty'):  # DataFrame
+                if not result.empty:
+                    self.assertIn('id', result.columns)
+                    self.assertIn('label', result.columns)
+            elif isinstance(result, dict):  # Dict format
+                # Check for either 'data' or 'rows' key
+                self.assertTrue('data' in result or 'rows' in result,
+                              "Result dict should have 'data' or 'rows' key")
+                
+            print(f"\n✅ ImagesThatDevelopFrom query executed successfully")
+            if isinstance(result, dict):
+                count = result.get('count', len(result.get('rows', result.get('data', []))))
+                print(f"  Result count: {count} neurons")
+            elif hasattr(result, 'shape'):
+                print(f"  Result count: {len(result)} neurons")
+                
+        except Exception as e:
+            self.fail(f"Query execution failed: {str(e)}")
+    
+    def test_return_dataframe_parameter(self):
+        """Test that return_dataframe parameter works correctly."""
+        # Test with return_dataframe=True
+        df_result = get_images_that_develop_from(self.test_neuroblast, return_dataframe=True, limit=5)
+        
+        # Test with return_dataframe=False
+        dict_result = get_images_that_develop_from(self.test_neuroblast, return_dataframe=False, limit=5)
+        
+        # Both should return valid results
+        self.assertIsNotNone(df_result)
+        self.assertIsNotNone(dict_result)
+        
+    def test_limit_parameter(self):
+        """Test that limit parameter restricts results."""
+        limited_result = get_images_that_develop_from(self.test_neuroblast, return_dataframe=True, limit=3)
+        
+        self.assertIsNotNone(limited_result)
+        
+        # If results exist, should respect limit
+        if hasattr(limited_result, '__len__') and len(limited_result) > 0:
+            self.assertLessEqual(len(limited_result), 3)
+    
+    def test_term_info_integration(self):
+        """Test that ImagesThatDevelopFrom appears in term_info for neuroblasts."""
+        # Get term info for a neuroblast
+        term_info = get_term_info(self.test_neuroblast, preview=False)
+        
+        self.assertIsNotNone(term_info)
+        
+        # Check if ImagesThatDevelopFrom query is in the queries list
+        # Note: This will only appear if the term has the correct supertypes
+        queries = term_info.get('Queries', [])
+        query_names = [q.get('query') for q in queries if isinstance(q, dict)]
+        
+        # ImagesThatDevelopFrom should appear for neuroblasts
+        if 'Neuroblast' in term_info.get('SuperTypes', []):
+            self.assertIn('ImagesThatDevelopFrom', query_names,
+                         "ImagesThatDevelopFrom should be available for neuroblast terms")
+            print(f"\n✓ ImagesThatDevelopFrom query found in term_info for {self.test_neuroblast}")
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

test/test_lineage_clones_in.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+Test suite for LineageClonesIn query.
+
+Tests the query that finds lineage clones that overlap with a synaptic neuropil.
+This implements the LineageClonesIn query from the VFB XMI specification.
+
+Test cases:
+1. Query execution with known neuropil
+2. Schema generation and validation
+3. Term info integration
+4. Preview results validation
+5. Cache functionality
+"""
+
+import unittest
+import sys
+import os
+
+# Add the src directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from vfbquery.vfb_queries import (
+    get_lineage_clones_in,
+    LineageClonesIn_to_schema,
+    get_term_info
+)
+
+
+class LineageClonesInTest(unittest.TestCase):
+    """Test suite for LineageClonesIn query"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Example synaptic neuropil: adult antennal lobe (FBbt_00007401)
+        self.test_neuropil = "FBbt_00007401"  # antennal lobe
+        
+    def test_query_execution(self):
+        """Test that the query executes successfully"""
+        print(f"\n=== Testing LineageClonesIn query execution ===")
+        
+        # Execute the query
+        result = get_lineage_clones_in(self.test_neuropil, return_dataframe=False, limit=5)
+        
+        # Validate result structure
+        self.assertIsNotNone(result, "Query should return a result")
+        self.assertIsInstance(result, dict, "Result should be a dictionary")
+        
+        # Check for expected keys
+        if result:
+            print(f"Query returned {len(result.get('data', []))} results")
+            
+            # Validate data structure
+            if 'data' in result and len(result['data']) > 0:
+                first_result = result['data'][0]
+                self.assertIn('id', first_result, "Result should contain 'id' field")
+                self.assertIn('label', first_result, "Result should contain 'label' field")
+                print(f"First result: {first_result.get('label', 'N/A')} ({first_result.get('id', 'N/A')})")
+            else:
+                print("No results found (this is OK if no clones overlap this neuropil)")
+        
+    def test_schema_generation(self):
+        """Test schema function generates correct structure"""
+        print(f"\n=== Testing LineageClonesIn schema generation ===")
+        
+        test_name = "Test Neuropil"
+        test_takes = {"short_form": self.test_neuropil}
+        
+        schema = LineageClonesIn_to_schema(test_name, test_takes)
+        
+        # Validate schema structure
+        self.assertIsNotNone(schema, "Schema should not be None")
+        self.assertEqual(schema.query, "LineageClonesIn", "Query name should match")
+        self.assertEqual(schema.label, f"Lineage clones found in {test_name}", "Label should be formatted correctly")
+        self.assertEqual(schema.function, "get_lineage_clones_in", "Function name should match")
+        self.assertEqual(schema.preview, 5, "Preview should be 10")
+        
+        # Check preview columns
+        expected_columns = ["id", "label", "tags", "thumbnail"]
+        self.assertEqual(schema.preview_columns, expected_columns, f"Preview columns should be {expected_columns}")
+        
+        print(f"Schema generated successfully: {schema.label}")
+        
+    def test_term_info_integration(self):
+        """Test that query appears in term info for appropriate terms"""
+        print(f"\n=== Testing term info integration ===")
+        
+        # Get term info for a synaptic neuropil
+        term_info = get_term_info(self.test_neuropil, preview=False)
+        
+        self.assertIsNotNone(term_info, "Term info should not be None")
+        self.assertIn("Queries", term_info, "Term info should contain Queries")
+        
+        # Check if our query is present
+        queries = term_info.get("Queries", [])
+        query_names = [q.get('query') for q in queries]
+        
+        print(f"Available queries for {self.test_neuropil}: {query_names}")
+        
+        # For synaptic neuropils, this query should be available
+        if "Synaptic_neuropil" in term_info.get("SuperTypes", []) or \
+           "Synaptic_neuropil_domain" in term_info.get("SuperTypes", []):
+            self.assertIn("LineageClonesIn", query_names, 
+                         "LineageClonesIn should be available for Synaptic_neuropil")
+            print("✓ Query correctly appears for Synaptic_neuropil type")
+        else:
+            print(f"Warning: {self.test_neuropil} does not have Synaptic_neuropil type")
+            print(f"SuperTypes: {term_info.get('SuperTypes', [])}")
+    
+    def test_preview_results(self):
+        """Test that preview results are properly formatted"""
+        print(f"\n=== Testing preview results ===")
+        
+        # Get term info with preview enabled
+        term_info = get_term_info(self.test_neuropil, preview=True)
+        
+        self.assertIsNotNone(term_info, "Term info should not be None")
+        
+        # Find our query in the results
+        queries = term_info.get("Queries", [])
+        clones_query = None
+        for q in queries:
+            if q.get('query') == "LineageClonesIn":
+                clones_query = q
+                break
+        
+        if clones_query:
+            print(f"Found LineageClonesIn query")
+            
+            # Check if preview_results exist
+            if clones_query.get('preview_results'):
+                preview = clones_query['preview_results']
+                data_key = 'data' if 'data' in preview else 'rows'
+                print(f"Preview contains {len(preview.get(data_key, []))} results")
+                
+                # Validate preview structure
+                self.assertIn(data_key, preview, f"Preview should contain '{data_key}' key")
+                self.assertIn('headers', preview, "Preview should contain 'headers' key")
+                
+                # Check first result if available
+                if preview.get(data_key) and len(preview[data_key]) > 0:
+                    first_result = preview[data_key][0]
+                    print(f"First preview result: {first_result.get('label', 'N/A')}")
+                    
+                    # Validate required fields
+                    self.assertIn('id', first_result, "Preview result should have 'id'")
+                    self.assertIn('label', first_result, "Preview result should have 'label'")
+            else:
+                print("No preview results available (this is OK if no clones overlap this neuropil)")
+        else:
+            print("LineageClonesIn query not found in term info")
+    
+    def test_with_different_neuropils(self):
+        """Test with multiple synaptic neuropil types"""
+        print(f"\n=== Testing with different neuropils ===")
+        
+        test_neuropils = [
+            ("FBbt_00007401", "antennal lobe"),
+            ("FBbt_00003982", "medulla"),
+            ("FBbt_00003679", "mushroom body"),
+        ]
+        
+        for neuropil_id, neuropil_name in test_neuropils:
+            print(f"\nTesting {neuropil_name} ({neuropil_id})...")
+            
+            try:
+                result = get_lineage_clones_in(neuropil_id, return_dataframe=False, limit=3)
+                
+                if result and 'data' in result:
+                    print(f"  ✓ Query successful, found {len(result['data'])} results")
+                else:
+                    print(f"  ✓ Query successful, no results found")
+                    
+            except Exception as e:
+                print(f"  ✗ Query failed: {str(e)}")
+                # Don't fail the test, just log the error
+                # raise
+
+
+def run_tests():
+    """Run the test suite"""
+    suite = unittest.TestLoader().loadTestsFromTestCase(LineageClonesInTest)
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    return result.wasSuccessful()
+
+
+if __name__ == '__main__':
+    success = run_tests()
+    sys.exit(0 if success else 1)

test/test_nblast_queries.py

@@ -0,0 +1,124 @@
+"""
+Unit tests for NBLAST similarity queries.
+
+This tests all 6 NBLAST-related queries:
+1. get_similar_morphology - NBLAST matches
+2. get_similar_morphology_part_of - NBLASTexp to expression patterns
+3. get_similar_morphology_part_of_exp - Reverse NBLASTexp
+4. get_similar_morphology_nb - NeuronBridge matches
+5. get_similar_morphology_nb_exp - NeuronBridge for expression patterns
+6. get_similar_morphology_userdata - User upload NBLAST from SOLR
+
+Test terms:
+- VFB_00101567 - has NBLAST matches
+- VFB_00050000 - example neuron with NBLASTexp
+"""
+
+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_similar_morphology,
+    get_similar_morphology_part_of,
+    get_similar_morphology_part_of_exp,
+    get_similar_morphology_nb,
+    get_similar_morphology_nb_exp,
+    get_similar_morphology_userdata,
+    SimilarMorphologyTo_to_schema,
+    SimilarMorphologyToPartOf_to_schema,
+    SimilarMorphologyToPartOfexp_to_schema,
+    SimilarMorphologyToNB_to_schema,
+    SimilarMorphologyToNBexp_to_schema,
+    SimilarMorphologyToUserData_to_schema
+)
+
+
+class NBLASTQueriesTest(unittest.TestCase):
+    """Test cases for NBLAST similarity queries"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.nblast_term = 'VFB_00101567'  # Has NBLAST matches
+        self.neuron_term = 'VFB_00050000'  # Example neuron
+        
+    def test_get_similar_morphology(self):
+        """Test get_similar_morphology query"""
+        result = get_similar_morphology(self.nblast_term, return_dataframe=True, limit=5)
+        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)} NBLAST matches for {self.nblast_term}")
+            self.assertIn('id', result.columns)
+            self.assertIn('label', result.columns)
+            self.assertIn('score', result.columns)
+            
+    def test_get_similar_morphology_formatted(self):
+        """Test get_similar_morphology with formatted output"""
+        result = get_similar_morphology(self.nblast_term, return_dataframe=False, limit=3)
+        self.assertIsNotNone(result)
+        
+        if isinstance(result, dict):
+            self.assertIn('headers', result)
+            self.assertIn('rows', result)
+            
+    def test_get_similar_morphology_part_of(self):
+        """Test get_similar_morphology_part_of (NBLASTexp)"""
+        result = get_similar_morphology_part_of(self.neuron_term, return_dataframe=True, limit=5)
+        self.assertIsNotNone(result)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} NBLASTexp matches for {self.neuron_term}")
+            
+    def test_get_similar_morphology_part_of_exp(self):
+        """Test get_similar_morphology_part_of_exp (reverse NBLASTexp)"""
+        result = get_similar_morphology_part_of_exp(self.neuron_term, return_dataframe=True, limit=5)
+        self.assertIsNotNone(result)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} reverse NBLASTexp matches")
+            
+    def test_get_similar_morphology_nb(self):
+        """Test get_similar_morphology_nb (NeuronBridge)"""
+        result = get_similar_morphology_nb(self.neuron_term, return_dataframe=True, limit=5)
+        self.assertIsNotNone(result)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} NeuronBridge matches")
+            self.assertIn('score', result.columns)
+            
+    def test_get_similar_morphology_nb_exp(self):
+        """Test get_similar_morphology_nb_exp (NeuronBridge for expression)"""
+        result = get_similar_morphology_nb_exp(self.neuron_term, return_dataframe=True, limit=5)
+        self.assertIsNotNone(result)
+        
+    def test_schema_functions_exist(self):
+        """Test that all NBLAST schema functions exist and are callable"""
+        schema_functions = [
+            SimilarMorphologyTo_to_schema,
+            SimilarMorphologyToPartOf_to_schema,
+            SimilarMorphologyToPartOfexp_to_schema,
+            SimilarMorphologyToNB_to_schema,
+            SimilarMorphologyToNBexp_to_schema,
+            SimilarMorphologyToUserData_to_schema
+        ]
+        
+        for func in schema_functions:
+            self.assertTrue(callable(func), f"{func.__name__} should be callable")
+            
+    def test_empty_results_handling(self):
+        """Test that queries handle empty results gracefully"""
+        # Use a term unlikely to have NBLAST matches
+        result = get_similar_morphology('FBbt_00000001', return_dataframe=True, limit=5)
+        self.assertIsNotNone(result)
+
+
+if __name__ == '__main__':
+    unittest.main()