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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.2
+Version: 4.2.3
 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.3/VERSION

@@ -0,0 +1 @@
+4.2.3

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3/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.3
 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.3}/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

helix_fhir_client_sdk-4.2.3/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.3}/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.3}/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,
@@ -611,34 +606,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 +673,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.3}/helix_fhir_client_sdk/fhir_delete_mixin.py

@@ -62,7 +62,7 @@ class FhirDeleteMixin(FhirClientProtocol):
         ) 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 +131,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.3}/helix_fhir_client_sdk/fhir_merge_mixin.py

@@ -193,7 +193,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.3}/helix_fhir_client_sdk/fhir_merge_resources_mixin.py

@@ -136,7 +136,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:
@@ -355,7 +355,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.3}/helix_fhir_client_sdk/fhir_patch_mixin.py

@@ -82,7 +82,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.3}/helix_fhir_client_sdk/fhir_update_mixin.py

@@ -112,7 +112,7 @@ class FhirUpdateMixin(FhirClientProtocol):
         ) 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.3}/helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py

@@ -250,6 +250,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
 
             # Combine and process responses
             parent_response = cast(FhirGetBundleResponse, parent_response.extend(child_responses))
+            parent_response = parent_response.remove_duplicates()
 
             # Optional resource sorting
             if sort_resources:

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

@@ -74,15 +74,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(
@@ -177,7 +168,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 +198,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
@@ -348,7 +339,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.3}/helix_fhir_client_sdk/responses/fhir_client_protocol.py

@@ -124,7 +124,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

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/fhir_get_response.py

@@ -119,7 +119,7 @@ class FhirGetResponse:
         """ Count of cache hits """
         self.results_by_url: list[RetryableAioHttpUrlResult] = results_by_url
         """ Count of errors in the response by status """
-        self.storage_mode: CompressedDictStorageMode = storage_mode
+        self.storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.raw()
         """ Storage mode for the response """
 
     @abstractmethod

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/fhir_response_processor.py

@@ -11,13 +11,10 @@ from aiohttp.streams import AsyncStreamIterator
 from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
     CompressedDictStorageMode,
 )
-from opentelemetry import trace
-from opentelemetry.trace import Status, StatusCode
 
 from helix_fhir_client_sdk.function_types import (
     HandleStreamingChunkFunction,
 )
-from helix_fhir_client_sdk.open_telemetry.span_names import FhirClientSdkOpenTelemetrySpanNames
 from helix_fhir_client_sdk.responses.bundle_expander import (
     BundleExpander,
     BundleExpanderResult,
@@ -40,8 +37,6 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_response import (
     RetryableAioHttpResponse,
 )
 
-TRACER = trace.get_tracer(__name__)
-
 
 class FhirResponseProcessor:
     """
@@ -98,74 +93,60 @@ class FhirResponseProcessor:
 
         :return: An async generator of FhirGetResponse objects.
         """
-        span = TRACER.start_span(FhirClientSdkOpenTelemetrySpanNames.HANDLE_RESPONSE)
-        try:
-            # if request is ok (200) then return the data
-            if response.ok:
-                async for r in FhirResponseProcessor._handle_response_200(
-                    full_url=full_url,
-                    request_id=request_id,
-                    response=response,
-                    response_headers=response_headers,
-                    fn_handle_streaming_chunk=fn_handle_streaming_chunk,
-                    access_token=access_token,
-                    resources_json=resources_json,
-                    resource=resource,
-                    id_=id_,
-                    logger=logger,
-                    use_data_streaming=use_data_streaming,
-                    chunk_size=chunk_size,
-                    extra_context_to_return=extra_context_to_return,
-                    expand_fhir_bundle=expand_fhir_bundle,
-                    url=url,
-                    separate_bundle_resources=separate_bundle_resources,
-                    storage_mode=storage_mode,
-                    create_operation_outcome_for_error=create_operation_outcome_for_error,
-                ):
-                    yield r
-            elif response.status == 404:  # not found
-                async for r in FhirResponseProcessor._handle_response_404(
-                    full_url=full_url,
-                    request_id=request_id,
-                    response=response,
-                    response_headers=response_headers,
-                    extra_context_to_return=extra_context_to_return,
-                    resource=resource,
-                    logger=logger,
-                    id_=id_,
-                    access_token=access_token,
-                    storage_mode=storage_mode,
-                    create_operation_outcome_for_error=create_operation_outcome_for_error,
-                ):
-                    yield r
-            else:  # unknown response
-                async for r in FhirResponseProcessor._handle_response_unknown(
-                    full_url=full_url,
-                    request_id=request_id,
-                    response=response,
-                    response_headers=response_headers,
-                    resource=resource,
-                    logger=logger,
-                    access_token=access_token,
-                    extra_context_to_return=extra_context_to_return,
-                    id_=id_,
-                    internal_logger=internal_logger,
-                    storage_mode=storage_mode,
-                    create_operation_outcome_for_error=create_operation_outcome_for_error,
-                ):
-                    yield r
-            # Mark span as successful
-            span.set_status(Status(StatusCode.OK))
-
-        except Exception as e:
-            # Record exception in span
-            span.record_exception(e)
-            span.set_status(Status(StatusCode.ERROR, str(e)))
-            raise
-
-        finally:
-            # Ensure span is ended after generator is exhausted or error occurs
-            span.end()
+        # if request is ok (200) then return the data
+        if response.ok:
+            async for r in FhirResponseProcessor._handle_response_200(
+                full_url=full_url,
+                request_id=request_id,
+                response=response,
+                response_headers=response_headers,
+                fn_handle_streaming_chunk=fn_handle_streaming_chunk,
+                access_token=access_token,
+                resources_json=resources_json,
+                resource=resource,
+                id_=id_,
+                logger=logger,
+                use_data_streaming=use_data_streaming,
+                chunk_size=chunk_size,
+                extra_context_to_return=extra_context_to_return,
+                expand_fhir_bundle=expand_fhir_bundle,
+                url=url,
+                separate_bundle_resources=separate_bundle_resources,
+                storage_mode=storage_mode,
+                create_operation_outcome_for_error=create_operation_outcome_for_error,
+            ):
+                yield r
+        elif response.status == 404:  # not found
+            async for r in FhirResponseProcessor._handle_response_404(
+                full_url=full_url,
+                request_id=request_id,
+                response=response,
+                response_headers=response_headers,
+                extra_context_to_return=extra_context_to_return,
+                resource=resource,
+                logger=logger,
+                id_=id_,
+                access_token=access_token,
+                storage_mode=storage_mode,
+                create_operation_outcome_for_error=create_operation_outcome_for_error,
+            ):
+                yield r
+        else:  # unknown response
+            async for r in FhirResponseProcessor._handle_response_unknown(
+                full_url=full_url,
+                request_id=request_id,
+                response=response,
+                response_headers=response_headers,
+                resource=resource,
+                logger=logger,
+                access_token=access_token,
+                extra_context_to_return=extra_context_to_return,
+                id_=id_,
+                internal_logger=internal_logger,
+                storage_mode=storage_mode,
+                create_operation_outcome_for_error=create_operation_outcome_for_error,
+            ):
+                yield r
 
     @staticmethod
     async def _handle_response_unknown(

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/get/fhir_get_bundle_response.py

@@ -59,7 +59,7 @@ class FhirGetBundleResponse(FhirGetResponse):
         chunk_number: int | None = None,
         cache_hits: int | None = None,
         results_by_url: list[RetryableAioHttpUrlResult],
-        storage_mode: CompressedDictStorageMode,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.raw(),
     ) -> None:
         super().__init__(
             request_id=request_id,

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/get/fhir_get_error_response.py

@@ -67,6 +67,7 @@ class FhirGetErrorResponse(FhirGetResponse):
         storage_mode: CompressedDictStorageMode,
         create_operation_outcome_for_error: bool | None,
     ) -> None:
+        storage_mode or CompressedDictStorageMode.raw()
         super().__init__(
             request_id=request_id,
             url=url,

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/get/fhir_get_list_by_resource_type_response.py

@@ -57,7 +57,7 @@ class FhirGetListByResourceTypeResponse(FhirGetResponse):
         chunk_number: int | None = None,
         cache_hits: int | None = None,
         results_by_url: list[RetryableAioHttpUrlResult],
-        storage_mode: CompressedDictStorageMode,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.raw(),
     ) -> None:
         super().__init__(
             request_id=request_id,

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/get/fhir_get_list_response.py

@@ -59,7 +59,7 @@ class FhirGetListResponse(FhirGetResponse):
         chunk_number: int | None = None,
         cache_hits: int | None = None,
         results_by_url: list[RetryableAioHttpUrlResult],
-        storage_mode: CompressedDictStorageMode,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.raw(),
     ) -> None:
         super().__init__(
             request_id=request_id,

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/get/fhir_get_response_factory.py

@@ -50,6 +50,7 @@ class FhirGetResponseFactory:
         storage_mode: CompressedDictStorageMode,
         create_operation_outcome_for_error: bool | None,
     ) -> FhirGetResponse:
+        storage_mode = storage_mode or CompressedDictStorageMode.raw()
         try:
             if not error and response_text:
                 # test if responses is valid json

{helix_fhir_client_sdk-4.2.2 → helix_fhir_client_sdk-4.2.3}/helix_fhir_client_sdk/responses/get/fhir_get_single_response.py

@@ -59,7 +59,7 @@ class FhirGetSingleResponse(FhirGetResponse):
         chunk_number: int | None = None,
         cache_hits: int | None = None,
         results_by_url: list[RetryableAioHttpUrlResult],
-        storage_mode: CompressedDictStorageMode,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.raw(),
     ) -> None:
         super().__init__(
             request_id=request_id,