refactor: unify error classification into shared _classify_transient helper

Extract the per-exception type matching from _classify_chunk_error into
a new _classify_transient(exc) helper that classifies a SINGLE exception
(no chain walk) into (interrupted_class, retry_after) | None.

_classify_chunk_error now calls _classify_transient on each step of its
__cause__ walk. _retryable continues to inspect only the top-level
exception (preserving the intentional divergence: initial-page raw
transients are cheap to retry; wrapped mid-pagination failures escalate
to a resumable ChunkInterrupted instead).

When a new transient error type needs recognition, it now goes in ONE
place (_classify_transient) and both the retry and escalation paths pick
it up automatically.

Author: thodson-usgs

dataretrieval/ogc/retry.py

@@ -190,6 +190,38 @@ def backoff(self, attempt: int, retry_after: float | None) -> float:
 _NO_RETRY = RetryPolicy(max_retries=0)
 
 
+def _classify_transient(
+    exc: BaseException,
+) -> tuple[type[ChunkInterrupted], float | None] | None:
+    """
+    Classify a SINGLE exception as a known transient (resumable) failure.
+
+    Does NOT walk the ``__cause__`` chain — inspects only the exception
+    passed in. This is the shared taxonomy that both
+    :func:`_classify_chunk_error` (chain-walking) and :func:`_retryable`
+    (top-level only) delegate to, so a new error type need only be added
+    in one place.
+
+    Parameters
+    ----------
+    exc : BaseException
+        A single exception to classify.
+
+    Returns
+    -------
+    tuple[type[ChunkInterrupted], float or None] or None
+        ``(interrupted_class, retry_after)`` for a recognized transient
+        failure; ``None`` otherwise.
+    """
+    if isinstance(exc, RateLimited):
+        return QuotaExhausted, exc.retry_after
+    if isinstance(exc, ServiceUnavailable):
+        return ServiceInterrupted, exc.retry_after
+    if isinstance(exc, (httpx.HTTPError, httpx.InvalidURL)):
+        return ServiceInterrupted, None
+    return None
+
+
 def _classify_chunk_error(
     exc: BaseException,
 ) -> tuple[type[ChunkInterrupted], float | None] | None:
@@ -231,12 +263,9 @@ def _classify_chunk_error(
     """
     cur: BaseException | None = exc
     while cur is not None:
-        if isinstance(cur, RateLimited):
-            return QuotaExhausted, cur.retry_after
-        if isinstance(cur, ServiceUnavailable):
-            return ServiceInterrupted, cur.retry_after
-        if isinstance(cur, (httpx.HTTPError, httpx.InvalidURL)):
-            return ServiceInterrupted, None
+        result = _classify_transient(cur)
+        if result is not None:
+            return result
         cur = cur.__cause__
     return None
 
@@ -262,6 +291,10 @@ def _retryable(exc: BaseException) -> tuple[bool, float | None]:
         ``(retryable, retry_after)`` — the server ``Retry-After`` hint
         (seconds) when the transient carried one, else ``None``.
     """
+    # Only initial-page raw transients (TransientError, TransportError) are
+    # retryable — not wrapped mid-pagination DataRetrievalError. We use
+    # _classify_transient for the typed status errors and handle bare
+    # TransportError (which isn't a TransientError) separately.
     if isinstance(exc, TransientError):
         return True, exc.retry_after
     if isinstance(exc, httpx.TransportError):