helix.fhir.client.sdk 4.2.15__py3-none-any.whl → 4.2.16__py3-none-any.whl

helix_fhir_client_sdk/fhir_patch_mixin.py

@@ -2,8 +2,12 @@ import json
 import time
 
 from furl import furl
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
 
 from helix_fhir_client_sdk.exceptions.fhir_sender_exception import FhirSenderException
+from helix_fhir_client_sdk.open_telemetry.attribute_names import FhirClientSdkOpenTelemetryAttributeNames
+from helix_fhir_client_sdk.open_telemetry.span_names import FhirClientSdkOpenTelemetrySpanNames
 from helix_fhir_client_sdk.responses.fhir_client_protocol import FhirClientProtocol
 from helix_fhir_client_sdk.responses.fhir_update_response import FhirUpdateResponse
 from helix_fhir_client_sdk.structures.get_access_token_result import (
@@ -18,6 +22,8 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_response import (
     RetryableAioHttpResponse,
 )
 
+TRACER = trace.get_tracer(__name__)
+
 
 class FhirPatchMixin(FhirClientProtocol):
     async def send_patch_request_async(self, data: str) -> FhirUpdateResponse:
@@ -33,93 +39,102 @@ class FhirPatchMixin(FhirClientProtocol):
             raise ValueError("update should have only one id")
         if not self._resource:
             raise ValueError("update requires a FHIR resource type")
-        self._internal_logger.debug(
-            f"Calling patch method on {self._url} with client_id={self._client_id} and scopes={self._auth_scopes}"
-        )
-        full_uri: furl = furl(self._url)
-        full_uri /= self._resource
-        full_uri /= self._id
-        request_id: str | None = None
 
-        start_time: float = time.time()
+        with TRACER.start_as_current_span(FhirClientSdkOpenTelemetrySpanNames.PATCH) as span:
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.URL, self._url or "")
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.RESOURCE, self._resource or "")
+            try:
+                self._internal_logger.debug(
+                    f"Calling patch method on {self._url} with client_id={self._client_id} and scopes={self._auth_scopes}"
+                )
+                full_uri: furl = furl(self._url)
+                full_uri /= self._resource
+                full_uri /= self._id
+                request_id: str | None = None
 
-        # Set up headers
-        headers = {"Content-Type": "application/json-patch+json"}
-        headers.update(self._additional_request_headers)
-        self._internal_logger.debug(f"Request headers: {headers}")
-        access_token_result: GetAccessTokenResult = await self.get_access_token_async()
-        access_token: str | None = access_token_result.access_token
-        # set access token in request if present
-        if access_token:
-            headers["Authorization"] = f"Bearer {access_token}"
+                start_time: float = time.time()
 
-        response_text: str | None = None
-        response_status: int | None = None
+                # Set up headers
+                headers = {"Content-Type": "application/json-patch+json"}
+                headers.update(self._additional_request_headers)
+                self._internal_logger.debug(f"Request headers: {headers}")
+                access_token_result: GetAccessTokenResult = await self.get_access_token_async()
+                access_token: str | None = access_token_result.access_token
+                # set access token in request if present
+                if access_token:
+                    headers["Authorization"] = f"Bearer {access_token}"
 
-        try:
-            deserialized_data = json.loads(data)
-            # actually make the request
-            async with RetryableAioHttpClient(
-                fn_get_session=lambda: self.create_http_session(),
-                refresh_token_func=self._refresh_token_function,
-                tracer_request_func=self._trace_request_function,
-                retries=self._retry_count,
-                exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
-                use_data_streaming=self._use_data_streaming,
-                send_data_as_chunked=self._send_data_as_chunked,
-                compress=self._compress,
-                throw_exception_on_error=self._throw_exception_on_error,
-                log_all_url_results=self._log_all_response_urls,
-                access_token=self._access_token,
-                access_token_expiry_date=self._access_token_expiry_date,
-            ) as client:
-                response: RetryableAioHttpResponse = await client.patch(
-                    url=full_uri.url, json=deserialized_data, headers=headers
-                )
-                response_status = response.status
-                response_text = await response.get_text_async()
-                request_id = response.response_headers.get("X-Request-ID", None)
-                self._internal_logger.debug(f"X-Request-ID={request_id}")
+                response_text: str | None = None
+                response_status: int | None = None
 
-                if response_status == 200:
-                    if self._logger:
-                        self._logger.info(f"Successfully updated: {full_uri}")
-                elif response_status == 404:
-                    if self._logger:
-                        self._logger.info(f"Request resource was not found: {full_uri}")
+                try:
+                    deserialized_data = json.loads(data)
+                    # actually make the request
+                    async with RetryableAioHttpClient(
+                        fn_get_session=lambda: self.create_http_session(),
+                        refresh_token_func=self._refresh_token_function,
+                        tracer_request_func=self._trace_request_function,
+                        retries=self._retry_count,
+                        exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
+                        use_data_streaming=self._use_data_streaming,
+                        send_data_as_chunked=self._send_data_as_chunked,
+                        compress=self._compress,
+                        throw_exception_on_error=self._throw_exception_on_error,
+                        log_all_url_results=self._log_all_response_urls,
+                        access_token=self._access_token,
+                        access_token_expiry_date=self._access_token_expiry_date,
+                    ) as client:
+                        response: RetryableAioHttpResponse = await client.patch(
+                            url=full_uri.url, json=deserialized_data, headers=headers
+                        )
+                        response_status = response.status
+                        response_text = await response.get_text_async()
+                        request_id = response.response_headers.get("X-Request-ID", None)
+                        self._internal_logger.debug(f"X-Request-ID={request_id}")
+
+                        if response_status == 200:
+                            if self._logger:
+                                self._logger.info(f"Successfully updated: {full_uri}")
+                        elif response_status == 404:
+                            if self._logger:
+                                self._logger.info(f"Request resource was not found: {full_uri}")
+                        else:
+                            # other HTTP errors
+                            self._internal_logger.info(f"PATCH response for {full_uri.url}: {response_status}")
+                except Exception as e:
+                    raise FhirSenderException(
+                        request_id=request_id,
+                        url=full_uri.url,
+                        headers=headers,
+                        json_data=data,
+                        response_text=response_text,
+                        response_status_code=response_status,
+                        exception=e,
+                        variables=FhirClientLogger.get_variables_to_log(vars(self)),
+                        message=f"Error: {e}",
+                        elapsed_time=time.time() - start_time,
+                    ) from e
+                # check if response is json
+                if response_text:
+                    try:
+                        responses = json.loads(response_text)
+                    except ValueError as e:
+                        responses = {"issue": str(e)}
                 else:
-                    # other HTTP errors
-                    self._internal_logger.info(f"PATCH response for {full_uri.url}: {response_status}")
-        except Exception as e:
-            raise FhirSenderException(
-                request_id=request_id,
-                url=full_uri.url,
-                headers=headers,
-                json_data=data,
-                response_text=response_text,
-                response_status_code=response_status,
-                exception=e,
-                variables=FhirClientLogger.get_variables_to_log(vars(self)),
-                message=f"Error: {e}",
-                elapsed_time=time.time() - start_time,
-            ) from e
-        # check if response is json
-        if response_text:
-            try:
-                responses = json.loads(response_text)
-            except ValueError as e:
-                responses = {"issue": str(e)}
-        else:
-            responses = {}
-        return FhirUpdateResponse(
-            request_id=request_id,
-            url=full_uri.tostr(),
-            responses=json.dumps(responses),
-            error=json.dumps(responses),
-            access_token=access_token,
-            status=response_status if response_status else 500,
-            resource_type=self._resource,
-        )
+                    responses = {}
+                return FhirUpdateResponse(
+                    request_id=request_id,
+                    url=full_uri.tostr(),
+                    responses=json.dumps(responses),
+                    error=json.dumps(responses),
+                    access_token=access_token,
+                    status=response_status if response_status else 500,
+                    resource_type=self._resource,
+                )
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
 
     def send_patch_request(self, data: str) -> FhirUpdateResponse:
         """

helix_fhir_client_sdk/fhir_update_mixin.py

@@ -3,7 +3,11 @@ from collections.abc import AsyncGenerator
 from compressedfhir.fhir.fhir_resource import FhirResource
 from compressedfhir.fhir.fhir_resource_list import FhirResourceList
 from furl import furl
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
 
+from helix_fhir_client_sdk.open_telemetry.attribute_names import FhirClientSdkOpenTelemetryAttributeNames
+from helix_fhir_client_sdk.open_telemetry.span_names import FhirClientSdkOpenTelemetrySpanNames
 from helix_fhir_client_sdk.responses.fhir_client_protocol import FhirClientProtocol
 from helix_fhir_client_sdk.responses.fhir_update_response import FhirUpdateResponse
 from helix_fhir_client_sdk.structures.get_access_token_result import (
@@ -15,6 +19,8 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_client import (
 )
 from helix_fhir_client_sdk.validators.async_fhir_validator import AsyncFhirValidator
 
+TRACER = trace.get_tracer(__name__)
+
 
 class FhirUpdateMixin(FhirClientProtocol):
     async def update_single_resource_async(self, *, resource: FhirResource) -> FhirUpdateResponse:
@@ -69,60 +75,69 @@ class FhirUpdateMixin(FhirClientProtocol):
             raise ValueError("update should have only one id")
         if not self._resource:
             raise ValueError("update requires a FHIR resource type")
-        full_uri: furl = furl(self._url)
-        full_uri /= self._resource
-        full_uri /= id_ or self._id
-        # set up headers
-        headers = {"Content-Type": "application/fhir+json"}
-        headers.update(self._additional_request_headers)
-        self._internal_logger.debug(f"Request headers: {headers}")
-
-        access_token_result: GetAccessTokenResult = await self.get_access_token_async()
-        access_token: str | None = access_token_result.access_token
-        # set access token in request if present
-        if access_token:
-            headers["Authorization"] = f"Bearer {access_token}"
-
-        if self._validation_server_url:
-            await AsyncFhirValidator.validate_fhir_resource(
-                fn_get_session=lambda: self.create_http_session(),
-                json_data=json_data,
-                resource_name=self._resource,
-                validation_server_url=self._validation_server_url,
-                access_token=access_token,
-            )
-
-        # actually make the request
-        async with RetryableAioHttpClient(
-            fn_get_session=lambda: self.create_http_session(),
-            refresh_token_func=self._refresh_token_function,
-            tracer_request_func=self._trace_request_function,
-            retries=self._retry_count,
-            exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
-            use_data_streaming=self._use_data_streaming,
-            send_data_as_chunked=self._send_data_as_chunked,
-            compress=self._compress,
-            throw_exception_on_error=self._throw_exception_on_error,
-            log_all_url_results=self._log_all_response_urls,
-            access_token=self._access_token,
-            access_token_expiry_date=self._access_token_expiry_date,
-        ) 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)
-            self._internal_logger.debug(f"X-Request-ID={request_id}")
-            if response.status == 200:
-                if self._logger:
-                    self._logger.info(f"Successfully updated: {full_uri}")
-
-            return FhirUpdateResponse(
-                request_id=request_id,
-                url=full_uri.tostr(),
-                responses=await response.get_text_async(),
-                error=f"{response.status}" if not response.status == 200 else None,
-                access_token=access_token,
-                status=response.status,
-                resource_type=self._resource,
-            )
+
+        with TRACER.start_as_current_span(FhirClientSdkOpenTelemetrySpanNames.UPDATE) as span:
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.URL, self._url or "")
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.RESOURCE, self._resource or "")
+            try:
+                full_uri: furl = furl(self._url)
+                full_uri /= self._resource
+                full_uri /= id_ or self._id
+                # set up headers
+                headers = {"Content-Type": "application/fhir+json"}
+                headers.update(self._additional_request_headers)
+                self._internal_logger.debug(f"Request headers: {headers}")
+
+                access_token_result: GetAccessTokenResult = await self.get_access_token_async()
+                access_token: str | None = access_token_result.access_token
+                # set access token in request if present
+                if access_token:
+                    headers["Authorization"] = f"Bearer {access_token}"
+
+                if self._validation_server_url:
+                    await AsyncFhirValidator.validate_fhir_resource(
+                        fn_get_session=lambda: self.create_http_session(),
+                        json_data=json_data,
+                        resource_name=self._resource,
+                        validation_server_url=self._validation_server_url,
+                        access_token=access_token,
+                    )
+
+                # actually make the request
+                async with RetryableAioHttpClient(
+                    fn_get_session=lambda: self.create_http_session(),
+                    refresh_token_func=self._refresh_token_function,
+                    tracer_request_func=self._trace_request_function,
+                    retries=self._retry_count,
+                    exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
+                    use_data_streaming=self._use_data_streaming,
+                    send_data_as_chunked=self._send_data_as_chunked,
+                    compress=self._compress,
+                    throw_exception_on_error=self._throw_exception_on_error,
+                    log_all_url_results=self._log_all_response_urls,
+                    access_token=self._access_token,
+                    access_token_expiry_date=self._access_token_expiry_date,
+                ) 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)
+                    self._internal_logger.debug(f"X-Request-ID={request_id}")
+                    if response.status == 200:
+                        if self._logger:
+                            self._logger.info(f"Successfully updated: {full_uri}")
+
+                    return FhirUpdateResponse(
+                        request_id=request_id,
+                        url=full_uri.tostr(),
+                        responses=await response.get_text_async(),
+                        error=f"{response.status}" if not response.status == 200 else None,
+                        access_token=access_token,
+                        status=response.status,
+                        resource_type=self._resource,
+                    )
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
 
     def update(self, json_data: str) -> FhirUpdateResponse:
         """

helix_fhir_client_sdk/open_telemetry/attribute_names.py

@@ -2,3 +2,6 @@ class FhirClientSdkOpenTelemetryAttributeNames:
     """Constants for OpenTelemetry attribute names used in the FHIR Client SDK."""
 
     URL: str = "fhir.client_sdk.url"
+    RESOURCE: str = "fhir.client_sdk.resource"
+    JSON_DATA_COUNT: str = "fhir.client_sdk.json_data.count"
+    BATCH_SIZE: str = "fhir.client_sdk.batch.size"

helix_fhir_client_sdk/open_telemetry/span_names.py

@@ -6,3 +6,7 @@ class FhirClientSdkOpenTelemetrySpanNames:
     GET_ACCESS_TOKEN: str = "fhir.client_sdk.access_token.get"
     HTTP_GET: str = "fhir.client_sdk.http.get"
     HANDLE_RESPONSE: str = "fhir.client_sdk.handle_response"
+    DELETE: str = "fhir.client_sdk.delete"
+    UPDATE: str = "fhir.client_sdk.update"
+    PATCH: str = "fhir.client_sdk.patch"
+    MERGE: str = "fhir.client_sdk.merge"

helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py

@@ -47,8 +47,30 @@ class RetryableAioHttpClient:
         access_token_expiry_date: datetime | None,
     ) -> None:
         """
-        RetryableClient provides a way to make HTTP calls with automatic retry and automatic refreshing of access tokens
+        RetryableClient provides a way to make HTTP calls with automatic retry and automatic refreshing of access tokens.
 
+        Session Lifecycle Management:
+        - If fn_get_session is None (default): The SDK creates and manages the session lifecycle.
+          The session will be automatically closed when exiting the context manager.
+        - If fn_get_session is provided: The caller is responsible for managing the session lifecycle.
+          The SDK will NOT close the session - the caller must close it themselves.
+
+        :param retries: Number of retry attempts for failed requests
+        :param timeout_in_seconds: Timeout for HTTP requests
+        :param backoff_factor: Factor for exponential backoff between retries
+        :param retry_status_codes: HTTP status codes that trigger a retry
+        :param refresh_token_func: Function to refresh authentication tokens
+        :param tracer_request_func: Function to trace/log requests
+        :param fn_get_session: Optional callable that returns a ClientSession. If provided,
+                               the caller is responsible for closing the session.
+        :param exclude_status_codes_from_retry: Status codes to exclude from retry logic
+        :param use_data_streaming: Whether to stream response data
+        :param compress: Whether to compress request data
+        :param send_data_as_chunked: Whether to use chunked transfer encoding
+        :param throw_exception_on_error: Whether to raise exceptions on HTTP errors
+        :param log_all_url_results: Whether to log all URL results
+        :param access_token: Access token for authentication
+        :param access_token_expiry_date: Expiry date of the access token
         """
         self.retries: int = retries
         self.timeout_in_seconds: float | None = timeout_in_seconds
@@ -58,6 +80,8 @@ class RetryableAioHttpClient:
         )
         self.refresh_token_func_async: RefreshTokenFunction | None = refresh_token_func
         self.trace_function_async: TraceRequestFunction | None = tracer_request_func
+        # Automatically determine if a session is caller-managed based on whether fn_get_session is provided
+        self._caller_managed_session: bool = fn_get_session is not None
         self.fn_get_session: Callable[[], ClientSession] = (
             fn_get_session if fn_get_session is not None else lambda: ClientSession()
         )
@@ -81,7 +105,9 @@ class RetryableAioHttpClient:
         exc_val: BaseException | None,
         exc_tb: type[BaseException] | None | None,
     ) -> None:
-        if self.session is not None:
+        # Only close the session if SDK created it (fn_get_session was not provided)
+        # If the caller provided fn_get_session, they are responsible for closing the session
+        if not self._caller_managed_session and self.session is not None:
             await self.session.close()
 
     @staticmethod
@@ -115,7 +141,7 @@ class RetryableAioHttpClient:
             try:
                 if headers:
                     kwargs["headers"] = headers
-                # if there is no data then remove from kwargs so as not to confuse aiohttp
+                # if there is no data, then remove from kwargs so as not to confuse aiohttp
                 if "data" in kwargs and kwargs["data"] is None:
                     del kwargs["data"]
                 # compression and chunked can only be enabled if there is content sent
@@ -399,7 +425,7 @@ class RetryableAioHttpClient:
         if retry_after_text:
             # noinspection PyBroadException
             try:
-                if retry_after_text.isnumeric():  # it is number of seconds
+                if retry_after_text.isnumeric():  # it is a number of seconds
                     await asyncio.sleep(int(retry_after_text))
                 else:
                     wait_till: datetime = datetime.strptime(retry_after_text, "%a, %d %b %Y %H:%M:%S GMT")
@@ -413,7 +439,7 @@ class RetryableAioHttpClient:
                     if time_diff > 0:
                         await asyncio.sleep(time_diff)
             except Exception:
-                # if there was some exception parsing the Retry-After header, sleep for 60 seconds
+                # if there was some exception, parsing the Retry-After header, sleep for 60 seconds
                 await asyncio.sleep(60)
         else:
             await asyncio.sleep(60)

{helix_fhir_client_sdk-4.2.15.dist-info → helix_fhir_client_sdk-4.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.15
+Version: 4.2.16
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi
@@ -111,9 +111,46 @@ response: Optional[FhirGetResponse] = await FhirGetResponse.from_async_generator
 ```
 
 # Data Streaming
-For FHIR servers that support data streaming (e.g., b.well FHIR server), you can just set the `use_data_streaming` parameter to stream the data as it i received.
+For FHIR servers that support data streaming (e.g., b.well FHIR server), you can just set the `use_data_streaming` parameter to stream the data as it is received.
 The data will be streamed in AsyncGenerators as described above.
 
+# Persistent Sessions (Connection Reuse)
+By default, the SDK creates a new HTTP session for each request. For better performance (~4× faster), 
+you can use persistent sessions to reuse connections across multiple requests.
+
+**Important**: When you provide a custom session factory using `use_http_session()`, YOU are responsible 
+for managing the session lifecycle, including closing it when done. The SDK will NOT automatically close 
+user-provided sessions.
+
+```python
+import aiohttp
+from helix_fhir_client_sdk.fhir_client import FhirClient
+
+# Create a persistent session for connection reuse
+session = aiohttp.ClientSession()
+
+try:
+    # Configure FhirClient to use persistent session
+    fhir_client = (
+        FhirClient()
+        .url("https://fhir.example.com")
+        .resource("Patient")
+        .use_http_session(lambda: session)  # User provides session factory
+    )
+    
+    # Multiple requests reuse the same connection (~4× performance boost)
+    response1 = await fhir_client.get_async()
+    response2 = await fhir_client.clone().resource("Observation").get_async()
+    
+finally:
+    # User must close the session when done
+    await session.close()
+```
+
+**Session Lifecycle Rules**:
+- **No custom factory** (default): SDK creates and closes the session automatically
+- **Custom factory provided**: User is responsible for closing the session
+
 # Storage Compression
 The FHIR client SDK supports two types of compression:
 

{helix_fhir_client_sdk-4.2.15.dist-info → helix_fhir_client_sdk-4.2.16.dist-info}/RECORD

@@ -3,12 +3,12 @@ helix_fhir_client_sdk/dictionary_parser.py,sha256=WrGkVAxMlUvVycRVrX7UZt2oP2e_Vk
 helix_fhir_client_sdk/dictionary_writer.py,sha256=V7Bx9Z69s0LRYF6Lc6Xp0d-Gj0BnAVKA1vBuwf3JORE,1486
 helix_fhir_client_sdk/fhir_auth_mixin.py,sha256=L-_fwQbyojv6AoRUYkPSXWEsW7NRInvJ3wwYgINEtJs,14351
 helix_fhir_client_sdk/fhir_bundle_appender.py,sha256=t1hs7p_vXKC9MUFyUnN9dTuDhRF-kw-kkgVFtGHv9QQ,11749
-helix_fhir_client_sdk/fhir_client.py,sha256=zCMK19efEE-D6aDfbi5lOBD6Hw-Wa1dWdQj_a1GCLaQ,36142
-helix_fhir_client_sdk/fhir_delete_mixin.py,sha256=KaBBkV771sxbqskNZbW0yNVATDaRhd5sX58AKHHai9c,6407
-helix_fhir_client_sdk/fhir_merge_mixin.py,sha256=5d0w_hQVJ5EB9FE8jDbgpPwgwCgmf4ZUZ-JY-Rm6zSE,15191
+helix_fhir_client_sdk/fhir_client.py,sha256=dHfkruJZ1uPM4cmKcnn4HqI0BCDP3IwIqXSLvCu4IsY,37346
+helix_fhir_client_sdk/fhir_delete_mixin.py,sha256=IRcJ5AJ7yrsc1HbjqYW5-jAcIEwG__9nEqwbvvC8qJ0,7532
+helix_fhir_client_sdk/fhir_merge_mixin.py,sha256=h2lvpLDs5nvt9F1bcpd110LFuFXI2HW-uKrUs5TbW7I,17783
 helix_fhir_client_sdk/fhir_merge_resources_mixin.py,sha256=QO2SeZa4Co69f_2YCz0_ss2dJb4xhVMkRdzbjLIJ-iI,35799
-helix_fhir_client_sdk/fhir_patch_mixin.py,sha256=t_Qi-FsqNdCUnRMiliL9h09824A-OI3p9bbhM5mI-7Y,5797
-helix_fhir_client_sdk/fhir_update_mixin.py,sha256=XYpj0w4TokxHSh1EFqLTHvsfrsIIfwk1q2BN_iuWkXE,6173
+helix_fhir_client_sdk/fhir_patch_mixin.py,sha256=QLTsqhFLGi4gC_qQblnCA4skdiLw8h4QRlzvaeyFkl4,7249
+helix_fhir_client_sdk/fhir_update_mixin.py,sha256=_Yx9yg809N8EXY07XlwHxSJLp-xIzpNg5erL92LOeww,7370
 helix_fhir_client_sdk/function_types.py,sha256=x95j6ix3Xa9b276Q741xX1jguqBuFT6EBLDw35_EoVM,3916
 helix_fhir_client_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 helix_fhir_client_sdk/well_known_configuration.py,sha256=hwKpqZoJHkHuCEOowoXk07ywEMMhr_rcmQHNKCUEgVk,221
@@ -38,8 +38,8 @@ helix_fhir_client_sdk/graph/test/test_graph_mixin.py,sha256=LNd4LVjryVLgzWeTXMDp
 helix_fhir_client_sdk/graph/test/test_simulate_graph_processor_mixin.py,sha256=EQDfhqJfUrP6SptXRP7ayEN7g5cZQMA00ccXzeXiSXM,46312
 helix_fhir_client_sdk/graph/test/test_simulate_graph_processor_mixin_caching.py,sha256=WFzKKHtKDcOOXjXRMKkRyJ64whoJoo9M9ST88ayvEbY,16176
 helix_fhir_client_sdk/open_telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-helix_fhir_client_sdk/open_telemetry/attribute_names.py,sha256=iUxm82t5-_qONL3Ld6LkzOwjuuCwcOptaJVBgCE4tps,169
-helix_fhir_client_sdk/open_telemetry/span_names.py,sha256=Y-k29sniK5beSgkEz335eYFpybaw3K_3VU-ayxLdrW0,380
+helix_fhir_client_sdk/open_telemetry/attribute_names.py,sha256=mcPcgpaRe-hZDmPu8gLQo51E_-rllAk2OXMC9uK6EmM,328
+helix_fhir_client_sdk/open_telemetry/span_names.py,sha256=sEuzUXxE9pSoAZti2YVifBqbo3r4SLTPlIUW4F2EuP0,548
 helix_fhir_client_sdk/queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 helix_fhir_client_sdk/queue/request_queue_mixin.py,sha256=Q5ZyadT2nMX6TATsiy0FLXzzCpTbVjN0Gh-B_F0RGCk,21684
 helix_fhir_client_sdk/responses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -104,7 +104,7 @@ helix_fhir_client_sdk/utilities/hash_util.py,sha256=YNUy7-IC_OtC0l-T45UO9UkA-_ps
 helix_fhir_client_sdk/utilities/list_chunker.py,sha256=2h2k5CCFmOhICaugOx6UI-9dh4q5w1lVdF7WQLX0LCM,1456
 helix_fhir_client_sdk/utilities/ndjson_chunk_streaming_parser.py,sha256=3TCYfWVCEpJbqRxqlSDsGnFnraO4T9bxzYdShvu6Pos,1954
 helix_fhir_client_sdk/utilities/practitioner_generator.py,sha256=gneCAXNDNEphBY-Nc2nMQBbEWJgHcjvv3S8JQ75yiJI,3778
-helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py,sha256=Gb_-EcJRpNlMr5Ma2VlJY51jMCGiU-embiA1V6WMR9s,20617
+helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py,sha256=8DdzqTmIY1hWlxmEXOxycBpa72wTo-vsAtcLO4hpnmQ,22605
 helix_fhir_client_sdk/utilities/retryable_aiohttp_response.py,sha256=DvNX6WO1m2Hz6LoI5CwSPDECPd8oDsqRCVsyq_Oxf-0,3542
 helix_fhir_client_sdk/utilities/retryable_aiohttp_url_result.py,sha256=Gdmvn6qIM2JF0YOhobQUHY41fCxvYyaths_CZs0iJfo,616
 helix_fhir_client_sdk/utilities/url_checker.py,sha256=_JRSIvu7WNXh2OA79HJbEEiomGT-quGhAUGh44-9824,3580
@@ -130,7 +130,7 @@ helix_fhir_client_sdk/validators/async_fhir_validator.py,sha256=Bgiw5atbc5YzBYpk
 helix_fhir_client_sdk/validators/fhir_validator.py,sha256=HWBldSEB9yeKIcnLcV8R-LoTzwT_OMu8SchtUUBKzys,2331
 helix_fhir_client_sdk/validators/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 helix_fhir_client_sdk/validators/test/test_async_fhir_validator.py,sha256=RmSowjPUdZee5nYuYujghxWyqJ20cu7U0lJFtFT-ZBs,3285
-helix_fhir_client_sdk-4.2.15.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+helix_fhir_client_sdk-4.2.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/logger_for_test.py,sha256=UC-7F6w6fDsUIYf37aRnvUdiUUVk8qkJEUSuO17NQnI,1525
 tests/test_fhir_client_clone.py,sha256=c5y1rWJ32nBSUnK1FfyymY005dNowd4Nf1xrbuQolNk,5368
@@ -153,6 +153,7 @@ tests/async/test_async_real_fhir_server_get_patients.py,sha256=0oMnUJg1KEspJ5_4e
 tests/async/test_async_real_fhir_server_get_patients_error.py,sha256=_s7chLogAg0yKgGpsq1o9_dDHBrzGaRWBAo8agFTN6U,1914
 tests/async/test_benchmark_compress.py,sha256=q1gDG7qXvof-3uVAqJlZAW7uO8cR0vEeDfzl-iwIEtY,16470
 tests/async/test_benchmark_merge.py,sha256=ME0Pow_IXpIaVGWvq3ii7dGltXcz-3DGxz2gGF4LmYQ,19830
+tests/async/test_retryable_client_session_management.py,sha256=cOAE0wGkh3cv0AS187nujeial3gGEu1VlOJ5b9-LaCI,5360
 tests/async/fhir_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/async/fhir_server/test_async_real_fhir_server_get_graph_large.py,sha256=fM2MPF47nDF2Qwj2AkdTZ2CfvgUYGN4AVIS253KC9MQ,9430
 tests/async/fhir_server/test_async_real_fhir_server_get_patients_large.py,sha256=rXRF8E8Al7XANCmef1d_WqxSA9TVQjVC7B41OZaEQlY,5583
@@ -212,7 +213,7 @@ tests_integration/test_emr_server_auth.py,sha256=2I4QUAspQN89uGf6JB2aVuYaBeDnRJz
 tests_integration/test_firely_fhir.py,sha256=ll6-plwQrKfdrEyfbw0wLTC1jB-Qei1Mj-81tYTl5eQ,697
 tests_integration/test_merge_vs_smart_merge_behavior.py,sha256=LrIuyxzw0YLaTjcRtG0jzy0M6xSv9qebmdBtMPDcacQ,3733
 tests_integration/test_staging_server_graph.py,sha256=5RfMxjhdX9o4-n_ZRvze4Sm8u8NjRijRLDpqiz8qD_0,7132
-helix_fhir_client_sdk-4.2.15.dist-info/METADATA,sha256=7L_vOwYcAkZTKkAtwRolmGQbB7X90cN9EuuwiwBTo24,5845
-helix_fhir_client_sdk-4.2.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-helix_fhir_client_sdk-4.2.15.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
-helix_fhir_client_sdk-4.2.15.dist-info/RECORD,,
+helix_fhir_client_sdk-4.2.16.dist-info/METADATA,sha256=AHcaKMqC3ICIbjD_Fr8CXs8MxOXLzdyh3A76J-SVYMk,7210
+helix_fhir_client_sdk-4.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+helix_fhir_client_sdk-4.2.16.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
+helix_fhir_client_sdk-4.2.16.dist-info/RECORD,,