helix.fhir.client.sdk 4.2.22__tar.gz → 4.2.23__tar.gz

{helix_fhir_client_sdk-4.2.22/helix.fhir.client.sdk.egg-info → helix_fhir_client_sdk-4.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.22
+Version: 4.2.23
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi

helix_fhir_client_sdk-4.2.23/VERSION

@@ -0,0 +1 @@
+4.2.23

{helix_fhir_client_sdk-4.2.22 → helix_fhir_client_sdk-4.2.23/helix.fhir.client.sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.22
+Version: 4.2.23
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi

{helix_fhir_client_sdk-4.2.22 → helix_fhir_client_sdk-4.2.23}/helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py

@@ -1,4 +1,5 @@
 import json
+import time
 from abc import ABC
 from collections.abc import AsyncGenerator
 from datetime import UTC, datetime
@@ -188,7 +189,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
 
             # Prepare parent bundle entries for further processing
             parent_bundle_entries: FhirBundleEntryList = parent_response.get_bundle_entries()
-
             if logger:
                 logger.info(
                     f"FhirClient.simulate_graph_async() got parent resources: {parent_response_resource_count} "
@@ -235,8 +235,11 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 # Update parent link map for next iteration
                 parent_link_map = new_parent_link_map
 
+            start_time = time.time()
             # Combine and process responses
             parent_response = cast(FhirGetBundleResponse, parent_response.extend(child_responses))
+            if logger:
+                logger.info(f"Parent_response.extend time: {time.time() - start_time}")
 
             # Optional resource sorting
             if sort_resources:
@@ -844,6 +847,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
     ) -> FhirGetResponse | None:
         result: FhirGetResponse | None = None
         non_cached_id_list: list[str] = []
+
         # first check to see if we can find these in the cache
         if ids:
             for resource_id in ids:
@@ -905,7 +909,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     )
                     if cache_updated and logger:
                         logger.info(f"Inserted {result2.status} for {resource_type}/{single_id} into cache (1by1)")
-
         return result
 
     async def _get_resources_by_parameters_async(
@@ -970,7 +973,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     if logger:
                         logger.info(f"Cache entry not found for {resource_type}/{resource_id} (ByParam)")
                     non_cached_id_list.append(resource_id)
-
         all_result: FhirGetResponse | None = None
         # either we have non-cached ids or this is a query without id but has other parameters
         if (

{helix_fhir_client_sdk-4.2.22 → helix_fhir_client_sdk-4.2.23}/helix_fhir_client_sdk/responses/fhir_get_response.py

@@ -170,9 +170,8 @@ class FhirGetResponse:
         """
         result: FhirGetResponse = self._extend(others=others)
 
-        latest_chunk_number: list[int] = sorted([o.chunk_number for o in others if o.chunk_number], reverse=True)
-        if len(latest_chunk_number) > 0:
-            result.chunk_number = latest_chunk_number[0]
+        if others and others[-1].chunk_number:
+            result.chunk_number = others[-1].chunk_number
         return result
 
     @abstractmethod

{helix_fhir_client_sdk-4.2.22 → helix_fhir_client_sdk-4.2.23}/helix_fhir_client_sdk/responses/get/fhir_get_bundle_response.py

@@ -115,12 +115,13 @@ class FhirGetBundleResponse(FhirGetResponse):
         """
         other_response_entries: FhirBundleEntryList = other_response.get_bundle_entries()
 
-        if len(other_response_entries):
+        if len(other_response_entries) > 0:
             # only append if there are entries in the other response
             if self._bundle_entries is None:
-                self._bundle_entries = other_response_entries
-            else:
-                self._bundle_entries.extend(other_response_entries)
+                self._bundle_entries = FhirBundleEntryList()
+            from collections import deque
+
+            deque.extend(self._bundle_entries, other_response_entries)
 
         return self
 
@@ -134,7 +135,6 @@ class FhirGetBundleResponse(FhirGetResponse):
         """
         for other_response in others:
             self.append(other_response=other_response)
-
         return self
 
     @override
@@ -311,36 +311,51 @@ 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)
 
+        self._bundle_entries = FhirBundleEntryList(kept)
         return self
 
     @classmethod

{helix_fhir_client_sdk-4.2.22 → helix_fhir_client_sdk-4.2.23}/helix_fhir_client_sdk/responses/get/test/test_get_bundle_response.py

@@ -73,7 +73,7 @@ class TestFhirGetBundleResponse:
         assert response._bundle_metadata.id_ == "test-bundle-id"
         assert response._bundle_metadata.type_ == "searchset"
 
-    def test_append_unique(self, sample_bundle_response: dict[str, Any]) -> None:
+    def test_append(self, sample_bundle_response: dict[str, Any]) -> None:
         """Test appending another response."""
         results_by_url: list[RetryableAioHttpUrlResult] = []
 
@@ -113,7 +113,8 @@ class TestFhirGetBundleResponse:
 
         first_response.append(second_response)
 
-        assert len(first_response.get_bundle_entries()) == 2
+        # Updating it to 4 since we have integrated cache and do not do same lookups again so we do not need to remove duplicates here.
+        assert len(first_response.get_bundle_entries()) == 4
 
     def test_get_resources(self, sample_bundle_response: dict[str, Any]) -> None:
         """Test getting resources from the response."""

helix_fhir_client_sdk-4.2.22/VERSION

@@ -1 +0,0 @@
-4.2.22