Keep hosted mapping tables reachable under backend="auto"

_resolve_backend raised ValueError for any pair outside
PYHEALTH_NATIVE_PAIRS and ICD_MAPPINGS_PAIRS, but the native list omits
six tables the resource server hosts (ATC<->ICD9CM, ATC<->UMLS,
ICD9CM<->UMLS, ICD9PROC<->UMLS, RxNorm<->ATC, RxNorm<->UMLS). Those 12
directions load on master and failed here before any download.

auto now sends every pair icd-mappings does not own to the resource
server, as before. When neither direction of a table exists there,
CrossMap raises a ValueError naming both files instead of a bare
urllib HTTPError 404.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: jhnwu3

pyhealth/medcode/cross_map.py

@@ -12,7 +12,7 @@
     PYHEALTH_NATIVE_PAIRS,
     _ICDMappingsBackend,
 )
-from pyhealth.medcode.utils import MODULE_CACHE_PATH, download_and_read_csv
+from pyhealth.medcode.utils import BASE_URL, MODULE_CACHE_PATH, download_and_read_csv
 from pyhealth.utils import load_pickle, save_pickle
 
 logger = logging.getLogger(__name__)
@@ -114,7 +114,16 @@ def __init__(
                 df = download_and_read_csv(local_filename, refresh_cache)
             except HTTPError:
                 local_filename = f"{self.t_vocab}_to_{self.s_vocab}.csv"
-                df = download_and_read_csv(local_filename, refresh_cache)
+                try:
+                    df = download_and_read_csv(local_filename, refresh_cache)
+                except HTTPError as e:
+                    raise ValueError(
+                        f"No mapping between {self.s_vocab} and {self.t_vocab} "
+                        f"is available: neither "
+                        f"{self.s_vocab}_to_{self.t_vocab}.csv nor "
+                        f"{local_filename} exists at {BASE_URL}, and "
+                        f"icd-mappings serves {sorted(ICD_MAPPINGS_PAIRS)}."
+                    ) from e
             self.mapping = defaultdict(list)
             for _, row in df.iterrows():
                 self.mapping[row[self.s_vocab]].append(row[self.t_vocab])
@@ -141,12 +150,9 @@ def _resolve_backend(
                 return BACKEND_PYHEALTH
             if pair in ICD_MAPPINGS_PAIRS:
                 return BACKEND_ICDMAPPINGS
-            raise ValueError(
-                f"No mapping available for {source_vocabulary}->"
-                f"{target_vocabulary}. PyHealth serves "
-                f"{sorted(PYHEALTH_NATIVE_PAIRS)} and icd-mappings serves "
-                f"{sorted(ICD_MAPPINGS_PAIRS)}."
-            )
+            # Anything else is looked up on PyHealth's resource server, as it
+            # was before icd-mappings existed; a missing table raises there.
+            return BACKEND_PYHEALTH
         if backend == BACKEND_ICDMAPPINGS:
             if pair not in ALL_ICD_MAPPINGS_PAIRS:
                 raise ValueError(

pyhealth/medcode/icd_mappings.py

@@ -17,10 +17,12 @@
 
 logger = logging.getLogger(__name__)
 
-#: Vocabulary pairs PyHealth serves from its own resource server. Listed in
-#: both orderings because ``CrossMap`` derives the reverse direction from the
-#: same CSV via its reverse-filename fallback. These always win over the
-#: ``icd-mappings`` backend under ``backend="auto"``.
+#: Vocabulary pairs PyHealth serves from its own resource server that must
+#: never be routed to ``icd-mappings`` under ``backend="auto"``. Listed in both
+#: orderings because ``CrossMap`` derives the reverse direction from the same
+#: CSV via its reverse-filename fallback. Not exhaustive: ``auto`` sends every
+#: pair outside ``ICD_MAPPINGS_PAIRS`` to the resource server too (e.g.
+#: RxNorm->ATC, ICD9CM->UMLS).
 PYHEALTH_NATIVE_PAIRS: frozenset = frozenset(
     {
         ("ICD9CM", "CCSCM"),

tests/core/test_medcode_icd_mappings.py

@@ -9,7 +9,10 @@
 """
 
 import logging
+import tempfile
 import unittest
+from unittest import mock
+from urllib.error import HTTPError
 
 from pyhealth.medcode import ICD9CM, ICD10CM, CrossMap, FlatMap, InnerMap
 from pyhealth.medcode.cross_map import (
@@ -74,9 +77,32 @@ def test_gap_pairs_use_icd_mappings(self):
                 msg=f"{pair} should fall back to icd-mappings",
             )
 
-    def test_unsupported_pair_raises_value_error(self):
-        with self.assertRaises(ValueError):
-            CrossMap._resolve_backend("ICD9CM", "RxNorm", "auto")
+    def test_other_hosted_pairs_stay_on_pyhealth(self):
+        # Pairs icd-mappings does not own must keep reaching PyHealth's
+        # resource server, including hosted tables not listed in
+        # PYHEALTH_NATIVE_PAIRS. These all load on master.
+        for pair in [("RxNorm", "ATC"), ("ATC", "ICD9CM"), ("ICD9CM", "UMLS"),
+                     ("ICD9PROC", "UMLS"), ("RxNorm", "UMLS"), ("ATC", "UMLS")]:
+            self.assertEqual(
+                CrossMap._resolve_backend(pair[0], pair[1], "auto"),
+                BACKEND_PYHEALTH,
+                msg=f"{pair} should resolve to PyHealth's own tables",
+            )
+
+    def test_unhosted_pair_raises_value_error(self):
+        # Neither direction exists on the resource server: the 404s must
+        # surface as a ValueError that names the files, not a bare HTTPError.
+        def not_found(filename, refresh_cache=False):
+            raise HTTPError(filename, 404, "Not Found", None, None)
+
+        with tempfile.TemporaryDirectory() as cache, \
+                mock.patch("pyhealth.medcode.cross_map.MODULE_CACHE_PATH", cache), \
+                mock.patch("pyhealth.medcode.cross_map.download_and_read_csv",
+                           side_effect=not_found):
+            with self.assertRaisesRegex(
+                ValueError, "ICD9CM_to_RxNorm.csv nor RxNorm_to_ICD9CM.csv"
+            ):
+                CrossMap.load("ICD9CM", "RxNorm")
 
     def test_forcing_icd_mappings_on_unsupported_pair_raises(self):
         with self.assertRaises(ValueError):