helix.fhir.client.sdk 4.2.8__py3-none-any.whl → 4.2.9__py3-none-any.whl

helix_fhir_client_sdk/fhir_client.py

@@ -150,9 +150,10 @@ class FhirClient(
         self._log_all_response_urls: bool = False
         """ If True, logs all response URLs and status codes.  Can take a lot of memory for when there are many responses. """
 
-        self._storage_mode = CompressedDictStorageMode(storage_type="raw")
+        # Default to "raw" storage mode - no in-memory compression, resources stored as plain Python dicts
+        self._storage_mode: CompressedDictStorageMode = CompressedDictStorageMode(storage_type="raw")
 
-        self._create_operation_outcome_for_error = False
+        self._create_operation_outcome_for_error: bool | None = False
 
     def action(self, action: str) -> FhirClient:
         """
@@ -455,9 +456,14 @@ class FhirClient(
 
     def compress(self, compress: bool) -> FhirClient:
         """
-        Sets the compress flag
+        Sets whether to use HTTP compression (gzip) when sending request data to the server.
 
-        :param compress: whether to compress the response
+        This controls compression of the HTTP request body only, not in-memory storage.
+        Default is True (compression enabled).
+
+        To disable all compression, call: .compress(False)
+
+        :param compress: whether to compress HTTP request body (default: True)
         """
         self._compress = compress
         return self
@@ -826,17 +832,17 @@ class FhirClient(
         Whether to ask the server to include the total count in the result
 
 
-        :param include_total: whether to include total count
+        :param include_total: whether to include the total count
         """
         self._include_total = include_total
         return self
 
     def filter(self, filter_: list[BaseFilter]) -> FhirClient:
         """
-        Allows adding in a custom filters that derives from BaseFilter
+        Allows adding in custom filters that derive from BaseFilter
 
 
-        :param filter_: list of custom filter instances that derives from BaseFilter.
+        :param filter_: list of custom filter instances that derive from BaseFilter.
         """
         assert isinstance(filter_, list), "This function requires a list"
         self._filters.extend(filter_)
@@ -889,6 +895,16 @@ class FhirClient(
         fhir_client._time_to_live_in_secs_for_cache = self._time_to_live_in_secs_for_cache
         fhir_client._validation_server_url = self._validation_server_url
         fhir_client._smart_merge = self._smart_merge
+        fhir_client._compress = self._compress
+        fhir_client._storage_mode = self._storage_mode
+        fhir_client._send_data_as_chunked = self._send_data_as_chunked
+        fhir_client._use_post_for_search = self._use_post_for_search
+        fhir_client._maximum_time_to_retry_on_429 = self._maximum_time_to_retry_on_429
+        fhir_client._retry_count = self._retry_count
+        fhir_client._throw_exception_on_error = self._throw_exception_on_error
+        fhir_client._trace_request_function = self._trace_request_function
+        fhir_client._log_all_response_urls = self._log_all_response_urls
+        fhir_client._create_operation_outcome_for_error = self._create_operation_outcome_for_error
         return fhir_client
 
     def set_log_all_response_urls(self, value: bool) -> FhirClient:
@@ -911,18 +927,30 @@ class FhirClient(
 
     def set_storage_mode(self, value: CompressedDictStorageMode) -> FhirClient:
         """
-        Sets the storage mode
+        Sets the in-memory storage mode for FHIR resources.
+
+        This controls how FHIR resources are stored in memory after being received.
+        The default is "raw" (no compression - resources stored as plain Python dicts).
+
+        Available storage types:
+        - "raw": No compression, standard Python dictionaries (default)
+        - "compressed": Zlib/gzip compression in memory
+        - "msgpack": MessagePack binary serialization
+        - "compressed_msgpack": MessagePack + compression
+
+        Note: This is separate from HTTP compression (controlled by .compress()).
+        With default settings, no in-memory compression is applied.
 
-        :param value: storage mode
+        :param value: storage mode (default: raw)
         """
         self._storage_mode = value
         return self
 
-    def set_create_operation_outcome_for_error(self, value: bool) -> FhirClient:
+    def set_create_operation_outcome_for_error(self, value: bool | None) -> FhirClient:
         """
         Sets the create_operation_outcome_for_error flag
 
-        :param value: whether to create operation outcome for error
+        :param value: whether to create an operation outcome for error (True, False, or None)
         """
         self._create_operation_outcome_for_error = value
         return self

helix_fhir_client_sdk/fhir_merge_resources_mixin.py

@@ -2,9 +2,7 @@ import json
 import time
 from collections import deque
 from collections.abc import AsyncGenerator
-from typing import (
-    cast,
-)
+from typing import Any, cast
 from urllib import parse
 
 import requests
@@ -45,6 +43,198 @@ from helix_fhir_client_sdk.validators.async_fhir_validator import AsyncFhirValid
 
 
 class FhirMergeResourcesMixin(FhirClientProtocol):
+    async def merge_bundle_uncompressed(
+        self,
+        id_: str | None,
+        bundle: FhirBundle,
+    ) -> FhirMergeResourceResponse:
+        """
+        Optimized variant of :meth:`merge_bundle_async` that bypasses storage-mode handling.
+        Use this method when you do not need storage-mode behavior, or features such as request/response compression.
+        :param id_: id of the resource to merge
+        :param bundle: FHIR Bundle to merge
+        :return: FhirMergeResourceResponse
+        """
+        # Initialize profiling dictionary
+        profiling: dict[str, float] = {
+            "total_time": 0.0,
+            "build_url": 0.0,
+            "get_access_token": 0.0,
+            "prepare_payload": 0.0,
+            "http_post": 0.0,
+            "parse_response": 0.0,
+            "create_response_objects": 0.0,
+        }
+
+        merge_start_time = time.time()
+
+        request_id: str | None = None
+        response_status: int = 500
+
+        # Build URL
+        build_url_start = time.time()
+        full_uri: furl = furl(self._url)
+        full_uri /= self._resource
+
+        # Prepare headers
+        headers = {"Content-Type": "application/fhir+json"}
+        headers.update(self._additional_request_headers)
+        profiling["build_url"] = time.time() - build_url_start
+
+        # Get access token
+        get_token_start = time.time()
+        access_token_result: GetAccessTokenResult = await self.get_access_token_async()
+        access_token: str | None = access_token_result.access_token
+        if access_token:
+            headers["Authorization"] = f"Bearer {access_token}"
+        profiling["get_access_token"] = time.time() - get_token_start
+
+        # Prepare JSON payload
+        prepare_payload_start = time.time()
+        first_resource: FhirResource | None = bundle.entry[0].resource
+        assert first_resource is not None
+        json_payload: str = first_resource.json() if len(bundle.entry) == 1 else bundle.json()
+
+        # Build merge URL
+        obj_id: str = id_ or "1"
+        resource_uri: furl = full_uri / parse.quote(str(obj_id), safe="") / "$merge"
+        profiling["prepare_payload"] = time.time() - prepare_payload_start
+
+        response_text: str | None = None
+        responses: list[dict[str, Any]] = []
+        errors: list[dict[str, Any]] = []
+
+        try:
+            async with RetryableAioHttpClient(
+                fn_get_session=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,
+                persistent_session=self._persistent_session,
+                use_persistent_session=self._use_persistent_session,
+                close_session_on_exit=self._close_session,
+            ) as client:
+                http_post_start = time.time()
+                response: RetryableAioHttpResponse = await client.post(
+                    url=resource_uri.url,
+                    data=json_payload,
+                    headers=headers,
+                )
+                profiling["http_post"] = time.time() - http_post_start
+
+                response_status = response.status
+                request_id = response.response_headers.get("X-Request-ID", None)
+
+                parse_response_start = time.time()
+                if response.status == 200:
+                    response_text = await response.get_text_async()
+                    if response_text:
+                        try:
+                            # Parse response as plain dicts for speed
+                            parsed_response = json.loads(response_text)
+                            if isinstance(parsed_response, list):
+                                responses = parsed_response
+                            else:
+                                responses = [parsed_response]
+                        except (ValueError, json.JSONDecodeError) as e:
+                            errors.append(
+                                {
+                                    "issue": [
+                                        {
+                                            "severity": "error",
+                                            "code": "exception",
+                                            "diagnostics": f"Failed to parse response: {str(e)}",
+                                        }
+                                    ]
+                                }
+                            )
+                else:
+                    # HTTP error
+                    response_text = await response.get_text_async()
+                    errors.append(
+                        {
+                            "issue": [
+                                {
+                                    "severity": "error",
+                                    "code": "exception",
+                                    "diagnostics": response_text or f"HTTP {response.status}",
+                                }
+                            ]
+                        }
+                    )
+                profiling["parse_response"] = time.time() - parse_response_start
+
+        except requests.exceptions.HTTPError as e:
+            raise FhirSenderException(
+                request_id=request_id,
+                url=resource_uri.url,
+                headers=headers,
+                json_data=json_payload,
+                response_text=response_text,
+                response_status_code=response_status,
+                exception=e,
+                variables=FhirClientLogger.get_variables_to_log(vars(self)),
+                message=f"HttpError: {e}",
+                elapsed_time=time.time() - merge_start_time,
+            ) from e
+        except Exception as e:
+            raise FhirSenderException(
+                request_id=request_id,
+                url=resource_uri.url,
+                headers=headers,
+                json_data=json_payload,
+                response_text=response_text,
+                response_status_code=response_status,
+                exception=e,
+                variables=FhirClientLogger.get_variables_to_log(vars(self)),
+                message=f"Unknown Error: {e}",
+                elapsed_time=time.time() - merge_start_time,
+            ) from e
+
+        # Convert dict responses to proper objects using fast method
+        create_objects_start = time.time()
+        response_entries: deque[BaseFhirMergeResourceResponseEntry] = deque()
+
+        for resp_dict in responses:
+            response_entries.append(FhirMergeResourceResponseEntry.from_dict_uncompressed(resp_dict))
+
+        for error_dict in errors:
+            response_entries.append(FhirMergeResponseEntryError.from_dict(error_dict, storage_mode=self._storage_mode))
+        profiling["create_response_objects"] = time.time() - create_objects_start
+
+        profiling["total_time"] = time.time() - merge_start_time
+
+        # Log profiling information if logger is available
+        if self._logger:
+            self._logger.debug(
+                f"merge_bundle_without_storage profiling: "
+                f"total={profiling['total_time']:.3f}s, "
+                f"build_url={profiling['build_url']:.3f}s, "
+                f"get_token={profiling['get_access_token']:.3f}s, "
+                f"prepare_payload={profiling['prepare_payload']:.3f}s, "
+                f"http_post={profiling['http_post']:.3f}s, "
+                f"parse_response={profiling['parse_response']:.3f}s, "
+                f"create_objects={profiling['create_response_objects']:.3f}s"
+            )
+
+        return FhirMergeResourceResponse(
+            request_id=request_id,
+            url=resource_uri.url,
+            responses=response_entries,
+            error=None if response_status == 200 else (response_text or f"HTTP {response_status}"),
+            access_token=self._access_token,
+            status=response_status,
+            response_text=response_text,
+        )
+
     async def merge_bundle_async(
         self,
         id_: str | None,

helix_fhir_client_sdk/responses/merge/fhir_merge_resource_response_entry.py

@@ -75,6 +75,36 @@ class FhirMergeResourceResponseEntry(BaseFhirMergeResourceResponseEntry):
             status=data.get("status"),
         )
 
+    @classmethod
+    def from_dict_uncompressed(cls, data: dict[str, Any]) -> "FhirMergeResourceResponseEntry":
+        """
+        Creates a FhirMergeResourceResponseEntry from a dictionary without storage_mode overhead.
+        Uses FhirResource.construct for faster object creation.
+
+        :param data: Dictionary containing the response entry data
+        :return: FhirMergeResourceResponseEntry instance
+        """
+        resource_payload = data.get("resource")
+        resource_obj: FhirResource | None = (
+            FhirResource.construct(**resource_payload) if isinstance(resource_payload, dict) else None
+        )
+        return FhirMergeResourceResponseEntry(
+            created=data.get("created"),
+            updated=data.get("updated"),
+            deleted=data.get("deleted"),
+            id_=data.get("id"),
+            uuid=data.get("uuid"),
+            resource_type=data.get("resourceType"),
+            source_assigning_authority=data.get("source_assigning_authority"),
+            resource_version=data.get("resource_version"),
+            message=data.get("message"),
+            issue=data.get("issue"),
+            error=data.get("error"),
+            token=data.get("token"),
+            resource=resource_obj,
+            status=data.get("status"),
+        )
+
     @classmethod
     @override
     def from_json(

helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py

@@ -8,7 +8,7 @@ import async_timeout
 from aiohttp import ClientError, ClientResponse, ClientResponseError, ClientSession
 from multidict import MultiMapping
 from opentelemetry import trace
-import logging
+
 from helix_fhir_client_sdk.function_types import (
     RefreshTokenFunction,
     RefreshTokenResult,
@@ -130,7 +130,6 @@ class RetryableAioHttpClient:
                     if self.compress:
                         kwargs["compress"] = self.compress
                 assert self.session is not None
-                logging.info(f"Using Session ID: {id(self.session)} for URL: {url}")
                 with TRACER.start_as_current_span(FhirClientSdkOpenTelemetrySpanNames.HTTP_GET) as span:
                     span.set_attribute(
                         FhirClientSdkOpenTelemetryAttributeNames.URL,

{helix_fhir_client_sdk-4.2.8.dist-info → helix_fhir_client_sdk-4.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.8
+Version: 4.2.9
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi
@@ -115,4 +115,49 @@ For FHIR servers that support data streaming (e.g., b.well FHIR server), you can
 The data will be streamed in AsyncGenerators as described above.
 
 # Storage Compression
-The FHIR client SDK natively stores the FHIR resources compressed in memory.  This allows use in environments where you are processing large number of FHIR resources.
+The FHIR client SDK supports two types of compression:
+
+1. **HTTP Compression** (`compress`): Compresses HTTP request body when sending data to the server. Default: **enabled**
+2. **In-Memory Storage** (`storage_mode`): Controls how FHIR resources are stored in memory. Default: **raw (no compression)**
+
+## Disabling HTTP Compression
+HTTP compression (gzip) is enabled by default for request bodies. To disable it:
+
+```python
+from helix_fhir_client_sdk.fhir_client import FhirClient
+
+# Disable HTTP compression for requests
+fhir_client = FhirClient().url("https://fhir.example.com").compress(False)
+```
+
+## In-Memory Storage Modes
+The SDK supports different storage modes for FHIR resources through the `set_storage_mode()` method.
+By default, resources are stored as raw Python dictionaries (no compression).
+
+```python
+from helix_fhir_client_sdk.fhir_client import FhirClient
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import CompressedDictStorageMode
+
+# Use raw storage (default) - no compression, resources stored as plain Python dicts
+fhir_client = FhirClient().set_storage_mode(CompressedDictStorageMode(storage_type="raw"))
+
+# Use msgpack storage - stores resources in msgpack format
+fhir_client = FhirClient().set_storage_mode(CompressedDictStorageMode(storage_type="msgpack"))
+
+# Use compressed msgpack storage - stores resources in compressed msgpack format
+fhir_client = FhirClient().set_storage_mode(CompressedDictStorageMode(storage_type="compressed_msgpack"))
+```
+
+Available storage types:
+- `raw`: Default. Resources are stored as standard Python dictionaries (no compression)
+- `msgpack`: Resources are serialized using MessagePack for efficient storage
+- `compressed_msgpack`: Resources are serialized using MessagePack and then compressed
+
+## Getting Raw Python Dictionaries
+To completely bypass the `compressedfhir` library and get plain Python dictionaries:
+
+```python
+# Returns plain Python dicts, not FhirResource objects
+result = await fhir_client.get_raw_resources_async()
+resources = result["_resources"]  # list[dict[str, Any]]
+```

{helix_fhir_client_sdk-4.2.8.dist-info → helix_fhir_client_sdk-4.2.9.dist-info}/RECORD

@@ -3,10 +3,10 @@ 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=p2QIYrCv7ZktutY7SzYizmHADahxBddRTSCqX1EKyHc,14465
 helix_fhir_client_sdk/fhir_bundle_appender.py,sha256=t1hs7p_vXKC9MUFyUnN9dTuDhRF-kw-kkgVFtGHv9QQ,11749
-helix_fhir_client_sdk/fhir_client.py,sha256=-vaKQWKSJf4LiGP-Px-w6BlPa7N4yh_DOazM9WAvtRA,33120
+helix_fhir_client_sdk/fhir_client.py,sha256=vSkgWVgNlRkdu7RFPkD1-4BF9N88PnRXhCTSqUJqHlI,34930
 helix_fhir_client_sdk/fhir_delete_mixin.py,sha256=1YiKddTJTUzzrRvG7WgSisXY8rfJAHPAEXTsOevrom8,6521
 helix_fhir_client_sdk/fhir_merge_mixin.py,sha256=YTUODvc2rqXhk5_kwNMFPykm1I9_omww2WUcDExMESg,15264
-helix_fhir_client_sdk/fhir_merge_resources_mixin.py,sha256=EOxsxOwvJ_wCbPrk7y4G55EkaDJrfUbRPZVgnt2_B7c,27671
+helix_fhir_client_sdk/fhir_merge_resources_mixin.py,sha256=GsVeqcYpDvV5oeNbwyHS5YQozAyayICNcIRTQTRcrY0,36130
 helix_fhir_client_sdk/fhir_patch_mixin.py,sha256=YGcCPStoqVxWCYOaNI8vCKSFkAyRzP0YM_UWp4UKYro,5858
 helix_fhir_client_sdk/fhir_update_mixin.py,sha256=7psQTBsGPY1izuwn3yD4MGLjLVWQjqA_15_IeaUspew,6230
 helix_fhir_client_sdk/function_types.py,sha256=x95j6ix3Xa9b276Q741xX1jguqBuFT6EBLDw35_EoVM,3916
@@ -70,7 +70,7 @@ helix_fhir_client_sdk/responses/get/test/test_get_single_response.py,sha256=cDK6
 helix_fhir_client_sdk/responses/merge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 helix_fhir_client_sdk/responses/merge/base_fhir_merge_resource_response_entry.py,sha256=0PKxQc6sfO2RJka6AS4cX3U_yFnHRR0nsfgva91WrYk,3734
 helix_fhir_client_sdk/responses/merge/fhir_merge_resource_response.py,sha256=jLHzg-mHYKYBMrAnsx_vnTaP0OCuHJoPEHODCHFxaXA,3226
-helix_fhir_client_sdk/responses/merge/fhir_merge_resource_response_entry.py,sha256=J_r92iqS8YEnfOngblAVDAys-0hRSWmj_EnIMSqm0gk,3332
+helix_fhir_client_sdk/responses/merge/fhir_merge_resource_response_entry.py,sha256=DyTCoix8MqD9_860I0-Ikl6wCiACzQFMOaEossxyTWc,4626
 helix_fhir_client_sdk/responses/merge/fhir_merge_response_entry_issue.py,sha256=e7yKvYqdcb45YWblQafyoK1scf62j8Ux80AOdrkQbF4,2048
 helix_fhir_client_sdk/responses/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 helix_fhir_client_sdk/responses/test/test_bundle_expander.py,sha256=-IMu42ZcRSif8pwDWI0SsBXDI-8gRmOAsshtNhmoROM,877
@@ -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=OGWRb0ip5hHPAUHoQ9RHWdJnMERQVZvAAWPSPA4pAJ0,20997
+helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py,sha256=pxB4N0nkNBo2LT59tr1WnLBqiyr0J6l2OfXVMad1WJU,20898
 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,9 +130,10 @@ 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.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+helix_fhir_client_sdk-4.2.9.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=ZjC0ctog5r8Ba0ZD94ggwbnbQMeQdxk5pTt3zTpE8rQ,2832
 tests/test_get_nested_property.py,sha256=dA7eNmPJuwzQTViORRmJkcn9RAZzxeajSxUghobHpAo,2381
 tests/async/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/async/test_async_fhir_client_fetch_response_in_chunks.py,sha256=Ql95DuOqaidFL6u553f-Bkp4Rsd662C__NA-5sw0KL0,3993
@@ -150,6 +151,7 @@ tests/async/test_async_fhir_client_patient_merge_with_validate.py,sha256=CRTfV0v
 tests/async/test_async_fhir_client_patient_update.py,sha256=Q-hNO9D4FZ_r7oa62pyBG9keN-ZtkKvlsMK0hoE-5RA,1685
 tests/async/test_async_real_fhir_server_get_patients.py,sha256=0oMnUJg1KEspJ5_4eBen8z12Ion5HXv-gKAzFAkyII0,3837
 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/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
@@ -209,7 +211,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.8.dist-info/METADATA,sha256=oR35BPFtyfxWva020v58txCvPufKY3bXlhL0RU7IYkc,3914
-helix_fhir_client_sdk-4.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-helix_fhir_client_sdk-4.2.8.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
-helix_fhir_client_sdk-4.2.8.dist-info/RECORD,,
+helix_fhir_client_sdk-4.2.9.dist-info/METADATA,sha256=e-ajvH1vdbrt84TIgYqnldqWv9RzfHeuyzgSURayZyk,5841
+helix_fhir_client_sdk-4.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+helix_fhir_client_sdk-4.2.9.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
+helix_fhir_client_sdk-4.2.9.dist-info/RECORD,,

tests/async/test_benchmark_compress.py

@@ -0,0 +1,448 @@
+"""
+Benchmark tests for comparing compressed vs uncompressed FHIR client operations.
+
+These tests measure the performance of:
+- get_async() with compress=True vs compress=False
+- get_raw_resources_async() with compress=True vs compress=False
+
+=============================================================================
+HOW TO RUN THESE TESTS
+=============================================================================
+
+1. Start services using docker-compose:
+   docker-compose up -d mock-server
+
+2. First time only - rebuild dev container to include pytest-benchmark:
+   docker-compose build dev
+
+   OR install pytest-benchmark in the running container:
+   docker-compose run --rm dev pip install pytest-benchmark
+
+3. Run benchmark tests inside docker container:
+   docker-compose run --rm dev pytest tests/async/test_benchmark_compress.py -v --benchmark-only
+
+4. Or run all benchmark variations:
+   docker-compose run --rm dev pytest tests/async/test_benchmark_compress.py -v --benchmark-only --benchmark-group-by=func
+
+5. Save benchmark results for comparison:
+   docker-compose run --rm dev pytest tests/async/test_benchmark_compress.py -v --benchmark-autosave
+
+6. Compare with previous runs:
+   docker-compose run --rm dev pytest tests/async/test_benchmark_compress.py -v --benchmark-compare
+
+7. Run with more iterations for accuracy:
+   docker-compose run --rm dev pytest tests/async/test_benchmark_compress.py -v --benchmark-min-rounds=10
+
+8. To stop mock-server:
+   docker-compose down mock-server
+
+=============================================================================
+"""
+
+import asyncio
+import json
+import socket
+from typing import Any
+
+import pytest
+from mockserver_client.mockserver_client import (
+    MockServerFriendlyClient,
+    mock_request,
+    mock_response,
+    times,
+)
+
+from helix_fhir_client_sdk.fhir_client import FhirClient
+from helix_fhir_client_sdk.responses.fhir_get_response import FhirGetResponse
+
+
+def is_mock_server_running(host: str = "mock-server", port: int = 1080) -> bool:
+    """Check if mock-server is reachable."""
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(2)
+        result = sock.connect_ex((host, port))
+        sock.close()
+        return result == 0
+    except OSError:
+        return False
+
+
+# Skip all tests if mock-server is not running
+pytestmark = pytest.mark.skipif(
+    not is_mock_server_running(), reason="Mock server not running. Start with: docker-compose up -d mock-server"
+)
+
+
+def generate_patient_resource(index: int) -> dict[str, Any]:
+    """Generate a realistic FHIR Patient resource."""
+    return {
+        "resourceType": "Patient",
+        "id": f"patient-{index}",
+        "meta": {
+            "versionId": "1",
+            "lastUpdated": "2025-01-15T10:30:00.000Z",
+            "source": "http://example.org/fhir",
+            "profile": ["http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient"],
+        },
+        "identifier": [
+            {
+                "use": "official",
+                "type": {
+                    "coding": [
+                        {
+                            "system": "http://terminology.hl7.org/CodeSystem/v2-0203",
+                            "code": "MR",
+                            "display": "Medical Record Number",
+                        }
+                    ]
+                },
+                "system": "http://hospital.example.org/mrn",
+                "value": f"MRN-{index:08d}",
+            },
+            {
+                "use": "official",
+                "type": {
+                    "coding": [
+                        {
+                            "system": "http://terminology.hl7.org/CodeSystem/v2-0203",
+                            "code": "SS",
+                            "display": "Social Security Number",
+                        }
+                    ]
+                },
+                "system": "http://hl7.org/fhir/sid/us-ssn",
+                "value": f"{100 + index:03d}-{50 + index:02d}-{1000 + index:04d}",
+            },
+        ],
+        "active": True,
+        "name": [
+            {
+                "use": "official",
+                "family": f"TestFamily{index}",
+                "given": [f"TestGiven{index}", f"MiddleName{index}"],
+                "prefix": ["Mr."],
+                "suffix": ["Jr."],
+            },
+            {
+                "use": "nickname",
+                "given": [f"Nick{index}"],
+            },
+        ],
+        "telecom": [
+            {"system": "phone", "value": f"555-{100 + index:03d}-{1000 + index:04d}", "use": "home"},
+            {"system": "phone", "value": f"555-{200 + index:03d}-{2000 + index:04d}", "use": "mobile"},
+            {"system": "email", "value": f"patient{index}@example.com", "use": "home"},
+        ],
+        "gender": "male" if index % 2 == 0 else "female",
+        "birthDate": f"{1950 + (index % 50)}-{(index % 12) + 1:02d}-{(index % 28) + 1:02d}",
+        "deceasedBoolean": False,
+        "address": [
+            {
+                "use": "home",
+                "type": "physical",
+                "line": [f"{100 + index} Main Street", f"Apt {index}"],
+                "city": "Boston",
+                "state": "MA",
+                "postalCode": f"02{100 + (index % 900):03d}",
+                "country": "USA",
+            },
+            {
+                "use": "work",
+                "type": "postal",
+                "line": [f"{200 + index} Business Ave"],
+                "city": "Cambridge",
+                "state": "MA",
+                "postalCode": f"02{200 + (index % 800):03d}",
+                "country": "USA",
+            },
+        ],
+        "maritalStatus": {
+            "coding": [
+                {
+                    "system": "http://terminology.hl7.org/CodeSystem/v3-MaritalStatus",
+                    "code": "M" if index % 2 == 0 else "S",
+                    "display": "Married" if index % 2 == 0 else "Never Married",
+                }
+            ]
+        },
+        "communication": [
+            {
+                "language": {
+                    "coding": [
+                        {
+                            "system": "urn:ietf:bcp:47",
+                            "code": "en-US",
+                            "display": "English (United States)",
+                        }
+                    ]
+                },
+                "preferred": True,
+            }
+        ],
+        "generalPractitioner": [{"reference": f"Practitioner/practitioner-{index % 10}"}],
+        "managingOrganization": {"reference": "Organization/org-1"},
+    }
+
+
+def generate_patient_bundle(count: int) -> dict[str, Any]:
+    """Generate a FHIR Bundle with multiple Patient resources."""
+    entries = []
+    for i in range(count):
+        entries.append(
+            {
+                "fullUrl": f"http://example.org/fhir/Patient/patient-{i}",
+                "resource": generate_patient_resource(i),
+                "search": {"mode": "match"},
+            }
+        )
+    return {
+        "resourceType": "Bundle",
+        "id": "bundle-search-result",
+        "type": "searchset",
+        "total": count,
+        "link": [
+            {"relation": "self", "url": f"http://example.org/fhir/Patient?_count={count}"},
+        ],
+        "entry": entries,
+    }
+
+
+@pytest.fixture(scope="module")
+def mock_server_url() -> str:
+    return "http://mock-server:1080"
+
+
+@pytest.fixture(scope="module")
+def mock_client(mock_server_url: str) -> MockServerFriendlyClient:
+    return MockServerFriendlyClient(base_url=mock_server_url)
+
+
+@pytest.fixture(scope="module")
+def setup_mock_endpoints(mock_client: MockServerFriendlyClient, mock_server_url: str) -> str:
+    """Set up mock endpoints for different payload sizes."""
+    test_name = "benchmark_compress"
+
+    mock_client.clear(f"/{test_name}/*.*")
+    mock_client.reset()
+
+    # Create payloads of different sizes for benchmarking
+    payloads = {
+        "small": generate_patient_bundle(10),  # ~10KB
+        "medium": generate_patient_bundle(100),  # ~100KB
+        "large": generate_patient_bundle(500),  # ~500KB
+    }
+
+    # Setup mock endpoints for each payload size
+    for size, bundle in payloads.items():
+        response_body = json.dumps(bundle)
+        # Endpoint for GET /Patient (returns bundle)
+        mock_client.expect(
+            request=mock_request(path=f"/{test_name}/{size}/Patient", method="GET"),
+            response=mock_response(body=response_body),
+            timing=times(10000),  # Allow many requests for benchmarking
+        )
+        # Endpoint for GET /Patient/{id} (returns single resource)
+        mock_client.expect(
+            request=mock_request(path=f"/{test_name}/{size}/Patient/{size}", method="GET"),
+            response=mock_response(body=response_body),
+            timing=times(10000),
+        )
+
+    return f"{mock_server_url}/{test_name}"
+
+
+# ============================================================================
+# Benchmark Tests for get_async()
+# ============================================================================
+
+
+def test_benchmark_get_async_compress_false_small(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_async with compress=False and a small payload (10 patients)."""
+    base_url = f"{setup_mock_endpoints}/small"
+
+    async def run_get_async() -> FhirGetResponse:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(False).get_async()
+
+    def run_sync() -> FhirGetResponse:
+        return asyncio.run(run_get_async())
+
+    result = benchmark(run_sync)
+    assert result is not None
+    assert result.get_response_text() is not None
+
+
+def test_benchmark_get_async_compress_true_small(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_async with compress=True and a small payload (10 patients)."""
+    base_url = f"{setup_mock_endpoints}/small"
+
+    async def run_get_async() -> FhirGetResponse:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(True).get_async()
+
+    def run_sync() -> FhirGetResponse:
+        return asyncio.run(run_get_async())
+
+    result = benchmark(run_sync)
+    assert result is not None
+    assert result.get_response_text() is not None
+
+
+def test_benchmark_get_async_compress_false_medium(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_async with compress=False and medium payload (100 patients)."""
+    base_url = f"{setup_mock_endpoints}/medium"
+
+    async def run_get_async() -> FhirGetResponse:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(False).get_async()
+
+    def run_sync() -> FhirGetResponse:
+        return asyncio.run(run_get_async())
+
+    result = benchmark(run_sync)
+    assert result is not None
+    assert result.get_response_text() is not None
+
+
+def test_benchmark_get_async_compress_true_medium(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_async with compress=True and medium payload (100 patients)."""
+    base_url = f"{setup_mock_endpoints}/medium"
+
+    async def run_get_async() -> FhirGetResponse:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(True).get_async()
+
+    def run_sync() -> FhirGetResponse:
+        return asyncio.run(run_get_async())
+
+    result = benchmark(run_sync)
+    assert result is not None
+    assert result.get_response_text() is not None
+
+
+def test_benchmark_get_async_compress_false_large(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_async with compress=False and a large payload (500 patients)."""
+    base_url = f"{setup_mock_endpoints}/large"
+
+    async def run_get_async() -> FhirGetResponse:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(False).get_async()
+
+    def run_sync() -> FhirGetResponse:
+        return asyncio.run(run_get_async())
+
+    result = benchmark(run_sync)
+    assert result is not None
+    assert result.get_response_text() is not None
+
+
+def test_benchmark_get_async_compress_true_large(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_async with compress=True and a large payload (500 patients)."""
+    base_url = f"{setup_mock_endpoints}/large"
+
+    async def run_get_async() -> FhirGetResponse:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(True).get_async()
+
+    def run_sync() -> FhirGetResponse:
+        return asyncio.run(run_get_async())
+
+    result = benchmark(run_sync)
+    assert result is not None
+    assert result.get_response_text() is not None
+
+
+# ============================================================================
+# Benchmark Tests for get_raw_resources_async()
+# ============================================================================
+
+
+def test_benchmark_get_raw_resources_async_compress_false_small(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_raw_resources_async with compress=False and small payload."""
+    base_url = f"{setup_mock_endpoints}/small"
+
+    async def run_get_raw() -> dict[str, Any]:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(False).get_raw_resources_async()
+
+    def run_sync() -> dict[str, Any]:
+        return asyncio.run(run_get_raw())
+
+    result = benchmark(run_sync)
+    assert result is not None
+
+
+def test_benchmark_get_raw_resources_async_compress_true_small(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_raw_resources_async with compress=True and a small payload."""
+    base_url = f"{setup_mock_endpoints}/small"
+
+    async def run_get_raw() -> dict[str, Any]:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(True).get_raw_resources_async()
+
+    def run_sync() -> dict[str, Any]:
+        return asyncio.run(run_get_raw())
+
+    result = benchmark(run_sync)
+    assert result is not None
+
+
+def test_benchmark_get_raw_resources_async_compress_false_medium(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_raw_resources_async with compress=False and medium payload."""
+    base_url = f"{setup_mock_endpoints}/medium"
+
+    async def run_get_raw() -> dict[str, Any]:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(False).get_raw_resources_async()
+
+    def run_sync() -> dict[str, Any]:
+        return asyncio.run(run_get_raw())
+
+    result = benchmark(run_sync)
+    assert result is not None
+
+
+def test_benchmark_get_raw_resources_async_compress_true_medium(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_raw_resources_async with compress=True and medium payload."""
+    base_url = f"{setup_mock_endpoints}/medium"
+
+    async def run_get_raw() -> dict[str, Any]:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(True).get_raw_resources_async()
+
+    def run_sync() -> dict[str, Any]:
+        return asyncio.run(run_get_raw())
+
+    result = benchmark(run_sync)
+    assert result is not None
+
+
+def test_benchmark_get_raw_resources_async_compress_false_large(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_raw_resources_async with compress=False and a large payload."""
+    base_url = f"{setup_mock_endpoints}/large"
+
+    async def run_get_raw() -> dict[str, Any]:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(False).get_raw_resources_async()
+
+    def run_sync() -> dict[str, Any]:
+        return asyncio.run(run_get_raw())
+
+    result = benchmark(run_sync)
+    assert result is not None
+
+
+def test_benchmark_get_raw_resources_async_compress_true_large(benchmark: Any, setup_mock_endpoints: str) -> None:
+    """Benchmark get_raw_resources_async with compress=True and a large payload."""
+    base_url = f"{setup_mock_endpoints}/large"
+
+    async def run_get_raw() -> dict[str, Any]:
+        fhir_client = FhirClient().url(base_url).resource("Patient")
+        return await fhir_client.compress(True).get_raw_resources_async()
+
+    def run_sync() -> dict[str, Any]:
+        return asyncio.run(run_get_raw())
+
+    result = benchmark(run_sync)
+    assert result is not None

tests/test_fhir_client_clone.py

@@ -0,0 +1,78 @@
+"""
+Tests for FhirClient.clone() method to ensure all properties are properly copied.
+"""
+
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+
+from helix_fhir_client_sdk.fhir_client import FhirClient
+
+
+def test_clone_preserves_compress_setting() -> None:
+    """Test that clone() preserves the _compress setting"""
+    # Create a client with compression disabled
+    fhir_client = FhirClient().url("http://example.com").compress(False)
+    assert fhir_client._compress is False
+
+    # Clone and verify compression is still disabled
+    cloned_client = fhir_client.clone()
+    assert cloned_client._compress is False
+
+    # Test with compression enabled
+    fhir_client2 = FhirClient().url("http://example.com").compress(True)
+    assert fhir_client2._compress is True
+
+    cloned_client2 = fhir_client2.clone()
+    assert cloned_client2._compress is True
+
+
+def test_clone_preserves_storage_mode() -> None:
+    """Test that clone() preserves the _storage_mode setting"""
+    # Create a client with msgpack storage mode
+    storage_mode = CompressedDictStorageMode(storage_type="msgpack")
+    fhir_client = FhirClient().url("http://example.com").set_storage_mode(storage_mode)
+    assert fhir_client._storage_mode.storage_type == "msgpack"
+
+    # Clone and verify storage mode is preserved
+    cloned_client = fhir_client.clone()
+    assert cloned_client._storage_mode.storage_type == "msgpack"
+
+
+def test_clone_preserves_additional_settings() -> None:
+    """Test that clone() preserves other compression-related settings"""
+    fhir_client = (
+        FhirClient()
+        .url("http://example.com")
+        .compress(False)
+        .send_data_as_chunked(True)
+        .use_post_for_search(True)
+        .maximum_time_to_retry_on_429(120)
+        .retry_count(5)
+        .throw_exception_on_error(False)
+        .set_log_all_response_urls(True)
+        .set_create_operation_outcome_for_error(True)
+    )
+
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._compress is False
+    assert cloned_client._send_data_as_chunked is True
+    assert cloned_client._use_post_for_search is True
+    assert cloned_client._maximum_time_to_retry_on_429 == 120
+    assert cloned_client._retry_count == 5
+    assert cloned_client._throw_exception_on_error is False
+    assert cloned_client._log_all_response_urls is True
+    assert cloned_client._create_operation_outcome_for_error is True
+
+
+def test_default_compression_is_enabled() -> None:
+    """Test that compression is enabled by default"""
+    fhir_client = FhirClient()
+    assert fhir_client._compress is True
+
+
+def test_default_storage_mode_is_raw() -> None:
+    """Test that the default storage mode is 'raw'"""
+    fhir_client = FhirClient()
+    assert fhir_client._storage_mode.storage_type == "raw"