refactor(ogc): move _Fetch/_Finalize/_passthrough_result into chunking.py

These type aliases define ChunkedCall's contract, not anything about
interruptions. They lived in interruptions.py only to avoid a circular
import. Move them to chunking.py where they belong; interruptions.py
keeps TYPE_CHECKING re-exports for backwards compat.

Author: thodson-usgs

dataretrieval/ogc/chunking.py

@@ -74,7 +74,7 @@
 import asyncio
 import functools
 import os
-from collections.abc import Callable, Iterator
+from collections.abc import Awaitable, Callable, Iterator
 from contextlib import contextmanager
 from contextvars import copy_context
 from typing import Any, cast
@@ -88,9 +88,6 @@
 from . import progress as _progress
 from .interruptions import (
     ChunkInterrupted,
-    _Fetch,
-    _Finalize,
-    _passthrough_result,
 )
 from .planning import (
     ChunkPlan,
@@ -104,6 +101,30 @@
     _retry,
 )
 
+# ---------------------------------------------------------------------------
+# Type aliases for the ChunkedCall contract.
+# ---------------------------------------------------------------------------
+
+# The per-sub-request fetcher the decorator wraps and ``ChunkedCall`` drives:
+# an ``async def fetch(args) -> (df, response)``.
+_Fetch = Callable[[dict[str, Any]], Awaitable[tuple[pd.DataFrame, httpx.Response]]]
+
+# Caller-supplied transform applied to the combined chunk result, so a
+# resumed call returns the same shape as an un-interrupted one rather than
+# the chunker's raw ``(frame, httpx.Response)``.  This keeps the chunker
+# generic: the OGC getters inject their post-processing (type coercion,
+# column arrangement, ``BaseMetadata``) through ``_finalize_ogc``.
+# The default is identity, so direct ``ChunkedCall`` use is unaffected.
+_Finalize = Callable[[pd.DataFrame, httpx.Response], tuple[pd.DataFrame, Any]]
+
+
+def _passthrough_result(
+    frame: pd.DataFrame, response: httpx.Response
+) -> tuple[pd.DataFrame, Any]:
+    """Default :data:`_Finalize`: return the raw combined pair unchanged."""
+    return frame, response
+
+
 # Empirically the API replies HTTP 414 above ~8200 bytes of full URL —
 # matches nginx's default ``large_client_header_buffers`` of 8 KB. 8000
 # leaves ~200 bytes for request-line framing and proxy variance. The decorator

dataretrieval/ogc/interruptions.py

@@ -11,7 +11,6 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any, ClassVar
 
 import httpx
@@ -23,25 +22,14 @@
     from dataretrieval.ogc.chunking import ChunkedCall
 
 
-# ``_Fetch`` is the per-sub-request fetcher the decorator wraps and
-# ``ChunkedCall`` drives: an ``async def fetch(args) -> (df, response)``.
-_Fetch = Callable[[dict[str, Any]], Awaitable[tuple[pd.DataFrame, httpx.Response]]]
-
-
-# Caller-supplied transform applied to the combined chunk result, so a
-# resumed call returns the same shape as an un-interrupted one rather than
-# the chunker's raw ``(frame, httpx.Response)``. This keeps the chunker
-# generic: the OGC getters inject their post-processing (type coercion,
-# column arrangement, ``BaseMetadata``) through ``utils._finalize_ogc``.
-# The default is identity, so direct ``ChunkedCall`` use is unaffected.
-_Finalize = Callable[[pd.DataFrame, httpx.Response], tuple[pd.DataFrame, Any]]
-
-
-def _passthrough_result(
-    frame: pd.DataFrame, response: httpx.Response
-) -> tuple[pd.DataFrame, Any]:
-    """Default :data:`_Finalize`: return the raw combined pair unchanged."""
-    return frame, response
+# These type aliases define the ChunkedCall contract and live in chunking.py;
+# re-exported here for backwards compatibility.
+if TYPE_CHECKING:
+    from dataretrieval.ogc.chunking import _Fetch as _Fetch  # noqa: F401
+    from dataretrieval.ogc.chunking import _Finalize as _Finalize  # noqa: F401
+    from dataretrieval.ogc.chunking import (  # noqa: F401
+        _passthrough_result as _passthrough_result,
+    )
 
 
 class ChunkInterrupted(DataRetrievalError):