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

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)

test/test_neurons_part_here.py

@@ -0,0 +1,203 @@
+import unittest
+import sys
+import os
+
+# Add src to path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from vfbquery.vfb_queries import get_neurons_with_part_in, get_term_info
+
+
+class NeuronsPartHereTest(unittest.TestCase):
+    """Test suite for NeuronsPartHere query implementation"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.medulla_id = 'FBbt_00003748'
+        # Expected count based on VFB data (as of test creation)
+        # Data can grow over time, so we test for minimum expected count
+        self.expected_count = 470  # Minimum expected count (actual was 472)
+        self.count_tolerance = 5    # Allow some tolerance for variations
+
+    def test_neurons_part_here_returns_results(self):
+        """Test that NeuronsPartHere query returns results for medulla"""
+        print("\n" + "=" * 80)
+        print("Testing NeuronsPartHere query - Basic functionality")
+        print("=" * 80)
+        
+        results_df = get_neurons_with_part_in(
+            self.medulla_id, 
+            return_dataframe=True, 
+            limit=-1
+        )
+        
+        self.assertIsNotNone(results_df, "Results should not be None")
+        self.assertGreater(len(results_df), 0, "Should return at least one result")
+        
+        print(f"✓ Query returned {len(results_df)} neuron classes")
+
+    def test_neurons_part_here_result_count(self):
+        """Test that NeuronsPartHere returns expected number of results for medulla"""
+        print("\n" + "=" * 80)
+        print(f"Testing NeuronsPartHere result count (expected ~{self.expected_count})")
+        print("=" * 80)
+        
+        results_df = get_neurons_with_part_in(
+            self.medulla_id, 
+            return_dataframe=True, 
+            limit=-1
+        )
+        
+        actual_count = len(results_df)
+        count_diff = actual_count - self.expected_count
+        
+        print(f"Expected: at least {self.expected_count} results")
+        print(f"Actual: {actual_count} results")
+        
+        # Data can grow over time, so we require at least the expected minimum
+        self.assertGreaterEqual(
+            actual_count, 
+            self.expected_count,
+            f"Result count {actual_count} is less than expected minimum {self.expected_count}"
+        )
+        
+        if count_diff > 0:
+            print(f"✓ Count increased by {count_diff} (data growth)")
+        else:
+            print(f"✓ Minimum count met: {actual_count}")
+
+    def test_neurons_part_here_result_structure(self):
+        """Test that results have the expected structure with required columns"""
+        print("\n" + "=" * 80)
+        print("Testing NeuronsPartHere result structure")
+        print("=" * 80)
+        
+        results_df = get_neurons_with_part_in(
+            self.medulla_id, 
+            return_dataframe=True, 
+            limit=5
+        )
+        
+        # Check required columns
+        required_columns = ['id', 'label', 'tags', 'thumbnail']
+        for col in required_columns:
+            self.assertIn(col, results_df.columns, f"Column '{col}' should be present")
+        
+        print(f"✓ All required columns present: {', '.join(required_columns)}")
+        
+        # Check that we have data in the columns
+        first_row = results_df.iloc[0]
+        self.assertIsNotNone(first_row['id'], "ID should not be None")
+        self.assertIsNotNone(first_row['label'], "Label should not be None")
+        
+        print(f"✓ Sample result: {first_row['label']}")
+
+    def test_neurons_part_here_has_examples(self):
+        """Test that neuron class results include example images (thumbnails)"""
+        print("\n" + "=" * 80)
+        print("Testing NeuronsPartHere includes example images")
+        print("=" * 80)
+        
+        results_df = get_neurons_with_part_in(
+            self.medulla_id, 
+            return_dataframe=True, 
+            limit=10
+        )
+        
+        # Count how many results have thumbnails
+        has_thumbnails = results_df['thumbnail'].notna().sum()
+        total_results = len(results_df)
+        
+        print(f"Results with thumbnails: {has_thumbnails}/{total_results}")
+        
+        # At least some results should have thumbnails (example instances)
+        self.assertGreater(
+            has_thumbnails, 
+            0,
+            "At least some neuron classes should have example images"
+        )
+        
+        # Show example thumbnails
+        sample_with_thumbnail = results_df[results_df['thumbnail'].notna()].iloc[0]
+        print(f"\n✓ Example with thumbnail:")
+        print(f"  {sample_with_thumbnail['label']}")
+        print(f"  Thumbnail: {sample_with_thumbnail['thumbnail'][:100]}...")
+
+    def test_neurons_part_here_preview_in_term_info(self):
+        """Test that NeuronsPartHere query appears with preview results in term_info"""
+        print("\n" + "=" * 80)
+        print("Testing NeuronsPartHere preview results in term_info")
+        print("=" * 80)
+        
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIsNotNone(term_info, "term_info should not be None")
+        self.assertIn('Queries', term_info, "term_info should have Queries")
+        
+        # Find NeuronsPartHere query
+        neurons_part_here_query = None
+        for query in term_info.get('Queries', []):
+            if query.get('query') == 'NeuronsPartHere':
+                neurons_part_here_query = query
+                break
+        
+        self.assertIsNotNone(
+            neurons_part_here_query,
+            "NeuronsPartHere query should be present in term_info"
+        )
+        
+        print(f"✓ NeuronsPartHere query found")
+        print(f"  Label: {neurons_part_here_query.get('label', 'Unknown')}")
+        print(f"  Preview limit: {neurons_part_here_query.get('preview', 0)}")
+        
+        # Check preview results
+        preview_results = neurons_part_here_query.get('preview_results', {})
+        preview_rows = preview_results.get('rows', [])
+        
+        self.assertGreater(
+            len(preview_rows),
+            0,
+            "Preview results should be populated"
+        )
+        
+        print(f"  Preview results: {len(preview_rows)} items")
+        
+        # Check that preview results include thumbnails
+        with_thumbnails = sum(1 for row in preview_rows if row.get('thumbnail', ''))
+        print(f"  Results with example images: {with_thumbnails}/{len(preview_rows)}")
+        
+        self.assertGreater(
+            with_thumbnails,
+            0,
+            "At least some preview results should have example images"
+        )
+        
+        print(f"\n✓ Preview includes example images")
+
+    def test_neurons_part_here_limit_parameter(self):
+        """Test that the limit parameter works correctly"""
+        print("\n" + "=" * 80)
+        print("Testing NeuronsPartHere limit parameter")
+        print("=" * 80)
+        
+        limit = 10
+        results_df = get_neurons_with_part_in(
+            self.medulla_id, 
+            return_dataframe=True, 
+            limit=limit
+        )
+        
+        actual_count = len(results_df)
+        
+        self.assertLessEqual(
+            actual_count,
+            limit,
+            f"Result count {actual_count} should not exceed limit {limit}"
+        )
+        
+        print(f"✓ Limit parameter working: requested {limit}, got {actual_count}")
+
+
+if __name__ == '__main__':
+    # Run tests with verbose output
+    unittest.main(verbosity=2)