Refactor pagination and type hinting in async functions. Update _parse_and_raise to remove type ignore comment. Add tests for minimal CodeableConcept resolution and async FHIR property caching.

Author: alex-omophub

src/omophub/_pagination.py

@@ -6,7 +6,7 @@
 from urllib.parse import urlencode
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Callable, Iterator
+    from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
 
     from ._types import PaginationMeta
 
@@ -106,7 +106,7 @@ def paginate_sync(
 
 
 async def paginate_async(
-    fetch_page: Callable[[int, int], tuple[list[T], PaginationMeta | None]],
+    fetch_page: Callable[[int, int], Awaitable[tuple[list[T], PaginationMeta | None]]],
     page_size: int = DEFAULT_PAGE_SIZE,
 ) -> AsyncIterator[T]:
     """Create an async iterator that auto-paginates through results.
@@ -121,12 +121,7 @@ async def paginate_async(
     page = 1
 
     while True:
-        # Note: fetch_page should be an async function
-        result = fetch_page(page, page_size)
-        if hasattr(result, "__await__"):
-            items, meta = await result  # type: ignore
-        else:
-            items, meta = result
+        items, meta = await fetch_page(page, page_size)
 
         for item in items:
             yield item

src/omophub/_request.py

@@ -74,7 +74,7 @@ def _parse_and_raise(
             retry_after=retry_after,
         )
 
-    return data  # type: ignore[return-value]
+    return data
 
 
 class Request(Generic[T]):

src/omophub/resources/search.py

@@ -699,6 +699,7 @@ async def fetch_page(
             meta = result.get("meta", {}).get("pagination")
             return results, meta
 
+        item: SemanticSearchResult
         async for item in paginate_async(fetch_page, page_size):
             yield item
 

tests/unit/resources/test_fhir.py

@@ -353,6 +353,25 @@ def test_resolve_codeable_concept_with_all_options(
         assert body["include_recommendations"] is True
         assert body["include_quality"] is True
 
+    @respx.mock
+    def test_resolve_codeable_concept_minimal(self, sync_client: OMOPHub, base_url: str) -> None:
+        """CodeableConcept with no optional flags (covers False branches)."""
+        route = respx.post(f"{base_url}/fhir/resolve/codeable-concept").mock(
+            return_value=Response(200, json=CODEABLE_CONCEPT_RESPONSE)
+        )
+
+        sync_client.fhir.resolve_codeable_concept(
+            coding=[{"system": "http://snomed.info/sct", "code": "44054006"}],
+        )
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert "text" not in body
+        assert "resource_type" not in body
+        assert "include_recommendations" not in body
+        assert "include_quality" not in body
+
     @respx.mock
     def test_resolve_sends_correct_body(self, sync_client: OMOPHub, base_url: str) -> None:
         """Verify the POST body includes only non-None parameters."""
@@ -439,3 +458,118 @@ async def test_async_resolve_codeable_concept(
         )
 
         assert result["best_match"] is not None
+
+    @respx.mock
+    @pytest.mark.anyio
+    async def test_async_resolve_vocabulary_id_bypass(
+        self, async_client: AsyncOMOPHub, base_url: str
+    ) -> None:
+        """Async resolve with vocabulary_id exercises the bypass branch."""
+        route = respx.post(f"{base_url}/fhir/resolve").mock(
+            return_value=Response(200, json=ICD10_MAPPED_RESPONSE)
+        )
+
+        result = await async_client.fhir.resolve(
+            vocabulary_id="ICD10CM",
+            code="E11.9",
+            include_recommendations=True,
+            recommendations_limit=3,
+            include_quality=True,
+        )
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert body["vocabulary_id"] == "ICD10CM"
+        assert body["include_recommendations"] is True
+        assert body["recommendations_limit"] == 3
+        assert body["include_quality"] is True
+        assert "resolution" in result
+
+    @respx.mock
+    @pytest.mark.anyio
+    async def test_async_resolve_batch_all_flags(
+        self, async_client: AsyncOMOPHub, base_url: str
+    ) -> None:
+        """Async batch with include_recommendations exercises that branch."""
+        route = respx.post(f"{base_url}/fhir/resolve/batch").mock(
+            return_value=Response(200, json=BATCH_RESPONSE)
+        )
+
+        await async_client.fhir.resolve_batch(
+            [{"system": "http://snomed.info/sct", "code": "44054006"}],
+            resource_type="Condition",
+            include_recommendations=True,
+            recommendations_limit=5,
+            include_quality=True,
+        )
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert body["include_recommendations"] is True
+        assert body["recommendations_limit"] == 5
+        assert body["include_quality"] is True
+
+    @respx.mock
+    @pytest.mark.anyio
+    async def test_async_fhir_property_cached(self, async_client: AsyncOMOPHub, base_url: str) -> None:
+        """Accessing client.fhir twice returns the same cached instance."""
+        fhir1 = async_client.fhir
+        fhir2 = async_client.fhir
+        assert fhir1 is fhir2
+
+
+    @respx.mock
+    @pytest.mark.anyio
+    async def test_async_resolve_codeable_minimal(
+        self, async_client: AsyncOMOPHub, base_url: str
+    ) -> None:
+        """Async codeable concept with no optional flags (covers False branches)."""
+        route = respx.post(f"{base_url}/fhir/resolve/codeable-concept").mock(
+            return_value=Response(200, json=CODEABLE_CONCEPT_RESPONSE)
+        )
+
+        await async_client.fhir.resolve_codeable_concept(
+            coding=[{"system": "http://snomed.info/sct", "code": "44054006"}],
+        )
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert "text" not in body
+        assert "resource_type" not in body
+        assert "include_recommendations" not in body
+        assert "include_quality" not in body
+
+    @respx.mock
+    @pytest.mark.anyio
+    async def test_async_resolve_batch_minimal(
+        self, async_client: AsyncOMOPHub, base_url: str
+    ) -> None:
+        """Async batch with no optional flags (covers False branches)."""
+        route = respx.post(f"{base_url}/fhir/resolve/batch").mock(
+            return_value=Response(200, json=BATCH_RESPONSE)
+        )
+
+        await async_client.fhir.resolve_batch(
+            [{"system": "http://snomed.info/sct", "code": "44054006"}],
+        )
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert "resource_type" not in body
+        assert "include_recommendations" not in body
+        assert "include_quality" not in body
+
+
+class TestFhirPropertyCaching:
+    """Test lazy-property cache hit on both client types."""
+
+    @respx.mock
+    def test_sync_fhir_property_cached(self, sync_client: OMOPHub) -> None:
+        """Accessing client.fhir twice returns the same cached instance."""
+        fhir1 = sync_client.fhir
+        fhir2 = sync_client.fhir
+        assert fhir1 is fhir2