Implement neuron region connectivity query and update documentation

Author: Robbie1977

VFB_QUERIES_REFERENCE.md

@@ -770,15 +770,61 @@ When implementing a new query, ensure:
 - **Query Chain**: Neo4j → Neo4j Pass → SOLR → Process
 - **Status**: ❌ **NOT IMPLEMENTED**
 
-#### 22. **neuron_region_connectivity_query** ❌
+#### 22. **neuron_region_connectivity_query** ✅
 - **ID**: `ref_neuron_region_connectivity_query` / `compound_neuron_region_connectivity_query`
 - **Name**: "Show connectivity to regions from Neuron X"
 - **Description**: "Show connectivity per region for $NAME"
 - **Matching Criteria**: Region_connectivity
 - **Query Chain**: Neo4j compound query → Process
-- **Status**: ❌ **NOT IMPLEMENTED**
+- **Status**: ✅ **FULLY IMPLEMENTED** (November 2025)
+
+**Implementation**:
+- Schema: `NeuronRegionConnectivityQuery_to_schema()`
+- Execution: `get_neuron_region_connectivity(term_id, return_dataframe=True, limit=-1)`
+- Preview: 5 results
+- Preview Columns: id, region, presynaptic_terminals, postsynaptic_terminals, tags
+- **Relationships**: Uses `has_presynaptic_terminals_in` and `has_postsynaptic_terminal_in`
+- **Terminology**: Uses VFB site conventions - "Brain Region", "Presynaptic Terminals", "Postsynaptic Terminals"
 
-#### 23. **neuron_neuron_connectivity_query** ❌
+**Parameters**:
+- `term_id`: Short form of the neuron (Individual)
+- `return_dataframe`: Returns pandas DataFrame if True, otherwise returns formatted dict (default: True)
+- `limit`: Maximum number of results to return (default: -1 for all results)
+
+**Cypher Query** (from XMI spec):
+```cypher
+MATCH (primary:Individual {short_form: $NAME})
+MATCH (target:Individual)<-[r:has_presynaptic_terminals_in|has_postsynaptic_terminal_in]-(primary)
+WITH DISTINCT collect(properties(r)) + {} as props, target, primary
+WITH apoc.map.removeKeys(apoc.map.merge(props[0], props[1]), 
+     ['iri', 'short_form', 'Related', 'label', 'type']) as synapse_counts,
+     target, primary
+RETURN 
+    target.short_form AS id,
+    target.label AS region,
+    synapse_counts.`pre` AS presynaptic_terminals,
+    synapse_counts.`post` AS postsynaptic_terminals,
+    target.uniqueFacets AS tags
+```
+
+**Expected Output Structure**:
+```python
+{
+  'headers': {
+    'id': {'title': 'Region ID', 'type': 'selection_id', 'order': -1},
+    'region': {'title': 'Brain Region', 'type': 'markdown', 'order': 0},
+    'presynaptic_terminals': {'title': 'Presynaptic Terminals', 'type': 'number', 'order': 1},
+    'postsynaptic_terminals': {'title': 'Postsynaptic Terminals', 'type': 'number', 'order': 2},
+    'tags': {'title': 'Region Types', 'type': 'list', 'order': 3},
+  },
+  'data': [...],
+  'count': <number>
+}
+```
+
+---
+
+#### 23. **neuron_neuron_connectivity_query** ✅
 
 ---
 

src/test/test_expression_pattern_fragments.py

@@ -4,8 +4,8 @@
 This query uses Owlery instances endpoint to find individual expression pattern
 fragment images that are part of a specified expression pattern.
 
-TODO: Query needs fixing - returns 0 results for known test cases.
-Example: VFBexp_FBtp0022557 should have image VFB_00008416 but query returns 0 results.
+FIXED: Query now works correctly with proper IRI resolution for VFBexp_* IDs.
+Example: VFBexp_FBtp0022557 returns image VFB_00008416 as expected.
 """
 
 import unittest
@@ -28,9 +28,9 @@ class TestExpressionPatternFragments(unittest.TestCase):
 
     def setUp(self):
         """Set up test fixtures."""
-        # TODO: Query needs fixing - VFBexp_FBtp0022557 has image VFB_00008416 but returns 0 results
-        # epFrag should find individual fragments (Expression_pattern_fragment) that are part_of a Class Expression_pattern
-        self.test_expression_pattern = "VFBexp_FBtp0022557"  # P{VGlut-GAL4.D} expression pattern (should have VFB_00008416)
+        # Expression pattern that has known fragments
+        # epFrag finds individual fragments (Expression_pattern_fragment) that are part_of a Class Expression_pattern
+        self.test_expression_pattern = "VFBexp_FBtp0022557"  # P{VGlut-GAL4.D} expression pattern (has VFB_00008416)
 
     def test_schema_generation(self):
         """Test that the schema function generates correct Query object."""
@@ -44,19 +44,23 @@ def test_schema_generation(self):
         self.assertIn("thumbnail", schema.preview_columns)
 
     def test_expression_pattern_fragments_execution(self):
-        """Test that expression pattern fragments query executes without errors."""
+        """Test that expression pattern fragments query executes and returns results."""
         result = get_expression_pattern_fragments(self.test_expression_pattern)
 
         self.assertIsNotNone(result)
         # Result can be dict or DataFrame
         if isinstance(result, dict):
             self.assertIn('count', result)
-            # TODO: Should return at least 1 result (VFB_00008416) but currently returns 0
-            # Query implementation needs debugging
-            self.assertGreaterEqual(result['count'], 0)
+            # Should return at least 1 result (VFB_00008416)
+            self.assertGreater(result['count'], 0, 
+                             f"Expected at least 1 result for {self.test_expression_pattern}")
+            print(f"\n✓ Query returned {result['count']} expression pattern fragments")
         else:
             # DataFrame
             self.assertIsInstance(result, pd.DataFrame)
+            self.assertGreater(len(result), 0, 
+                             f"Expected at least 1 result for {self.test_expression_pattern}")
+            print(f"\n✓ Query returned {len(result)} expression pattern fragments")
 
     def test_return_dataframe_parameter(self):
         """Test that return_dataframe parameter works correctly."""

src/vfbquery/vfb_queries.py

@@ -2287,6 +2287,64 @@ def get_neuron_neuron_connectivity(short_form: str, return_dataframe=True, limit
     }
 
 
+@with_solr_cache('neuron_region_connectivity_query')
+def get_neuron_region_connectivity(short_form: str, return_dataframe=True, limit: int = -1):
+    """
+    Retrieves brain regions where the specified neuron has synaptic terminals.
+    
+    This implements the neuron_region_connectivity_query from the VFB XMI specification.
+    Query chain (from XMI): Neo4j compound query → process
+    Matching criteria: Individual + has_region_connectivity
+    
+    Uses has_presynaptic_terminals_in and has_postsynaptic_terminal_in relationships
+    to find brain regions where the neuron makes connections.
+    
+    :param short_form: short form of the neuron (Individual)
+    :param return_dataframe: Returns pandas dataframe if true, otherwise returns formatted dict
+    :param limit: maximum number of results to return (default -1, returns all results)
+    :return: Brain regions with presynaptic and postsynaptic terminal counts
+    """
+    # Build Cypher query based on XMI spec pattern
+    cypher = f"""
+    MATCH (primary:Individual {{short_form: '{short_form}'}})
+    MATCH (target:Individual)<-[r:has_presynaptic_terminals_in|has_postsynaptic_terminal_in]-(primary)
+    WITH DISTINCT collect(properties(r)) + {{}} as props, target, primary
+    WITH apoc.map.removeKeys(apoc.map.merge(props[0], props[1]), ['iri', 'short_form', 'Related', 'label', 'type']) as synapse_counts,
+         target,
+         primary
+    RETURN 
+        target.short_form AS id,
+        target.label AS region,
+        synapse_counts.`pre` AS presynaptic_terminals,
+        synapse_counts.`post` AS postsynaptic_terminals,
+        target.uniqueFacets AS tags
+    """
+    if limit != -1:
+        cypher += f" LIMIT {limit}"
+
+    # Run query using Neo4j client
+    results = vc.nc.commit_list([cypher])
+    rows = get_dict_cursor()(results)
+    
+    # Format output
+    if return_dataframe:
+        df = pd.DataFrame(rows)
+        return df
+    
+    headers = {
+        'id': {'title': 'Region ID', 'type': 'selection_id', 'order': -1},
+        'region': {'title': 'Brain Region', 'type': 'markdown', 'order': 0},
+        'presynaptic_terminals': {'title': 'Presynaptic Terminals', 'type': 'number', 'order': 1},
+        'postsynaptic_terminals': {'title': 'Postsynaptic Terminals', 'type': 'number', 'order': 2},
+        'tags': {'title': 'Region Types', 'type': 'list', 'order': 3},
+    }
+    return {
+        'headers': headers,
+        'data': rows,
+        'count': len(rows)
+    }
+
+
 @with_solr_cache('images_neurons')
 def get_images_neurons(short_form: str, return_dataframe=True, limit: int = -1):
     """