helix.fhir.client.sdk 4.2.3__py3-none-any.whl → 4.2.19__py3-none-any.whl

helix_fhir_client_sdk/responses/fhir_response_processor.py

@@ -11,10 +11,13 @@ 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,
@@ -37,6 +40,8 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_response import (
     RetryableAioHttpResponse,
 )
 
+TRACER = trace.get_tracer(__name__)
+
 
 class FhirResponseProcessor:
     """
@@ -93,60 +98,74 @@ class FhirResponseProcessor:
 
         :return: An async generator of FhirGetResponse objects.
         """
-        # 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
+        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()
 
     @staticmethod
     async def _handle_response_unknown(

helix_fhir_client_sdk/responses/get/fhir_get_bundle_response.py

@@ -1,4 +1,5 @@
 import json
+import logging
 from collections.abc import AsyncGenerator, Generator
 from datetime import datetime
 from logging import Logger
@@ -59,7 +60,7 @@ class FhirGetBundleResponse(FhirGetResponse):
         chunk_number: int | None = None,
         cache_hits: int | None = None,
         results_by_url: list[RetryableAioHttpUrlResult],
-        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.raw(),
+        storage_mode: CompressedDictStorageMode,
     ) -> None:
         super().__init__(
             request_id=request_id,
@@ -311,36 +312,56 @@ class FhirGetBundleResponse(FhirGetResponse):
     ) -> "FhirGetBundleResponse":
         """
         Removes the entries in the cache from the bundle
-
-        :param request_cache: RequestCache object to remove the entries from
-        :param compare_hash: if True, compare the hash of the resource with the hash in the cache
-        :return: self
         """
-        # remove all entries in the cache from the bundle
+        # Build a lookup of cache entries by (resource_type, id)
+        cache_map: dict[tuple[str, str], str | None] = {}
         async for cached_entry in request_cache.get_entries_async():
-            if cached_entry.from_input_cache:
-                for entry in self._bundle_entries:
-                    if (
-                        entry.resource
-                        and entry.resource.id is not None  # only remove if resource has an id
-                        and entry.resource.id == cached_entry.id_
-                        and entry.resource.resource_type == cached_entry.resource_type
-                        and (
-                            not compare_hash
-                            or (
-                                ResourceHash().hash_value(json.dumps(json.loads(entry.resource.json()), sort_keys=True))
-                                == cached_entry.raw_hash
-                            )
-                        )
-                    ):
-                        if logger:
-                            logger.debug(
-                                f"Removing entry from bundle with id {entry.resource.id} and resource "
-                                f"type {entry.resource.resource_type}"
-                            )
-                        self._bundle_entries.remove(entry)
-                        break
+            if cached_entry.from_input_cache and cached_entry.resource_type and cached_entry.id_:
+                cache_map[(cached_entry.resource_type, cached_entry.id_)] = (
+                    cached_entry.raw_hash if compare_hash else None
+                )
+
+        if not cache_map:
+            return self
+
+        resource_hash = ResourceHash() if compare_hash else None
+        removed_entries: list[FhirBundleEntry] = []
+
+        def should_remove(entry: FhirBundleEntry) -> bool:
+            resource = entry.resource
+            if not resource or resource.id is None or resource.resource_type is None:
+                return False
+            key = (resource.resource_type, resource.id)
+            if key not in cache_map:
+                return False
+            if not compare_hash:
+                return True
+            # Compare normalized JSON hash
+            if resource_hash is None:
+                return False
+            try:
+                entry_hash = resource_hash.hash_value(json.dumps(json.loads(resource.json()), sort_keys=True))
+                return entry_hash == cache_map[key]
+            except Exception:
+                return False
+
+        # One pass filter; rebuild list to avoid many deque.remove calls
+        kept: list[FhirBundleEntry] = []
+        for entry in self._bundle_entries:
+            if should_remove(entry):
+                removed_entries.append(entry)
+            else:
+                kept.append(entry)
+
+        if logger and removed_entries and logger.isEnabledFor(logging.DEBUG):
+            for entry in removed_entries:
+                if entry.resource:
+                    logger.debug(
+                        f"Removing entry from bundle with id {entry.resource.id} and resource "
+                        f"type {entry.resource.resource_type}"
+                    )
 
+        self._bundle_entries = FhirBundleEntryList(kept)
         return self
 
     @classmethod

helix_fhir_client_sdk/responses/get/fhir_get_error_response.py

@@ -67,7 +67,6 @@ 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/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 = CompressedDictStorageMode.raw(),
+        storage_mode: CompressedDictStorageMode,
     ) -> None:
         super().__init__(
             request_id=request_id,

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 = CompressedDictStorageMode.raw(),
+        storage_mode: CompressedDictStorageMode,
     ) -> None:
         super().__init__(
             request_id=request_id,

helix_fhir_client_sdk/responses/get/fhir_get_response_factory.py

@@ -50,7 +50,6 @@ 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/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 = CompressedDictStorageMode.raw(),
+        storage_mode: CompressedDictStorageMode,
     ) -> None:
         super().__init__(
             request_id=request_id,

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/responses/resource_separator.py

@@ -1,5 +1,4 @@
 import dataclasses
-from copy import deepcopy
 from typing import Any, cast
 
 
@@ -27,46 +26,42 @@ class ResourceSeparator:
         extra_context_to_return: dict[str, Any] | None,
     ) -> ResourceSeparatorResult:
         """
-        Given a list of resources, return a list of resources with the contained resources separated out.
-
-        :param resources: The resources list.
-        :param access_token: The access token.
-        :param url: The URL.
-        :param extra_context_to_return: The extra context to return.
-
-        :return: None
+        Separate contained resources without copying or mutating input resources.
         """
         resources_dicts: list[dict[str, str | None | list[dict[str, Any]]]] = []
-        resource_count: int = 0
-        resource: dict[str, Any]
-        for resource in resources:
-            # make a copy so we are not changing the original resource
-            cloned_resource: dict[str, Any] = deepcopy(resource)
-            # This dict will hold the separated resources where the key is resourceType
-            # have to split these here otherwise when Spark loads them
-            # it can't handle that items in the entry array can have different schemas
-            resources_dict: dict[str, str | None | list[dict[str, Any]]] = {}
-            # add the parent resource to the resources_dict
-            resource_type = str(cloned_resource["resourceType"]).lower()
-            if resource_type not in resources_dict:
-                resources_dict[resource_type] = []
-            if isinstance(resources_dict[resource_type], list):
-                cast(list[dict[str, Any]], resources_dict[resource_type]).append(cloned_resource)
-                resource_count += 1
-            # now see if this resource has a contained array and if so, add those to the resources_dict
-            if "contained" in cloned_resource:
-                contained_resources = cloned_resource.pop("contained")
-                for contained_resource in contained_resources:
-                    resource_type = str(contained_resource["resourceType"]).lower()
-                    if resource_type not in resources_dict:
-                        resources_dict[resource_type] = []
-                    if isinstance(resources_dict[resource_type], list):
-                        cast(list[dict[str, Any]], resources_dict[resource_type]).append(contained_resource)
-                        resource_count += 1
-            resources_dict["token"] = access_token
-            resources_dict["url"] = url
+        total_resource_count: int = 0
+
+        for parent_resource in resources:
+            resource_type_value = parent_resource.get("resourceType")
+            if not resource_type_value:
+                continue
+
+            resource_type_key = str(resource_type_value).lower()
+            resource_map: dict[str, str | None | list[dict[str, Any]]] = {}
+
+            # Add parent resource
+            parent_list = cast(list[dict[str, Any]], resource_map.setdefault(resource_type_key, []))
+            parent_list.append(parent_resource)
+            total_resource_count += 1
+
+            # Add contained resources (if present) without mutating parent
+            contained_list = parent_resource.get("contained")
+            if isinstance(contained_list, list) and contained_list:
+                total_resource_count += len(contained_list)
+                for contained_resource in contained_list:
+                    contained_type_value = contained_resource.get("resourceType")
+                    if not contained_type_value:
+                        continue
+                    contained_type_key = str(contained_type_value).lower()
+                    contained_list_out = cast(list[dict[str, Any]], resource_map.setdefault(contained_type_key, []))
+                    contained_list_out.append(contained_resource)
+
+            # Context
+            resource_map["token"] = access_token
+            resource_map["url"] = url
             if extra_context_to_return:
-                resources_dict.update(extra_context_to_return)
-            resources_dicts.append(resources_dict)
+                resource_map.update(extra_context_to_return)
+
+            resources_dicts.append(resource_map)
 
-        return ResourceSeparatorResult(resources_dicts=resources_dicts, total_count=resource_count)
+        return ResourceSeparatorResult(resources_dicts=resources_dicts, total_count=total_resource_count)

helix_fhir_client_sdk/utilities/cache/request_cache.py

@@ -1,4 +1,3 @@
-import asyncio
 from collections.abc import AsyncGenerator
 from datetime import datetime
 from types import TracebackType
@@ -11,7 +10,7 @@ from helix_fhir_client_sdk.utilities.cache.request_cache_entry import RequestCac
 
 class RequestCache:
     """
-    This is a class that caches requests to the FHIR server using a weak value dictionary.
+    This is a class that caches requests to the FHIR server.
     It is used to avoid multiple requests to the FHIR server when doing a large number
     of requests for the same resource.
     """
@@ -20,7 +19,6 @@ class RequestCache:
         "cache_hits",
         "cache_misses",
         "_cache",
-        "_lock",
         "_clear_cache_at_the_end",
     ]
 
@@ -33,7 +31,6 @@ class RequestCache:
         self.cache_hits: int = 0
         self.cache_misses: int = 0
         self._cache: dict[str, RequestCacheEntry] = initial_dict or {}
-        self._lock: asyncio.Lock = asyncio.Lock()
         self._clear_cache_at_the_end: bool | None = clear_cache_at_the_end
 
     async def __aenter__(self) -> "RequestCache":
@@ -42,8 +39,7 @@ class RequestCache:
         It returns the RequestCache instance.
         """
         if self._clear_cache_at_the_end:
-            async with self._lock:
-                self._cache.clear()
+            self._cache.clear()
         return self
 
     async def __aexit__(
@@ -57,8 +53,7 @@ class RequestCache:
         It clears the cache.
         """
         if self._clear_cache_at_the_end:
-            async with self._lock:
-                self._cache.clear()
+            self._cache.clear()
 
         if exc_value is not None:
             raise exc_value.with_traceback(traceback)
@@ -75,15 +70,14 @@ class RequestCache:
         """
         key: str = f"{resource_type}/{resource_id}"
 
-        async with self._lock:
-            cached_entry = self._cache.get(key)
+        cached_entry = self._cache.get(key)
 
-            if cached_entry is not None:
-                self.cache_hits += 1
-                return cached_entry
+        if cached_entry is not None:
+            self.cache_hits += 1
+            return cached_entry
 
-            self.cache_misses += 1
-            return None
+        self.cache_misses += 1
+        return None
 
     async def add_async(
         self,
@@ -111,43 +105,40 @@ class RequestCache:
         """
         key: str = f"{resource_type}/{resource_id}"
 
-        async with self._lock:
-            # Create the cache entry
-            cache_entry = RequestCacheEntry(
-                id_=resource_id,
-                resource_type=resource_type,
-                status=status,
-                bundle_entry=bundle_entry,
-                last_modified=last_modified,
-                etag=etag,
-                from_input_cache=from_input_cache,
-                raw_hash=raw_hash,
-            )
-
-            # Add to the weak value dictionary
-            self._cache[key] = cache_entry
+        # Create the cache entry
+        cache_entry = RequestCacheEntry(
+            id_=resource_id,
+            resource_type=resource_type,
+            status=status,
+            bundle_entry=bundle_entry,
+            last_modified=last_modified,
+            etag=etag,
+            from_input_cache=from_input_cache,
+            raw_hash=raw_hash,
+        )
+
+        # Add to the dictionary
+        self._cache[key] = cache_entry
 
-            return True
+        return True
 
     async def remove_async(self, *, resource_key: str) -> bool:
         """
         This method remove the given data from the cache.
         :param resource_key: resource key contains both resourceType and resourceId. Eg: Patient/123
         """
-        async with self._lock:
-            if resource_key not in self._cache:
-                return False
+        if resource_key not in self._cache:
+            return False
 
-            del self._cache[resource_key]
+        del self._cache[resource_key]
 
-            return True
+        return True
 
     async def clear_async(self) -> None:
         """
         This method clears the cache.
         """
-        async with self._lock:
-            self._cache.clear()
+        self._cache.clear()
 
     async def get_entries_async(self) -> AsyncGenerator[RequestCacheEntry, None]:
         """
@@ -155,9 +146,8 @@ class RequestCache:
 
         :return: The keys in the cache.
         """
-        async with self._lock:
-            for entry in self._cache.values():
-                yield entry
+        for entry in self._cache.values():
+            yield entry
 
     async def get_keys_async(self) -> list[str]:
         """
@@ -165,8 +155,7 @@ class RequestCache:
 
         :return: The entries in the cache.
         """
-        async with self._lock:
-            return list(self._cache.keys())
+        return list(self._cache.keys())
 
     def __len__(self) -> int:
         """