helix.fhir.client.sdk 4.2.13__tar.gz → 4.2.15__tar.gz

{helix_fhir_client_sdk-4.2.13/helix.fhir.client.sdk.egg-info → helix_fhir_client_sdk-4.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.13
+Version: 4.2.15
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi

helix_fhir_client_sdk-4.2.15/VERSION

@@ -0,0 +1 @@
+4.2.15

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15/helix.fhir.client.sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.13
+Version: 4.2.15
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/fhir_auth_mixin.py

@@ -180,7 +180,6 @@ class FhirAuthMixin(FhirClientProtocol):
             access_token_expiry_date=self._access_token_expiry_date,
             refresh_token_func=self._refresh_token_function,
             tracer_request_func=self._trace_request_function,
-            persistent_session=self._persistent_session,
         ) as client:
             if self._auth_wellknown_url:
                 host_name: str = furl(self._auth_wellknown_url).host
@@ -282,7 +281,6 @@ class FhirAuthMixin(FhirClientProtocol):
             access_token_expiry_date=self._access_token_expiry_date,
             refresh_token_func=self._refresh_token_function,
             tracer_request_func=self._trace_request_function,
-            persistent_session=self._persistent_session,
         ) as client:
             response: RetryableAioHttpResponse = await client.post(url=auth_server_url, headers=headers, data=payload)
             # token = response.text.encode('utf8')

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/fhir_client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import ssl
 import uuid
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 from datetime import datetime
 from logging import Logger
 from os import environ
@@ -155,6 +155,9 @@ class FhirClient(
 
         self._create_operation_outcome_for_error: bool | None = False
 
+        # Optional callable to create HTTP sessions. When set, create_http_session() will use this.
+        self._fn_create_http_session: Callable[[], ClientSession] | None = None
+
     def action(self, action: str) -> FhirClient:
         """
         Set the action
@@ -477,13 +480,17 @@ class FhirClient(
         self._throw_exception_on_error = throw_exception_on_error
         return self
 
-    def set_persistent_session(self, session: ClientSession | None) -> FhirClient:
+    def use_http_session(self, fn_create_http_session: Callable[[], ClientSession] | None) -> FhirClient:
         """
-        Sets the persistent session to use for requests
+        Sets a custom callable to create HTTP sessions.
+
+        When set, create_http_session() will use this callable instead of the default
+        implementation. This allows for custom session management, connection pooling,
+        or persistent session support.
 
-        :param session: persistent session
+        :param fn_create_http_session: callable that returns a ClientSession, or None to use default
         """
-        self._persistent_session = session
+        self._fn_create_http_session = fn_create_http_session
         return self
 
     # noinspection PyUnusedLocal
@@ -808,9 +815,16 @@ class FhirClient(
 
     def create_http_session(self) -> ClientSession:
         """
-        Creates an HTTP Session
+        Creates an HTTP Session.
 
+        If a custom session factory was set via use_http_session(), it will be used.
+        Otherwise, creates a default aiohttp ClientSession with standard configuration.
         """
+        # Use a custom session factory if provided
+        if self._fn_create_http_session is not None:
+            return self._fn_create_http_session()
+
+        # Default implementation
         trace_config = aiohttp.TraceConfig()
         # trace_config.on_request_start.append(on_request_start)
         if self._log_level == "DEBUG":
@@ -883,6 +897,8 @@ class FhirClient(
         fhir_client._client_id = self._client_id
         fhir_client._auth_server_url = self._auth_server_url
         fhir_client._login_token = self._login_token
+        fhir_client._access_token = self._access_token
+        fhir_client._access_token_expiry_date = self._access_token_expiry_date
         fhir_client._refresh_token_function = self._refresh_token_function
         fhir_client._exclude_status_codes_from_retry = self._exclude_status_codes_from_retry
         fhir_client._chunk_size = self._chunk_size
@@ -905,6 +921,9 @@ class FhirClient(
         fhir_client._trace_request_function = self._trace_request_function
         fhir_client._log_all_response_urls = self._log_all_response_urls
         fhir_client._create_operation_outcome_for_error = self._create_operation_outcome_for_error
+        fhir_client._fn_create_http_session = self._fn_create_http_session
+        if self._max_concurrent_requests is not None:
+            fhir_client.set_max_concurrent_requests(self._max_concurrent_requests)
         return fhir_client
 
     def set_log_all_response_urls(self, value: bool) -> FhirClient:

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/fhir_delete_mixin.py

@@ -56,7 +56,6 @@ class FhirDeleteMixin(FhirClientProtocol):
             access_token=self._access_token,
             access_token_expiry_date=self._access_token_expiry_date,
             tracer_request_func=self._trace_request_function,
-            persistent_session=self._persistent_session,
         ) as client:
             response: RetryableAioHttpResponse = await client.delete(url=full_uri.tostr(), headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)
@@ -126,7 +125,6 @@ class FhirDeleteMixin(FhirClientProtocol):
             access_token=self._access_token,
             access_token_expiry_date=self._access_token_expiry_date,
             tracer_request_func=self._trace_request_function,
-            persistent_session=self._persistent_session,
         ) as client:
             response: RetryableAioHttpResponse = await client.delete(url=full_url, headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/fhir_merge_mixin.py

@@ -181,7 +181,6 @@ class FhirMergeMixin(FhirClientProtocol):
                             log_all_url_results=self._log_all_response_urls,
                             access_token=self._access_token,
                             access_token_expiry_date=self._access_token_expiry_date,
-                            persistent_session=self._persistent_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/fhir_merge_resources_mixin.py

@@ -118,7 +118,6 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
             ) as client:
                 http_post_start = time.time()
                 response: RetryableAioHttpResponse = await client.post(
@@ -312,7 +311,6 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                         log_all_url_results=self._log_all_response_urls,
                         access_token=self._access_token,
                         access_token_expiry_date=self._access_token_expiry_date,
-                        persistent_session=self._persistent_session,
                     ) as client:
                         # should we check if it exists and do a POST then?
                         response: RetryableAioHttpResponse = await client.post(
@@ -529,7 +527,6 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                             log_all_url_results=self._log_all_response_urls,
                             access_token=self._access_token,
                             access_token_expiry_date=self._access_token_expiry_date,
-                            persistent_session=self._persistent_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/fhir_patch_mixin.py

@@ -72,7 +72,6 @@ class FhirPatchMixin(FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
             ) as client:
                 response: RetryableAioHttpResponse = await client.patch(
                     url=full_uri.url, json=deserialized_data, headers=headers

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/fhir_update_mixin.py

@@ -106,7 +106,6 @@ class FhirUpdateMixin(FhirClientProtocol):
             log_all_url_results=self._log_all_response_urls,
             access_token=self._access_token,
             access_token_expiry_date=self._access_token_expiry_date,
-            persistent_session=self._persistent_session,
         ) as client:
             response = await client.put(url=full_uri.url, data=json_data, headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/queue/request_queue_mixin.py

@@ -130,7 +130,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present
@@ -299,7 +298,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/responses/fhir_client_protocol.py

@@ -1,5 +1,5 @@
 import uuid
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 from datetime import datetime
 from logging import Logger
 from threading import Lock
@@ -89,8 +89,6 @@ class FhirClientProtocol(Protocol):
     _send_data_as_chunked: bool = False
     _last_page_lock: Lock
 
-    _persistent_session: ClientSession | None = None
-
     _use_post_for_search: bool = False
 
     _accept: str
@@ -128,6 +126,12 @@ class FhirClientProtocol(Protocol):
     _create_operation_outcome_for_error: bool | None
     """ whether to create OperationOutcome resource for errors """
 
+    _max_concurrent_requests: int | None
+    """ maximum number of concurrent requests to make to the FHIR server """
+
+    _fn_create_http_session: Callable[[], ClientSession] | None
+    """ optional callable to create HTTP sessions """
+
     async def get_access_token_async(self) -> GetAccessTokenResult: ...
 
     async def _send_fhir_request_async(
@@ -211,4 +215,4 @@ class FhirClientProtocol(Protocol):
         # this is just here to tell Python this returns a generator
         yield None  # type: ignore[misc]
 
-    def set_persistent_session(self, session: ClientSession | None) -> "FhirClientProtocol": ...
+    def use_http_session(self, fn_create_http_session: Callable[[], ClientSession] | None) -> "FhirClientProtocol": ...

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py

@@ -45,7 +45,6 @@ class RetryableAioHttpClient:
         log_all_url_results: bool = False,
         access_token: str | None,
         access_token_expiry_date: datetime | None,
-        persistent_session: ClientSession | None = None,
     ) -> None:
         """
         RetryableClient provides a way to make HTTP calls with automatic retry and automatic refreshing of access tokens
@@ -71,13 +70,9 @@ class RetryableAioHttpClient:
         self.log_all_url_results: bool = log_all_url_results
         self.access_token: str | None = access_token
         self.access_token_expiry_date: datetime | None = access_token_expiry_date
-        self.persistent_session: ClientSession | None = persistent_session
 
     async def __aenter__(self) -> "RetryableAioHttpClient":
-        if self.persistent_session is not None:
-            self.session = self.persistent_session
-        else:
-            self.session = self.fn_get_session()
+        self.session = self.fn_get_session()
         return self
 
     async def __aexit__(
@@ -86,7 +81,7 @@ class RetryableAioHttpClient:
         exc_val: BaseException | None,
         exc_tb: type[BaseException] | None | None,
     ) -> None:
-        if not self.persistent_session and self.session is not None:
+        if self.session is not None:
             await self.session.close()
 
     @staticmethod

{helix_fhir_client_sdk-4.2.13 → helix_fhir_client_sdk-4.2.15}/tests/test_fhir_client_clone.py

@@ -2,6 +2,8 @@
 Tests for FhirClient.clone() method to ensure all properties are properly copied.
 """
 
+from datetime import UTC, datetime, timedelta
+
 from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
     CompressedDictStorageMode,
 )
@@ -76,3 +78,78 @@ def test_default_storage_mode_is_raw() -> None:
     """Test that the default storage mode is 'raw'"""
     fhir_client = FhirClient()
     assert fhir_client._storage_mode.storage_type == "raw"
+
+
+def test_clone_preserves_access_token() -> None:
+    """Test that clone() preserves access token and expiry date"""
+    expiry_date = datetime.now(UTC) + timedelta(hours=1)
+    fhir_client = (
+        FhirClient()
+        .url("http://example.com")
+        .set_access_token("test-access-token-12345")
+        .set_access_token_expiry_date(expiry_date)
+    )
+
+    assert fhir_client._access_token == "test-access-token-12345"
+    assert fhir_client._access_token_expiry_date == expiry_date
+
+    # Clone and verify access token is preserved
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._access_token == "test-access-token-12345"
+    assert cloned_client._access_token_expiry_date == expiry_date
+
+
+def test_clone_preserves_max_concurrent_requests() -> None:
+    """Test that clone() preserves max_concurrent_requests setting"""
+    fhir_client = FhirClient().url("http://example.com").set_max_concurrent_requests(10)
+
+    assert fhir_client._max_concurrent_requests == 10
+
+    # Clone and verify max_concurrent_requests is preserved
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._max_concurrent_requests == 10
+
+
+def test_use_http_session() -> None:
+    """Test that use_http_session sets the callable correctly"""
+    from aiohttp import ClientSession
+
+    def custom_session_factory() -> ClientSession:
+        return ClientSession()
+
+    fhir_client = FhirClient().url("http://example.com")
+
+    # Initially None
+    assert fhir_client._fn_create_http_session is None
+
+    # Set the callable
+    result = fhir_client.use_http_session(custom_session_factory)
+
+    # Returns self for chaining
+    assert result is fhir_client
+
+    # Callable is stored
+    assert fhir_client._fn_create_http_session is custom_session_factory
+
+    # Can set to None
+    fhir_client.use_http_session(None)
+    assert fhir_client._fn_create_http_session is None
+
+
+def test_clone_preserves_fn_create_http_session() -> None:
+    """Test that clone() preserves the _fn_create_http_session callable"""
+    from aiohttp import ClientSession
+
+    def custom_session_factory() -> ClientSession:
+        return ClientSession()
+
+    fhir_client = FhirClient().url("http://example.com").use_http_session(custom_session_factory)
+
+    assert fhir_client._fn_create_http_session is custom_session_factory
+
+    # Clone and verify fn_create_http_session is preserved
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._fn_create_http_session is custom_session_factory

helix_fhir_client_sdk-4.2.13/VERSION

@@ -1 +0,0 @@
-4.2.13