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

test/test_neuron_classes_fasciculating.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+Test suite for NeuronClassesFasciculatingHere query.
+
+Tests the query that finds neuron classes that fasciculate with (run along) tracts or nerves.
+This implements the NeuronClassesFasciculatingHere query from the VFB XMI specification.
+
+Test cases:
+1. Query execution with known tract
+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_neuron_classes_fasciculating_here,
+    NeuronClassesFasciculatingHere_to_schema,
+    get_term_info
+)
+
+
+class NeuronClassesFasciculatingTest(unittest.TestCase):
+    """Test suite for NeuronClassesFasciculatingHere query"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Example tract/nerve: broad root (FBbt_00003987) - a neuron projection bundle
+        self.test_tract = "FBbt_00003987"  # broad root
+        
+    def test_query_execution(self):
+        """Test that the query executes successfully"""
+        print(f"\n=== Testing NeuronClassesFasciculatingHere query execution ===")
+        
+        # Execute the query
+        result = get_neuron_classes_fasciculating_here(self.test_tract, 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')})")
+        
+    def test_schema_generation(self):
+        """Test schema function generates correct structure"""
+        print(f"\n=== Testing NeuronClassesFasciculatingHere schema generation ===")
+        
+        test_name = "Test Tract"
+        test_takes = {"short_form": self.test_tract}
+        
+        schema = NeuronClassesFasciculatingHere_to_schema(test_name, test_takes)
+        
+        # Validate schema structure
+        self.assertIsNotNone(schema, "Schema should not be None")
+        self.assertEqual(schema.query, "NeuronClassesFasciculatingHere", "Query name should match")
+        self.assertEqual(schema.label, f"Neurons fasciculating in {test_name}", "Label should be formatted correctly")
+        self.assertEqual(schema.function, "get_neuron_classes_fasciculating_here", "Function name should match")
+        self.assertEqual(schema.preview, 5, "Preview should be 5")
+        
+        # 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 tract/nerve
+        term_info = get_term_info(self.test_tract, 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_tract}: {query_names}")
+        
+        # For tracts/nerves (Neuron_projection_bundle), this query should be available
+        if "Neuron_projection_bundle" in term_info.get("SuperTypes", []):
+            self.assertIn("NeuronClassesFasciculatingHere", query_names, 
+                         "NeuronClassesFasciculatingHere should be available for Neuron_projection_bundle")
+            print("✓ Query correctly appears for Neuron_projection_bundle type")
+        else:
+            print(f"Warning: {self.test_tract} does not have Neuron_projection_bundle 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_tract, preview=True)
+        
+        self.assertIsNotNone(term_info, "Term info should not be None")
+        
+        # Find our query in the results
+        queries = term_info.get("Queries", [])
+        fasciculating_query = None
+        for q in queries:
+            if q.get('query') == "NeuronClassesFasciculatingHere":
+                fasciculating_query = q
+                break
+        
+        if fasciculating_query:
+            print(f"Found NeuronClassesFasciculatingHere query")
+            
+            # Check if preview_results exist
+            if fasciculating_query.get('preview_results'):
+                preview = fasciculating_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 matching neurons exist)")
+        else:
+            print("NeuronClassesFasciculatingHere query not found in term info")
+    
+    def test_with_different_tracts(self):
+        """Test with multiple tract/nerve types"""
+        print(f"\n=== Testing with different tracts/nerves ===")
+        
+        test_tracts = [
+            ("FBbt_00003987", "broad root"),
+            ("FBbt_00007354", "adult antenno-subesophageal tract"),
+            ("FBbt_00003985", "adult medial antennal lobe tract"),
+        ]
+        
+        for tract_id, tract_name in test_tracts:
+            print(f"\nTesting {tract_name} ({tract_id})...")
+            
+            try:
+                result = get_neuron_classes_fasciculating_here(tract_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(NeuronClassesFasciculatingTest)
+    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_neuron_inputs.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Test suite for NeuronInputsTo query.
+
+Tests the query that finds neurons with synapses into a specified neuron.
+This implements the NeuronInputsTo query from the VFB XMI specification.
+
+Test cases:
+1. Query execution with known neuron
+2. Schema generation and validation
+3. Term info integration
+4. Preview results validation (ribbon format)
+5. Neurotransmitter information validation
+"""
+
+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_individual_neuron_inputs,
+    NeuronInputsTo_to_schema,
+    get_term_info
+)
+
+class NeuronInputsTest(unittest.TestCase):
+    """Test suite for NeuronInputsTo query"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Test neuron: LPC1 (FlyEM-HB:1775513344) [VFB_jrchk00s]
+        self.test_neuron = "VFB_jrchk00s"
+
+    def test_query_execution(self):
+        """Test that the query executes successfully"""
+        print(f"\n=== Testing NeuronInputsTo execution ===")
+        result = get_individual_neuron_inputs(
+            self.test_neuron, 
+            return_dataframe=False, 
+            limit=5
+        )
+        self.assertIsNotNone(result, "Query should return a result")
+        self.assertIsInstance(result, dict, "Result should be a dictionary")
+        print(f"Query returned {result.get('count', 0)} total results")
+        
+        if 'rows' in result and len(result['rows']) > 0:
+            first_result = result['rows'][0]
+            self.assertIn('id', first_result, "Result should contain 'id' field")
+            self.assertIn('Neurotransmitter', first_result, "Result should contain 'Neurotransmitter' field")
+            self.assertIn('Weight', first_result, "Result should contain 'Weight' field")
+            print(f"First result: {first_result.get('Neurotransmitter', 'N/A')} (weight: {first_result.get('Weight', 0)})")
+        else:
+            print("No input neurons found (this is OK if none exist)")
+
+    def test_schema_generation(self):
+        """Test that the schema function works correctly"""
+        print(f"\n=== Testing NeuronInputsTo schema generation ===")
+        
+        # Get term info for the test neuron
+        term_info = get_term_info(self.test_neuron)
+        if term_info:
+            neuron_name = term_info.get('Name', self.test_neuron)
+        else:
+            neuron_name = self.test_neuron
+        
+        # Generate schema
+        schema = NeuronInputsTo_to_schema(neuron_name, self.test_neuron)
+        
+        # Validate schema structure
+        self.assertIsNotNone(schema, "Schema should not be None")
+        self.assertEqual(schema.query, "NeuronInputsTo", "Query name should match")
+        self.assertEqual(schema.function, "get_individual_neuron_inputs", "Function name should match")
+        # NeuronInputsTo uses ribbon format with preview=-1 (all results)
+        self.assertEqual(schema.preview, -1, "Preview should show all results (ribbon format)")
+        self.assertIn("Neurotransmitter", schema.preview_columns, "Preview should include 'Neurotransmitter' column")
+        self.assertIn("Weight", schema.preview_columns, "Preview should include 'Weight' column")
+        
+        print(f"Schema label: {schema.label}")
+        print(f"Preview columns: {schema.preview_columns}")
+        print(f"Output format: ribbon (preview={schema.preview})")
+
+    def test_term_info_integration(self):
+        """Test that term info lookup works for the test neuron"""
+        print(f"\n=== Testing term_info integration ===")
+        term_info = get_term_info(self.test_neuron)
+        
+        self.assertIsNotNone(term_info, "Term info should not be None")
+        if term_info:
+            # get_term_info returns a dict with 'Name', 'Id', 'Tags', etc.
+            self.assertIn('Name', term_info, "Term info should contain 'Name'")
+            self.assertIn('Id', term_info, "Term info should contain 'Id'")
+            print(f"Neuron name: {term_info.get('Name', 'N/A')}")
+            print(f"Neuron tags: {term_info.get('Tags', [])}")
+        else:
+            print(f"Note: Term info not found for {self.test_neuron} (may not be in SOLR)")
+
+    def test_preview_validation(self):
+        """Test that preview results are properly formatted"""
+        print(f"\n=== Testing preview results ===")
+        result = get_individual_neuron_inputs(
+            self.test_neuron,
+            return_dataframe=False,
+            limit=5
+        )
+        
+        if 'rows' in result and len(result['rows']) > 0:
+            # Check that all expected columns exist in the results
+            expected_columns = ['id', 'Neurotransmitter', 'Weight', 'Name']
+            for item in result['rows']:
+                for col in expected_columns:
+                    self.assertIn(col, item, f"Result should contain '{col}' field")
+            
+            print(f"✓ All {len(result['rows'])} results have required columns")
+            
+            # Print sample results
+            for i, item in enumerate(result['rows'][:3], 1):
+                print(f"{i}. {item.get('Name', 'N/A')} - {item.get('Neurotransmitter', 'N/A')} (weight: {item.get('Weight', 0)})")
+        else:
+            print("No preview data available (query returned no results)")
+
+    def test_neurotransmitter_info(self):
+        """Test that neurotransmitter information is included"""
+        print(f"\n=== Testing neurotransmitter information ===")
+        result = get_individual_neuron_inputs(
+            self.test_neuron,
+            return_dataframe=False,
+            limit=10
+        )
+        
+        if 'rows' in result and len(result['rows']) > 0:
+            # Check that neurotransmitter field exists and has values
+            neurotransmitters = set()
+            for row in result['rows']:
+                nt = row.get('Neurotransmitter', '')
+                if nt:
+                    neurotransmitters.add(nt)
+            
+            print(f"✓ Found {len(neurotransmitters)} different neurotransmitter type(s)")
+            if neurotransmitters:
+                print(f"  Types: {', '.join(list(neurotransmitters)[:5])}")
+        else:
+            print("No results to check neurotransmitter information")
+
+    def test_summary_mode(self):
+        """Test that summary mode works correctly"""
+        print(f"\n=== Testing summary mode ===")
+        result = get_individual_neuron_inputs(
+            self.test_neuron,
+            return_dataframe=False,
+            summary_mode=True
+        )
+        
+        self.assertIsNotNone(result, "Summary mode should return a result")
+        self.assertIsInstance(result, dict, "Result should be a dictionary")
+        
+        if 'rows' in result and len(result['rows']) > 0:
+            # In summary mode, results are grouped by neurotransmitter type
+            print(f"✓ Summary mode returned {len(result['rows'])} neurotransmitter types")
+            for i, item in enumerate(result['rows'][:3], 1):
+                print(f"{i}. {item.get('Neurotransmitter', 'N/A')} - Total weight: {item.get('Weight', 0)}")
+        else:
+            print("No summary data available")
+
+    def test_dataframe_output(self):
+        """Test that DataFrame output format works"""
+        print(f"\n=== Testing DataFrame output ===")
+        result = get_individual_neuron_inputs(
+            self.test_neuron,
+            return_dataframe=True,
+            limit=5
+        )
+        
+        # Should return a pandas DataFrame
+        import pandas as pd
+        self.assertIsInstance(result, pd.DataFrame, "Should return DataFrame when return_dataframe=True")
+        
+        if not result.empty:
+            # Check for expected columns
+            expected_columns = ['id', 'Neurotransmitter', 'Weight']
+            for col in expected_columns:
+                self.assertIn(col, result.columns, f"DataFrame should contain '{col}' column")
+            
+            print(f"✓ DataFrame has {len(result)} rows and {len(result.columns)} columns")
+            print(f"  Columns: {list(result.columns)}")
+        else:
+            print("DataFrame is empty (no input neurons found)")
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

test/test_neuron_neuron_connectivity.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+Test suite for NeuronNeuronConnectivityQuery.
+
+Tests the query that finds neurons connected to a given neuron.
+This implements the neuron_neuron_connectivity_query from the VFB XMI specification.
+
+Test cases:
+1. Query execution with known neuron
+2. Schema generation and validation
+3. Term info integration (if applicable)
+4. Preview results validation
+"""
+
+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_neuron_neuron_connectivity,
+    NeuronNeuronConnectivityQuery_to_schema,
+    get_term_info
+)
+
+class NeuronNeuronConnectivityTest(unittest.TestCase):
+    """Test suite for neuron_neuron_connectivity_query"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Test neuron: LPC1 (FlyEM-HB:1775513344) [VFB_jrchk00s]
+        self.test_neuron = "VFB_jrchk00s"
+
+    def test_query_execution(self):
+        """Test that the query executes successfully"""
+        print(f"\n=== Testing neuron_neuron_connectivity_query execution ===")
+        result = get_neuron_neuron_connectivity(self.test_neuron, return_dataframe=False, limit=5)
+        self.assertIsNotNone(result, "Query should return a result")
+        self.assertIsInstance(result, dict, "Result should be a dictionary")
+        print(f"Query returned {result.get('count', 0)} results")
+        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 connected neurons found (this is OK if none exist)")
+
+    def test_schema_generation(self):
+        """Test schema function generates correct structure"""
+        print(f"\n=== Testing neuron_neuron_connectivity_query schema generation ===")
+        test_name = "LPC1"
+        test_takes = {"short_form": self.test_neuron}
+        schema = NeuronNeuronConnectivityQuery_to_schema(test_name, test_takes)
+        self.assertIsNotNone(schema, "Schema should not be None")
+        self.assertEqual(schema.query, "NeuronNeuronConnectivityQuery", "Query name should match")
+        self.assertEqual(schema.label, f"Neurons connected to {test_name}", "Label should be formatted correctly")
+        self.assertEqual(schema.function, "get_neuron_neuron_connectivity", "Function name should match")
+        self.assertEqual(schema.preview, 5, "Preview should be 5")
+        expected_columns = ["id", "label", "outputs", "inputs", "tags"]
+        self.assertEqual(schema.preview_columns, expected_columns, f"Preview columns should be {expected_columns}")
+        print(f"Schema generated successfully: {schema.label}")
+
+    def test_preview_results(self):
+        """Test that preview results are properly formatted"""
+        print(f"\n=== Testing preview results ===")
+        result = get_neuron_neuron_connectivity(self.test_neuron, return_dataframe=False, limit=3)
+        self.assertIsNotNone(result, "Query should return a result")
+        if 'data' in result and len(result['data']) > 0:
+            first_result = result['data'][0]
+            self.assertIn('id', first_result, "Preview result should have 'id'")
+            self.assertIn('label', first_result, "Preview result should have 'label'")
+            print(f"First preview result: {first_result.get('label', 'N/A')}")
+        else:
+            print("No preview results available (this is OK if no connected neurons exist)")
+
+
+def run_tests():
+    """Run the test suite"""
+    suite = unittest.TestLoader().loadTestsFromTestCase(NeuronNeuronConnectivityTest)
+    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_neuron_region_connectivity.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""
+Test suite for NeuronRegionConnectivityQuery.
+
+Tests the query that shows connectivity to regions from a given neuron.
+This implements the neuron_region_connectivity_query from the VFB XMI specification.
+
+Test cases:
+1. Query execution with known neuron
+2. Schema generation and validation
+3. Term info integration (if applicable)
+4. Preview results validation
+"""
+
+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_neuron_region_connectivity,
+    NeuronRegionConnectivityQuery_to_schema,
+    get_term_info
+)
+
+class NeuronRegionConnectivityTest(unittest.TestCase):
+    """Test suite for neuron_region_connectivity_query"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Test neuron: LPC1 (FlyEM-HB:1775513344) [VFB_jrchk00s]
+        self.test_neuron = "VFB_jrchk00s"
+
+    def test_query_execution(self):
+        """Test that the query executes successfully"""
+        print(f"\n=== Testing neuron_region_connectivity_query execution ===")
+        result = get_neuron_region_connectivity(self.test_neuron, return_dataframe=False, limit=5)
+        self.assertIsNotNone(result, "Query should return a result")
+        self.assertIsInstance(result, dict, "Result should be a dictionary")
+        print(f"Query returned {result.get('count', 0)} results")
+        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('region', first_result, "Result should contain 'region' field")
+            self.assertIn('presynaptic_terminals', first_result, "Result should contain 'presynaptic_terminals' field")
+            self.assertIn('postsynaptic_terminals', first_result, "Result should contain 'postsynaptic_terminals' field")
+            print(f"First result: {first_result.get('region', 'N/A')} ({first_result.get('id', 'N/A')})")
+            print(f"  Pre: {first_result.get('presynaptic_terminals', 0)}, Post: {first_result.get('postsynaptic_terminals', 0)}")
+        else:
+            print("No regions with connectivity found (this is OK if none exist)")
+
+    def test_schema_generation(self):
+        """Test that the schema function works correctly"""
+        print(f"\n=== Testing NeuronRegionConnectivityQuery schema generation ===")
+        
+        # Get term info for the test neuron
+        term_info = get_term_info(self.test_neuron)
+        if term_info:
+            neuron_name = term_info.get('Name', self.test_neuron)
+        else:
+            neuron_name = self.test_neuron
+        
+        # Generate schema
+        schema = NeuronRegionConnectivityQuery_to_schema(neuron_name, self.test_neuron)
+        
+        # Validate schema structure
+        self.assertIsNotNone(schema, "Schema should not be None")
+        self.assertEqual(schema.query, "NeuronRegionConnectivityQuery", "Query name should match")
+        self.assertEqual(schema.function, "get_neuron_region_connectivity", "Function name should match")
+        self.assertEqual(schema.preview, 5, "Preview should show 5 results")
+        self.assertIn("region", schema.preview_columns, "Preview should include 'region' column")
+        self.assertIn("presynaptic_terminals", schema.preview_columns, "Preview should include 'presynaptic_terminals' column")
+        self.assertIn("postsynaptic_terminals", schema.preview_columns, "Preview should include 'postsynaptic_terminals' column")
+        
+        print(f"Schema label: {schema.label}")
+        print(f"Preview columns: {schema.preview_columns}")
+
+    def test_term_info_integration(self):
+        """Test that term info lookup works for the test neuron"""
+        print(f"\n=== Testing term_info integration ===")
+        term_info = get_term_info(self.test_neuron)
+        
+        self.assertIsNotNone(term_info, "Term info should not be None")
+        if term_info:
+            # get_term_info returns a dict with 'Name', 'Id', 'Tags', etc.
+            self.assertIn('Name', term_info, "Term info should contain 'Name'")
+            self.assertIn('Id', term_info, "Term info should contain 'Id'")
+            print(f"Neuron name: {term_info.get('Name', 'N/A')}")
+            print(f"Neuron tags: {term_info.get('Tags', [])}")
+        else:
+            print(f"Note: Term info not found for {self.test_neuron} (may not be in SOLR)")
+
+    def test_preview_validation(self):
+        """Test that preview results are properly formatted"""
+        print(f"\n=== Testing preview results ===")
+        result = get_neuron_region_connectivity(self.test_neuron, return_dataframe=False, limit=5)
+        
+        if 'data' in result and len(result['data']) > 0:
+            # Check that all preview columns exist in the results
+            expected_columns = ['id', 'region', 'presynaptic_terminals', 'postsynaptic_terminals', 'tags']
+            for item in result['data']:
+                for col in expected_columns:
+                    self.assertIn(col, item, f"Result should contain '{col}' field")
+            
+            print(f"✓ All {len(result['data'])} results have required preview columns")
+            
+            # Print sample results
+            for i, item in enumerate(result['data'][:3], 1):
+                print(f"{i}. {item.get('region', 'N/A')} - Pre:{item.get('presynaptic_terminals', 0)}, Post:{item.get('postsynaptic_terminals', 0)}")
+        else:
+            print("No preview data available (query returned no results)")
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)