Remove ExpressionOverlapsHere — canonical name is AnatomyExpressedIn

Per the XMI cleanup: the v2 XMI no longer carries a CompoundRefQuery
id="ExpressionOverlapsHere", so the wire-side alias here is dead
weight. Drop it cleanly:

- ha_api.QUERY_TYPE_MAP: remove the "ExpressionOverlapsHere" key.
- vfb_queries.py: remove the ExpressionOverlapsHere_to_schema module
  alias; AnatomyExpressedIn_to_schema is the sole entry point.
- Strip the now-stale "renamed from / legacy alias" comments at the
  two schema emit sites and in the function docstring.
- Tests: delete src/test/test_expression_overlaps.py and replace
  with src/test/test_anatomy_expressed_in.py. The schema test now
  asserts the legacy alias is *absent* (hasattr False); a new wire-
  mapping test asserts QUERY_TYPE_MAP carries AnatomyExpressedIn
  only. Perf test label updated to match.
- get_expression_overlaps_here function body unchanged (inverse-
  direction Cypher landed in v1.13.6); only naming/comments and the
  docstring shrink.

Pre-existing bookmarks against ?q=...,ExpressionOverlapsHere stop
resolving — intentional. There is no v2 production URL that
exercises that path (Clare's URL was a one-off from the audit) and
the XMI side no longer publishes the id either.

TransgeneExpressionHere is untouched.

Author: Robbie1977

src/test/test_expression_overlaps.py src/test/test_anatomy_expressed_in.pysrc/test/test_expression_overlaps.py renamed to src/test/test_anatomy_expressed_in.py

@@ -1,13 +1,13 @@
 """
-Test suite for ExpressionOverlapsHere query (get_expression_overlaps_here).
+Test suite for AnatomyExpressedIn query (get_expression_overlaps_here).
 
-INVERSE-direction query as of VFBquery v1.13.6 — given an expression
-pattern, return the anatomy classes whose Individuals overlap with the
-pattern's Individuals. The forward direction (anatomy -> expression
-patterns) is now solely owned by TransgeneExpressionHere.
+INVERSE-direction query — given an expression pattern, return the anatomy
+classes whose Individuals overlap with the pattern's Individuals. The
+forward direction (anatomy -> expression patterns) is solely owned by
+TransgeneExpressionHere.
 
 XMI Source: https://raw.githubusercontent.com/VirtualFlyBrain/geppetto-vfb/master/model/vfb.xmi
-Query: ExpressionOverlapsHere ("Anatomy $NAME is expressed in")
+Query: AnatomyExpressedIn ("Anatomy where $NAME is expressed")
 """
 
 import unittest
@@ -20,174 +20,173 @@
 from vfbquery import vfb_queries as vq
 
 
-class TestExpressionOverlapsHere(unittest.TestCase):
+class TestAnatomyExpressedIn(unittest.TestCase):
     """Test cases for get_expression_overlaps_here function"""
 
-    def test_expression_overlaps_basic_dataframe(self):
+    def test_anatomy_expressed_in_basic_dataframe(self):
         """Test basic query returns DataFrame with expected columns"""
-        # Test with adult brain (FBbt_00003982) - known to have expression patterns
         result = vq.get_expression_overlaps_here('VFBexp_FBtp0001321', return_dataframe=True)
-        
+
         self.assertIsInstance(result, pd.DataFrame, "Should return pandas DataFrame")
-        
+
         if not result.empty:
-            # Check for expected columns
             expected_columns = ['id', 'name', 'tags', 'pubs']
             for col in expected_columns:
                 self.assertIn(col, result.columns, f"DataFrame should contain '{col}' column")
-            
-            # Verify data types
+
             self.assertTrue(all(isinstance(x, str) for x in result['id']), "IDs should be strings")
             self.assertTrue(all(isinstance(x, str) for x in result['name']), "Names should be strings")
-            
-            print(f"\n✓ Found {len(result)} expression patterns overlapping FBbt_00003982")
-            print(f"✓ Sample results: {result.head(3)[['id', 'name']].to_dict('records')}")
 
-    def test_expression_overlaps_formatted_output(self):
+            print(f"\nFound {len(result)} anatomy classes where VFBexp_FBtp0001321 is expressed")
+            print(f"Sample results: {result.head(3)[['id', 'name']].to_dict('records')}")
+
+    def test_anatomy_expressed_in_formatted_output(self):
         """Test query returns properly formatted dictionary output"""
         result = vq.get_expression_overlaps_here('VFBexp_FBtp0001321', return_dataframe=False)
-        
+
         self.assertIsInstance(result, dict, "Should return dictionary when return_dataframe=False")
-        
-        # Check structure
+
         self.assertIn('headers', result, "Result should contain 'headers'")
         self.assertIn('rows', result, "Result should contain 'rows'")
         self.assertIn('count', result, "Result should contain 'count'")
-        
-        # Check headers structure
+
         headers = result['headers']
         expected_headers = ['id', 'name', 'tags', 'pubs']
         for header in expected_headers:
             self.assertIn(header, headers, f"Headers should contain '{header}'")
             self.assertIn('title', headers[header], f"Header '{header}' should have 'title'")
             self.assertIn('type', headers[header], f"Header '{header}' should have 'type'")
             self.assertIn('order', headers[header], f"Header '{header}' should have 'order'")
-        
-        # Verify header types
+
         self.assertEqual(headers['id']['type'], 'selection_id')
         self.assertEqual(headers['name']['type'], 'markdown')
         self.assertEqual(headers['tags']['type'], 'tags')
         self.assertEqual(headers['pubs']['type'], 'metadata')
-        
+
         if result['rows']:
-            # Check row structure
             first_row = result['rows'][0]
             for key in expected_headers:
                 self.assertIn(key, first_row, f"Row should contain '{key}'")
-            
-            print(f"\n✓ Formatted output contains {result['count']} expression patterns")
-            print(f"✓ Sample row keys: {list(first_row.keys())}")
 
-    def test_expression_overlaps_limit(self):
+            print(f"\nFormatted output contains {result['count']} anatomy classes")
+            print(f"Sample row keys: {list(first_row.keys())}")
+
+    def test_anatomy_expressed_in_limit(self):
         """Test limit parameter restricts number of results"""
         limit = 3
         result = vq.get_expression_overlaps_here('VFBexp_FBtp0001321', return_dataframe=True, limit=limit)
-        
+
         if not result.empty:
             self.assertLessEqual(len(result), limit, f"Should return at most {limit} results")
-            print(f"\n✓ Limit parameter working: requested {limit}, got {len(result)}")
+            print(f"\nLimit parameter working: requested {limit}, got {len(result)}")
+
+    def test_anatomy_expressed_in_empty_result(self):
+        """Test query with an id that has no expression overlaps"""
+        result = vq.get_expression_overlaps_here('VFBexp_99999999', return_dataframe=True)
 
-    def test_expression_overlaps_empty_result(self):
-        """Test query with anatomy that has no expression patterns"""
-        # Use a very specific anatomy term unlikely to have expression patterns
-        result = vq.get_expression_overlaps_here('FBbt_99999999', return_dataframe=True)
-        
         # Should return empty DataFrame, not error
         self.assertIsInstance(result, pd.DataFrame, "Should return DataFrame even for no results")
-        print(f"\n✓ Empty result handling works correctly")
+        print(f"\nEmpty result handling works correctly")
 
-    def test_expression_overlaps_publication_data(self):
+    def test_anatomy_expressed_in_publication_data(self):
         """Test that publication data is properly formatted when present"""
         result = vq.get_expression_overlaps_here('VFBexp_FBtp0001321', return_dataframe=True, limit=10)
-        
+
         if not result.empty:
-            # Check if pubs column exists and contains data
             self.assertIn('pubs', result.columns, "Should have 'pubs' column")
-            
-            # Check structure of publication data
+
             for idx, row in result.iterrows():
-                if row['pubs']:  # If publications exist
+                if row['pubs']:
                     pubs = row['pubs']
                     self.assertIsInstance(pubs, list, "Publications should be a list")
-                    
-                    if pubs:  # If list is not empty
+
+                    if pubs:
                         first_pub = pubs[0]
                         self.assertIsInstance(first_pub, dict, "Publication should be a dict")
-                        
-                        # Check expected publication fields
+
                         if 'core' in first_pub:
                             self.assertIn('short_form', first_pub['core'], "Publication should have short_form")
-                        
-                        print(f"\n✓ Publication data properly structured")
+
+                        print(f"\nPublication data properly structured")
                         break
 
-    def test_expression_overlaps_markdown_encoding(self):
+    def test_anatomy_expressed_in_markdown_encoding(self):
         """Test that markdown links are properly formatted"""
         result = vq.get_expression_overlaps_here('VFBexp_FBtp0001321', return_dataframe=True, limit=5)
-        
+
         if not result.empty:
-            # Check that names contain markdown link format [label](url)
             for name in result['name']:
-                # Should have markdown link format
                 self.assertIn('[', name, "Name should contain markdown link start")
                 self.assertIn('](', name, "Name should contain markdown link separator")
                 self.assertIn(')', name, "Name should contain markdown link end")
-            
-            print(f"\n✓ Markdown links properly formatted")
 
-    def test_expression_overlaps_tags_format(self):
+            print(f"\nMarkdown links properly formatted")
+
+    def test_anatomy_expressed_in_tags_format(self):
         """Test that tags are properly formatted as pipe-separated strings"""
         result = vq.get_expression_overlaps_here('VFBexp_FBtp0001321', return_dataframe=True, limit=5)
-        
+
         if not result.empty and 'tags' in result.columns:
             for tags in result['tags']:
                 if pd.notna(tags) and tags:
-                    # Tags should be pipe-separated strings
                     self.assertIsInstance(tags, str, "Tags should be string type")
-                    # Could contain pipes for multiple tags
                     parts = tags.split('|')
                     self.assertTrue(all(isinstance(p, str) for p in parts), "Tag parts should be strings")
-            
-            print(f"\n✓ Tags format verified")
+
+            print(f"\nTags format verified")
 
 
 class TestAnatomyExpressedInSchema(unittest.TestCase):
-    """Test cases for AnatomyExpressedIn_to_schema (renamed from
-    ExpressionOverlapsHere_to_schema in v1.13.7). The legacy name is
-    kept as a back-compat alias and must continue to import.
-    """
+    """Test cases for AnatomyExpressedIn_to_schema."""
 
     def test_schema_function_exists(self):
-        """Test that both the canonical and legacy schema functions are defined."""
+        """Canonical schema function is defined; legacy alias is gone."""
         self.assertTrue(hasattr(vq, 'AnatomyExpressedIn_to_schema'),
-                       "AnatomyExpressedIn_to_schema function should exist")
-        self.assertTrue(hasattr(vq, 'ExpressionOverlapsHere_to_schema'),
-                       "Legacy ExpressionOverlapsHere_to_schema alias should still exist")
+                        "AnatomyExpressedIn_to_schema function should exist")
+        self.assertFalse(hasattr(vq, 'ExpressionOverlapsHere_to_schema'),
+                         "Legacy ExpressionOverlapsHere_to_schema alias must be removed")
 
     def test_schema_structure(self):
-        """Test that schema function returns proper Query object."""
+        """Schema function returns the expected Query object."""
         from vfbquery.vfb_queries import AnatomyExpressedIn_to_schema
 
         schema = AnatomyExpressedIn_to_schema(
             "P{GAL4-per.BS} expression pattern",
             {"short_form": "VFBexp_FBtp0001321"},
         )
 
-        # Check Query object attributes
         self.assertEqual(schema.query, "AnatomyExpressedIn")
         self.assertEqual(schema.function, "get_expression_overlaps_here")
         self.assertIn("Anatomy where", schema.label)
         self.assertEqual(schema.preview, 5)
         self.assertEqual(schema.preview_columns, ["id", "name", "tags", "pubs"])
-        
-        # Check takes structure
+
+        # takes constrains the input to an expression pattern (or fragment)
         self.assertIn("short_form", schema.takes)
         self.assertIn("default", schema.takes)
-        self.assertEqual(schema.takes["short_form"], {"$and": ["Class", "Anatomy"]})
-        
-        print("\n✓ Schema structure verified")
+        self.assertEqual(
+            schema.takes["short_form"],
+            {"$or": [
+                {"$and": ["Class", "Expression_pattern"]},
+                {"$and": ["Class", "Expression_pattern_fragment"]},
+            ]},
+        )
+
+        print("\nSchema structure verified")
+
+
+class TestAnatomyExpressedInWireMapping(unittest.TestCase):
+    """ha_api.QUERY_TYPE_MAP — canonical key only, legacy alias removed."""
+
+    def test_query_type_map(self):
+        from vfbquery.ha_api import QUERY_TYPE_MAP
+        self.assertIn("AnatomyExpressedIn", QUERY_TYPE_MAP,
+                      "AnatomyExpressedIn must be a recognised query_type")
+        self.assertEqual(QUERY_TYPE_MAP["AnatomyExpressedIn"],
+                         "get_expression_overlaps_here")
+        self.assertNotIn("ExpressionOverlapsHere", QUERY_TYPE_MAP,
+                         "Legacy ExpressionOverlapsHere alias must be removed")
 
 
 if __name__ == '__main__':
-    # Run tests with verbose output
     unittest.main(verbosity=2)

src/test/test_query_performance.py

@@ -458,24 +458,26 @@ def test_10_expression_queries(self):
         print("EXPRESSION PATTERN QUERIES (Neo4j)")
         print("="*80)
 
-        # ExpressionOverlapsHere - test with adult brain which has many expression patterns
-        # Warm up cache with full results
+        # AnatomyExpressedIn - inverse direction (expression pattern ->
+        # anatomy classes). Use VFBexp_FBtp0001321 (P{GAL4-per.BS}),
+        # known to overlap ~50 anatomy classes in pdb.
+        EP_EXAMPLE = 'VFBexp_FBtp0001321'
         try:
-            get_expression_overlaps_here(self.test_terms['medulla'], return_dataframe=False, limit=-1)
+            get_expression_overlaps_here(EP_EXAMPLE, return_dataframe=False, limit=-1)
         except Exception:
             pass  # Ignore warm-up failures
-        
+
         result, duration, success = self._time_query(
-            "ExpressionOverlapsHere (adult brain)",
+            "AnatomyExpressedIn (P{GAL4-per.BS} expression pattern)",
             get_expression_overlaps_here,
-            self.test_terms['medulla'],  # FBbt_00003982 (adult brain/medulla)
+            EP_EXAMPLE,
             return_dataframe=False,
             limit=10  # Limit to 10 for performance test
         )
-        print(f"ExpressionOverlapsHere: {duration:.4f}s {'✅' if success else '❌'}")
+        print(f"AnatomyExpressedIn: {duration:.4f}s {'✅' if success else '❌'}")
         if success and result:
-            print(f"  └─ Found {result.get('count', 0)} total expression patterns, returned 10")
-        self.assertLess(duration, self.THRESHOLD_SLOW, "ExpressionOverlapsHere exceeded threshold")
+            print(f"  └─ Found {result.get('count', 0)} total anatomy classes, returned 10")
+        self.assertLess(duration, self.THRESHOLD_SLOW, "AnatomyExpressedIn exceeded threshold")
 
     def test_11_transcriptomics_queries(self):
         """Test scRNAseq transcriptomics queries"""

src/vfbquery/ha_api.py

@@ -301,7 +301,6 @@ async def security_middleware(request, handler):
 
     # Expression
     "AnatomyExpressedIn":            "get_expression_overlaps_here",
-    "ExpressionOverlapsHere":        "get_expression_overlaps_here",  # deprecated alias of AnatomyExpressedIn (kept for bookmarked URLs)
     "TransgeneExpressionHere":       "get_transgene_expression_here",
 
     # Transcriptomics