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

test/test_neurons_part_here.py

@@ -0,0 +1,204 @@
+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)
+        # Allowing tolerance for data updates
+        self.expected_count = 471
+        self.count_tolerance = 5  # Allow ±5 for data updates
+
+    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 = abs(actual_count - self.expected_count)
+        
+        print(f"Expected: {self.expected_count} results")
+        print(f"Actual: {actual_count} results")
+        print(f"Difference: {count_diff}")
+        
+        # Allow some tolerance for data updates
+        self.assertLessEqual(
+            count_diff, 
+            self.count_tolerance,
+            f"Result count {actual_count} differs from expected {self.expected_count} by more than {self.count_tolerance}"
+        )
+        
+        if count_diff > 0:
+            print(f"⚠ Count differs by {count_diff} (within tolerance of {self.count_tolerance})")
+        else:
+            print(f"✓ Exact count match: {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)

test/test_new_owlery_queries.py

@@ -0,0 +1,282 @@
+"""
+Tests for newly implemented Owlery-based queries:
+- NeuronsSynaptic
+- NeuronsPresynapticHere
+- NeuronsPostsynapticHere
+- ComponentsOf
+- PartsOf
+- SubclassesOf
+"""
+
+import unittest
+from vfbquery.vfb_queries import (
+    get_neurons_with_synapses_in,
+    get_neurons_with_presynaptic_terminals_in,
+    get_neurons_with_postsynaptic_terminals_in,
+    get_components_of,
+    get_parts_of,
+    get_subclasses_of,
+    get_term_info
+)
+
+
+class TestNeuronsSynaptic(unittest.TestCase):
+    """Tests for NeuronsSynaptic query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - synaptic neuropil
+    
+    def test_neurons_synaptic_returns_results(self):
+        """Test that NeuronsSynaptic query returns results for medulla"""
+        result = get_neurons_with_synapses_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_neurons_synaptic_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_neurons_with_synapses_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_neurons_synaptic_in_term_info(self):
+        """Test that NeuronsSynaptic appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Neurons with synaptic terminals in {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestNeuronsPresynapticHere(unittest.TestCase):
+    """Tests for NeuronsPresynapticHere query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - synaptic neuropil
+    
+    def test_neurons_presynaptic_returns_results(self):
+        """Test that NeuronsPresynapticHere query returns results for medulla"""
+        result = get_neurons_with_presynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_neurons_presynaptic_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_neurons_with_presynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_neurons_presynaptic_in_term_info(self):
+        """Test that NeuronsPresynapticHere appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Neurons with presynaptic terminals in {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestNeuronsPostsynapticHere(unittest.TestCase):
+    """Tests for NeuronsPostsynapticHere query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - synaptic neuropil
+    
+    def test_neurons_postsynaptic_returns_results(self):
+        """Test that NeuronsPostsynapticHere query returns results for medulla"""
+        result = get_neurons_with_postsynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_neurons_postsynaptic_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_neurons_with_postsynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_neurons_postsynaptic_in_term_info(self):
+        """Test that NeuronsPostsynapticHere appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Neurons with postsynaptic terminals in {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestComponentsOf(unittest.TestCase):
+    """Tests for ComponentsOf query"""
+    
+    def setUp(self):
+        self.clone_id = 'FBbt_00110369'  # adult SLPpm4 lineage clone
+    
+    def test_components_of_returns_results(self):
+        """Test that ComponentsOf query returns results for clone"""
+        result = get_components_of(
+            self.clone_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_components_of_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_components_of(
+            self.clone_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_components_of_in_term_info(self):
+        """Test that ComponentsOf appears in term_info queries"""
+        term_info = get_term_info(self.clone_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Components of {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestPartsOf(unittest.TestCase):
+    """Tests for PartsOf query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - any Class
+    
+    def test_parts_of_returns_results(self):
+        """Test that PartsOf query returns results for medulla"""
+        result = get_parts_of(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_parts_of_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_parts_of(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_parts_of_in_term_info(self):
+        """Test that PartsOf appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Parts of {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestSubclassesOf(unittest.TestCase):
+    """Tests for SubclassesOf query"""
+    
+    def setUp(self):
+        self.wedge_pn_id = 'FBbt_00048516'  # wedge projection neuron (>45 subclasses)
+    
+    def test_subclasses_of_returns_results(self):
+        """Test that SubclassesOf query returns results for wedge projection neuron"""
+        result = get_subclasses_of(
+            self.wedge_pn_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_subclasses_of_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_subclasses_of(
+            self.wedge_pn_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_subclasses_of_in_term_info(self):
+        """Test that SubclassesOf appears in term_info queries"""
+        term_info = get_term_info(self.wedge_pn_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Subclasses of {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+if __name__ == '__main__':
+    unittest.main()

test/test_publication_transgene_queries.py

@@ -0,0 +1,101 @@
+"""
+Unit tests for publication and transgene queries.
+
+This tests:
+1. get_terms_for_pub - Terms referencing a publication
+2. get_transgene_expression_here - Complex transgene expression query
+
+Test terms:
+- DOI_10_7554_eLife_04577 - Example publication
+- FBbt_00003748 - mushroom body (for transgene expression)
+"""
+
+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_terms_for_pub,
+    get_transgene_expression_here,
+    TermsForPub_to_schema,
+    TransgeneExpressionHere_to_schema
+)
+
+
+class PublicationTransgeneQueriesTest(unittest.TestCase):
+    """Test cases for publication and transgene queries"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.pub_term = 'DOI_10_7554_eLife_04577'  # Example publication
+        self.anatomy_term = 'FBbt_00003748'  # mushroom body
+        
+    def test_get_terms_for_pub(self):
+        """Test get_terms_for_pub query"""
+        result = get_terms_for_pub(self.pub_term, return_dataframe=True, limit=10)
+        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)} terms for publication {self.pub_term}")
+            self.assertIn('id', result.columns)
+            self.assertIn('label', result.columns)
+            
+    def test_get_terms_for_pub_formatted(self):
+        """Test get_terms_for_pub with formatted output"""
+        result = get_terms_for_pub(self.pub_term, return_dataframe=False, limit=5)
+        self.assertIsNotNone(result)
+        
+        if isinstance(result, dict):
+            self.assertIn('headers', result)
+            self.assertIn('rows', result)
+            
+    def test_get_transgene_expression_here(self):
+        """Test get_transgene_expression_here query"""
+        result = get_transgene_expression_here(self.anatomy_term, return_dataframe=True, limit=10)
+        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)} transgene expressions in {self.anatomy_term}")
+            self.assertIn('id', result.columns)
+            
+    def test_get_transgene_expression_formatted(self):
+        """Test get_transgene_expression_here with formatted output"""
+        result = get_transgene_expression_here(self.anatomy_term, return_dataframe=False, limit=5)
+        self.assertIsNotNone(result)
+        
+        if isinstance(result, dict):
+            self.assertIn('headers', result)
+            self.assertIn('rows', result)
+            
+    def test_schema_functions_exist(self):
+        """Test that publication/transgene schema functions exist and are callable"""
+        schema_functions = [
+            TermsForPub_to_schema,
+            TransgeneExpressionHere_to_schema
+        ]
+        
+        for func in schema_functions:
+            self.assertTrue(callable(func), f"{func.__name__} should be callable")
+            
+    def test_limit_parameter(self):
+        """Test that limit parameter works correctly"""
+        result = get_terms_for_pub(self.pub_term, return_dataframe=True, limit=3)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            self.assertLessEqual(len(result), 3, "Result should respect limit parameter")
+            
+    def test_empty_results_handling(self):
+        """Test that queries handle empty results gracefully"""
+        # Use a term unlikely to have references
+        result = get_terms_for_pub('INVALID_PUB_123', return_dataframe=True, limit=5)
+        self.assertIsNotNone(result)
+
+
+if __name__ == '__main__':
+    unittest.main()