helix.fhir.client.sdk 4.2.2__tar.gz → 4.2.4__tar.gz

{helix_fhir_client_sdk-4.2.2/helix.fhir.client.sdk.egg-info → helix_fhir_client_sdk-4.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.2
+Version: 4.2.4
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi
@@ -19,10 +19,7 @@ Requires-Dist: chardet
 Requires-Dist: aiohttp
 Requires-Dist: async-timeout>=4.0.3
 Requires-Dist: python-dateutil
-Requires-Dist: compressedfhir>=1.0.13
-Requires-Dist: certifi>=2025.1.31
-Requires-Dist: opentelemetry-api>=1.39
-Requires-Dist: multidict>=6
+Requires-Dist: compressedfhir>=1.0.3
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

helix_fhir_client_sdk-4.2.4/VERSION

@@ -0,0 +1 @@
+4.2.4

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4/helix.fhir.client.sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.2
+Version: 4.2.4
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi
@@ -19,10 +19,7 @@ Requires-Dist: chardet
 Requires-Dist: aiohttp
 Requires-Dist: async-timeout>=4.0.3
 Requires-Dist: python-dateutil
-Requires-Dist: compressedfhir>=1.0.13
-Requires-Dist: certifi>=2025.1.31
-Requires-Dist: opentelemetry-api>=1.39
-Requires-Dist: multidict>=6
+Requires-Dist: compressedfhir>=1.0.3
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix.fhir.client.sdk.egg-info/SOURCES.txt

@@ -51,9 +51,6 @@ helix_fhir_client_sdk/graph/test/__init__.py
 helix_fhir_client_sdk/graph/test/test_graph_mixin.py
 helix_fhir_client_sdk/graph/test/test_simulate_graph_processor_mixin.py
 helix_fhir_client_sdk/graph/test/test_simulate_graph_processor_mixin_caching.py
-helix_fhir_client_sdk/open_telemetry/__init__.py
-helix_fhir_client_sdk/open_telemetry/attribute_names.py
-helix_fhir_client_sdk/open_telemetry/span_names.py
 helix_fhir_client_sdk/queue/__init__.py
 helix_fhir_client_sdk/queue/request_queue_mixin.py
 helix_fhir_client_sdk/responses/__init__.py
@@ -116,6 +113,7 @@ helix_fhir_client_sdk/utilities/fhir_scope_parser_result.py
 helix_fhir_client_sdk/utilities/fhir_server_helpers.py
 helix_fhir_client_sdk/utilities/hash_util.py
 helix_fhir_client_sdk/utilities/list_chunker.py
+helix_fhir_client_sdk/utilities/logging_decorators.py
 helix_fhir_client_sdk/utilities/ndjson_chunk_streaming_parser.py
 helix_fhir_client_sdk/utilities/practitioner_generator.py
 helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py

helix_fhir_client_sdk-4.2.4/helix.fhir.client.sdk.egg-info/requires.txt

@@ -0,0 +1,8 @@
+furl
+requests
+urllib3
+chardet
+aiohttp
+async-timeout>=4.0.3
+python-dateutil
+compressedfhir>=1.0.3

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/fhir_auth_mixin.py

@@ -8,13 +8,11 @@ from threading import Lock
 from typing import TYPE_CHECKING, Any, cast
 
 from furl import furl
-from opentelemetry import trace
 
 from helix_fhir_client_sdk.function_types import (
     RefreshTokenFunction,
     RefreshTokenResult,
 )
-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.structures.get_access_token_result import (
     GetAccessTokenResult,
@@ -33,9 +31,6 @@ if TYPE_CHECKING:
     from helix_fhir_client_sdk.fhir_client import FhirClient
 
 
-TRACER = trace.get_tracer(__name__)
-
-
 class FhirAuthMixin(FhirClientProtocol):
     _time_to_live_in_secs_for_cache: int = 10 * 60
 
@@ -124,15 +119,15 @@ class FhirAuthMixin(FhirClientProtocol):
                 access_token=self._access_token,
                 expiry_date=self._access_token_expiry_date,
             )
-        with TRACER.start_as_current_span(FhirClientSdkOpenTelemetrySpanNames.GET_ACCESS_TOKEN):
-            refresh_token_result: RefreshTokenResult = await self._refresh_token_function(
-                url=None, status_code=0, current_token=None, expiry_date=None, retry_count=0
-            )
-            assert isinstance(refresh_token_result, RefreshTokenResult)
 
-            self.set_access_token(refresh_token_result.access_token)
-            self.set_access_token_expiry_date(refresh_token_result.expiry_date)
-            return GetAccessTokenResult(access_token=self._access_token, expiry_date=self._access_token_expiry_date)
+        refresh_token_result: RefreshTokenResult = await self._refresh_token_function(
+            url=None, status_code=0, current_token=None, expiry_date=None, retry_count=0
+        )
+        assert isinstance(refresh_token_result, RefreshTokenResult)
+
+        self.set_access_token(refresh_token_result.access_token)
+        self.set_access_token_expiry_date(refresh_token_result.expiry_date)
+        return GetAccessTokenResult(access_token=self._access_token, expiry_date=self._access_token_expiry_date)
 
     def authenticate_async_wrapper(self) -> RefreshTokenFunction:
         """

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/fhir_client.py

@@ -26,8 +26,6 @@ from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode im
     CompressedDictStorageMode,
 )
 from furl import furl
-from opentelemetry import trace
-from opentelemetry.trace import Status, StatusCode
 from requests.adapters import BaseAdapter
 
 from helix_fhir_client_sdk.dictionary_writer import convert_dict_to_str
@@ -48,7 +46,6 @@ from helix_fhir_client_sdk.graph.fhir_graph_mixin import FhirGraphMixin
 from helix_fhir_client_sdk.graph.simulated_graph_processor_mixin import (
     SimulatedGraphProcessorMixin,
 )
-from helix_fhir_client_sdk.open_telemetry.span_names import FhirClientSdkOpenTelemetrySpanNames
 from helix_fhir_client_sdk.queue.request_queue_mixin import RequestQueueMixin
 from helix_fhir_client_sdk.responses.fhir_client_protocol import FhirClientProtocol
 from helix_fhir_client_sdk.responses.fhir_get_response import FhirGetResponse
@@ -58,8 +55,6 @@ from helix_fhir_client_sdk.structures.get_access_token_result import (
 from helix_fhir_client_sdk.utilities.async_runner import AsyncRunner
 from helix_fhir_client_sdk.utilities.fhir_client_logger import FhirClientLogger
 
-TRACER = trace.get_tracer(__name__)
-
 
 class FhirClient(
     SimulatedGraphProcessorMixin,
@@ -471,24 +466,6 @@ class FhirClient(
         self._throw_exception_on_error = throw_exception_on_error
         return self
 
-    def set_persistent_session(self, session: ClientSession | None) -> FhirClient:
-        """
-        Sets the persistent session to use for requests
-
-        :param session: persistent session
-        """
-        self._persistent_session = session
-        return self
-
-    def use_persistent_session(self, value: bool) -> FhirClient:
-        """
-        Sets the use_persistent_session flag
-
-        :param value: whether to use the persistent session
-        """
-        self._use_persistent_session = value
-        return self
-
     def close_session_after_request(self, value: bool) -> FhirClient:
         """
         Sets the _close_session flag (default is True)
@@ -611,34 +588,33 @@ class FhirClient(
 
         :return: response
         """
-        with TRACER.start_as_current_span(FhirClientSdkOpenTelemetrySpanNames.GET):
-            instance_variables_text = convert_dict_to_str(FhirClientLogger.get_variables_to_log(vars(self)))
-            if self._logger:
-                # self._logger.info(f"LOGLEVEL: {self._log_level}")
-                self._logger.debug(f"parameters: {instance_variables_text}")
-            else:
-                self._internal_logger.debug(f"LOGLEVEL (InternalLogger): {self._log_level}")
-                self._internal_logger.debug(f"parameters: {instance_variables_text}")
-            ids: list[str] | None = None
-            if self._id:
-                ids = self._id if isinstance(self._id, list) else [self._id]
-            # actually make the request
-            full_response: FhirGetResponse | None = None
-            async for response in self._get_with_session_async(
-                ids=ids,
-                fn_handle_streaming_chunk=data_chunk_handler,
-                page_number=None,
-                id_above=None,
-                additional_parameters=None,
-                resource_type=None,
-            ):
-                if response:
-                    if full_response:
-                        full_response = full_response.append(response)
-                    else:
-                        full_response = response
-            assert full_response
-            return full_response
+        instance_variables_text = convert_dict_to_str(FhirClientLogger.get_variables_to_log(vars(self)))
+        if self._logger:
+            # self._logger.info(f"LOGLEVEL: {self._log_level}")
+            self._logger.debug(f"parameters: {instance_variables_text}")
+        else:
+            self._internal_logger.debug(f"LOGLEVEL (InternalLogger): {self._log_level}")
+            self._internal_logger.debug(f"parameters: {instance_variables_text}")
+        ids: list[str] | None = None
+        if self._id:
+            ids = self._id if isinstance(self._id, list) else [self._id]
+        # actually make the request
+        full_response: FhirGetResponse | None = None
+        async for response in self._get_with_session_async(
+            ids=ids,
+            fn_handle_streaming_chunk=data_chunk_handler,
+            page_number=None,
+            id_above=None,
+            additional_parameters=None,
+            resource_type=None,
+        ):
+            if response:
+                if full_response:
+                    full_response = full_response.append(response)
+                else:
+                    full_response = response
+        assert full_response
+        return full_response
 
     async def get_raw_resources_async(
         self,
@@ -679,37 +655,27 @@ class FhirClient(
 
         :return: async generator of responses
         """
-        span = TRACER.start_span(FhirClientSdkOpenTelemetrySpanNames.GET_STREAMING)
-        try:
-            instance_variables_text = convert_dict_to_str(FhirClientLogger.get_variables_to_log(vars(self)))
-            if self._logger:
-                # self._logger.info(f"LOGLEVEL: {self._log_level}")
-                self._logger.info(f"parameters: {instance_variables_text}")
-            else:
-                self._internal_logger.info(f"LOGLEVEL (InternalLogger): {self._log_level}")
-                self._internal_logger.info(f"parameters: {instance_variables_text}")
-            ids: list[str] | None = None
-            if self._id:
-                ids = self._id if isinstance(self._id, list) else [self._id]
-            # actually make the request
-            response: FhirGetResponse | None
-            async for response in self._get_with_session_async(
-                ids=ids,
-                fn_handle_streaming_chunk=data_chunk_handler,
-                page_number=None,
-                id_above=None,
-                additional_parameters=None,
-                resource_type=None,
-            ):
-                yield response
-        except BaseException as exc:  # propagate cancellation/errors but keep span informative
-            # Record exception in span
-            span.record_exception(exc)
-            span.set_status(Status(StatusCode.ERROR, str(exc)))
-            raise
-        finally:
-            # Ensure span is ended after generator is exhausted or error occurs
-            span.end()
+        instance_variables_text = convert_dict_to_str(FhirClientLogger.get_variables_to_log(vars(self)))
+        if self._logger:
+            # self._logger.info(f"LOGLEVEL: {self._log_level}")
+            self._logger.info(f"parameters: {instance_variables_text}")
+        else:
+            self._internal_logger.info(f"LOGLEVEL (InternalLogger): {self._log_level}")
+            self._internal_logger.info(f"parameters: {instance_variables_text}")
+        ids: list[str] | None = None
+        if self._id:
+            ids = self._id if isinstance(self._id, list) else [self._id]
+        # actually make the request
+        response: FhirGetResponse | None
+        async for response in self._get_with_session_async(
+            ids=ids,
+            fn_handle_streaming_chunk=data_chunk_handler,
+            page_number=None,
+            id_above=None,
+            additional_parameters=None,
+            resource_type=None,
+        ):
+            yield response
 
     def get(self) -> FhirGetResponse:
         """

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/fhir_delete_mixin.py

@@ -56,13 +56,10 @@ 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,
-            use_persistent_session=self._use_persistent_session,
-            close_session_on_exit=self._close_session,
         ) as client:
             response: RetryableAioHttpResponse = await client.delete(url=full_uri.tostr(), headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)
-            self._internal_logger.debug(f"X-Request-ID={request_id}")
+            self._internal_logger.info(f"X-Request-ID={request_id}")
             if response.status == 200:
                 if self._logger:
                     self._logger.info(f"Successfully deleted: {full_uri}")
@@ -131,7 +128,7 @@ class FhirDeleteMixin(FhirClientProtocol):
         ) as client:
             response: RetryableAioHttpResponse = await client.delete(url=full_url, headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)
-            self._internal_logger.debug(f"X-Request-ID={request_id}")
+            self._internal_logger.info(f"X-Request-ID={request_id}")
             if response.status == 200:
                 if self._logger:
                     self._logger.info(f"Successfully deleted: {full_uri}")

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/fhir_merge_mixin.py

@@ -181,9 +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,
-                            use_persistent_session=self._use_persistent_session,
-                            close_session_on_exit=self._close_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(
@@ -193,7 +190,7 @@ class FhirMergeMixin(FhirClientProtocol):
                             )
                             response_status = response.status
                             request_id = response.response_headers.get("X-Request-ID", None)
-                            self._internal_logger.debug(f"X-Request-ID={request_id}")
+                            self._internal_logger.info(f"X-Request-ID={request_id}")
                             if response and response.status == 200:
                                 response_text = await response.get_text_async()
                                 if response_text:

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/fhir_merge_resources_mixin.py

@@ -124,9 +124,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,
-                        use_persistent_session=self._use_persistent_session,
-                        close_session_on_exit=self._close_session,
                     ) as client:
                         # should we check if it exists and do a POST then?
                         response: RetryableAioHttpResponse = await client.post(
@@ -136,7 +133,7 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                         )
                         response_status = response.status
                         request_id = response.response_headers.get("X-Request-ID", None)
-                        self._internal_logger.debug(f"X-Request-ID={request_id}")
+                        self._internal_logger.info(f"X-Request-ID={request_id}")
                         if response and response.status == 200:
                             response_text = await response.get_text_async()
                             if response_text:
@@ -343,9 +340,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,
-                            close_session_on_exit=self._close_session,
-                            persistent_session=self._persistent_session,
-                            use_persistent_session=self._use_persistent_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(
@@ -355,7 +349,7 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                             )
                             response_status = response.status
                             request_id = response.response_headers.get("X-Request-ID", None)
-                            self._internal_logger.debug(f"X-Request-ID={request_id}")
+                            self._internal_logger.info(f"X-Request-ID={request_id}")
                             if response and response.status == 200:
                                 response_text = await response.get_text_async()
                                 if response_text:

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/fhir_patch_mixin.py

@@ -72,9 +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,
-                use_persistent_session=self._use_persistent_session,
-                close_session_on_exit=self._close_session,
             ) as client:
                 response: RetryableAioHttpResponse = await client.patch(
                     url=full_uri.url, json=deserialized_data, headers=headers
@@ -82,7 +79,7 @@ class FhirPatchMixin(FhirClientProtocol):
                 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}")
+                self._internal_logger.info(f"X-Request-ID={request_id}")
 
                 if response_status == 200:
                     if self._logger:

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/fhir_update_mixin.py

@@ -106,13 +106,10 @@ 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,
-            use_persistent_session=self._use_persistent_session,
-            close_session_on_exit=self._close_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)
-            self._internal_logger.debug(f"X-Request-ID={request_id}")
+            self._internal_logger.info(f"X-Request-ID={request_id}")
             if response.status == 200:
                 if self._logger:
                     self._logger.info(f"Successfully updated: {full_uri}")

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py

@@ -3,6 +3,7 @@ from abc import ABC
 from collections.abc import AsyncGenerator
 from datetime import UTC, datetime
 from logging import Logger
+import logging
 from typing import Any, cast
 from urllib.parse import quote
 
@@ -43,6 +44,7 @@ from helix_fhir_client_sdk.utilities.cache.request_cache import RequestCache
 from helix_fhir_client_sdk.utilities.cache.request_cache_entry import RequestCacheEntry
 from helix_fhir_client_sdk.utilities.fhir_scope_parser import FhirScopeParser
 from helix_fhir_client_sdk.utilities.hash_util import ResourceHash
+from helix_fhir_client_sdk.utilities.logging_decorators import log_execution_time, log_execution_time_asyncgen
 
 
 class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
@@ -57,6 +59,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
     """
 
     # noinspection PyPep8Naming,PyUnusedLocal
+    @log_execution_time_asyncgen
     async def process_simulate_graph_async(
         self,
         *,
@@ -247,26 +250,30 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
 
                 # Update parent link map for next iteration
                 parent_link_map = new_parent_link_map
-
+            logging.info(f"# Combine and process responses")
             # Combine and process responses
-            parent_response = cast(FhirGetBundleResponse, parent_response.extend(child_responses))
 
+            parent_response = cast(FhirGetBundleResponse, parent_response.extend(child_responses))
+            logging.info(f"# if sort_resources:")
             # Optional resource sorting
             if sort_resources:
                 parent_response = parent_response.sort_resources()
-
+            logging.info(f"# full_response: FhirGetResponse")
             # Prepare final response based on bundling preferences
             full_response: FhirGetResponse
             if separate_bundle_resources:
+                logging.info(f"# if separate_bundle_resources:")
                 full_response = FhirGetListByResourceTypeResponse.from_response(other_response=parent_response)
             elif expand_fhir_bundle:
+                logging.info(f"# elif expand_fhir_bundle:")
                 full_response = FhirGetListResponse.from_response(other_response=parent_response)
             else:
+                logging.info(f"# else:")
                 full_response = parent_response
-
+            logging.info(f"full_response.url = url or parent_response.url")
             # Set response URL
             full_response.url = url or parent_response.url
-
+            logging.info(f"# Log cache performance")
             # Log cache performance
             if logger:
                 logger.info(
@@ -287,6 +294,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             self.create_http_session = original_create_http_session  # type: ignore[method-assign]
 
     # noinspection PyUnusedLocal
+    @log_execution_time
     async def process_link_async_parallel_function(
         self,
         context: ParallelFunctionContext,
@@ -381,6 +389,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         # Return the list of retrieved responses
         return result
 
+    @log_execution_time_asyncgen
     async def _process_link_async(
         self,
         *,
@@ -465,6 +474,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 yield target_response
 
     # noinspection PyUnusedLocal
+    @log_execution_time
     async def process_target_async_parallel_function(
         self,
         context: ParallelFunctionContext,
@@ -536,6 +546,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         # Return the list of retrieved responses
         return result
 
+    @log_execution_time
     async def _process_child_group(
         self,
         *,
@@ -617,6 +628,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         # Return the retrieved child resources
         return child_response
 
+    @log_execution_time_asyncgen
     async def _process_target_async(
         self,
         *,
@@ -852,6 +864,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         if target.link:
             parent_link_map.append((target.link, children))
 
+    @log_execution_time
     async def _get_resources_by_id_one_by_one_async(
         self,
         *,
@@ -928,6 +941,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
 
         return result
 
+    @log_execution_time
     async def _get_resources_by_parameters_async(
         self,
         *,
@@ -1153,6 +1167,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         return bundle_response, cache.cache_hits
 
     # noinspection PyPep8Naming
+    @log_execution_time
     async def simulate_graph_async(
         self,
         *,
@@ -1233,6 +1248,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         return result
 
     # noinspection PyPep8Naming
+    @log_execution_time_asyncgen
     async def simulate_graph_streaming_async(
         self,
         *,

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/queue/request_queue_mixin.py

@@ -49,6 +49,9 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
             self._max_concurrent_requests_semaphore = Semaphore(max_concurrent_requests)
         return self
 
+    from helix_fhir_client_sdk.utilities.logging_decorators import log_execution_time_asyncgen
+
+    @log_execution_time_asyncgen
     async def _get_with_session_async(
         self,
         page_number: int | None,
@@ -74,15 +77,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
         request_id: str | None = None
         total_results = 0  # total number of resources returned so far
 
-        limit_count: int | None = self._limit
-
-        # if _count parameter is present in additional_parameters then set limit_count to it
-        if additional_parameters:
-            for param in additional_parameters:
-                if self._limit is None:
-                    if param.startswith("_count="):
-                        limit_count = int(param.split("=")[1])
-
         # create url and query to request from FHIR server
         resources_json: str = ""
         full_url = await self.build_url(
@@ -131,8 +125,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
                 close_session_on_exit=self._close_session,
-                persistent_session=self._persistent_session,
-                use_persistent_session=self._use_persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present
@@ -177,7 +169,7 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                     )
 
                     request_id = response.response_headers.get("X-Request-ID", None)
-                    self._internal_logger.debug(f"X-Request-ID={request_id}")
+                    self._internal_logger.info(f"X-Request-ID={request_id}")
 
                     async for r in FhirResponseProcessor.handle_response(
                         internal_logger=self._internal_logger,
@@ -207,9 +199,9 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                         total_results += resource_count
 
                         # Stop if limit reached
-                        if limit_count and total_results >= limit_count:
+                        if self._limit and total_results >= self._limit:
                             self._internal_logger.info(
-                                f"Reached limit={limit_count} after collecting {total_results} "
+                                f"Reached limit={self._limit} after collecting {total_results} "
                                 f"resources, stopping pagination"
                             )
                             return
@@ -301,9 +293,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,
-                close_session_on_exit=self._close_session,
-                persistent_session=self._persistent_session,
-                use_persistent_session=self._use_persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present
@@ -348,7 +337,7 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                     )
 
                     request_id = response.response_headers.get("X-Request-ID", None)
-                    self._internal_logger.debug(f"X-Request-ID={request_id}")
+                    self._internal_logger.info(f"X-Request-ID={request_id}")
 
                     if response.status == 200:
                         response_next_url = None

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/responses/bundle_expander.py

@@ -1,6 +1,8 @@
 import dataclasses
 from typing import Any
 
+from helix_fhir_client_sdk.utilities.logging_decorators import log_execution_time
+
 
 @dataclasses.dataclass(slots=True)
 class BundleExpanderResult:
@@ -10,6 +12,7 @@ class BundleExpanderResult:
 
 class BundleExpander:
     @staticmethod
+    @log_execution_time
     async def expand_bundle_async(
         *,
         bundle: dict[str, Any],

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.4}/helix_fhir_client_sdk/responses/fhir_client_protocol.py

@@ -89,8 +89,6 @@ class FhirClientProtocol(Protocol):
     _send_data_as_chunked: bool = False
     _last_page_lock: Lock
 
-    _persistent_session: ClientSession | None = None
-    _use_persistent_session: bool = False
     _close_session: bool = True
 
     _use_post_for_search: bool = False
@@ -124,7 +122,7 @@ class FhirClientProtocol(Protocol):
 
     _log_all_response_urls: bool
 
-    _storage_mode: CompressedDictStorageMode
+    _storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.raw()
     """ storage mode to store the responses """
 
     _create_operation_outcome_for_error: bool | None