helix.fhir.client.sdk 4.2.18__py3-none-any.whl → 4.2.20__py3-none-any.whl

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
@@ -123,6 +124,15 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         Yields:
             FhirGetResponse objects representing retrieved resources
         """
+
+        profiling: dict[str, Any] = {
+            "function": "process_simulate_graph_async",
+            "start_time": time.perf_counter(),
+            "steps": {},
+            "extend_calls": [],
+            "append_calls": [],
+        }
+
         # Validate graph definition input
         assert graph_json, "Graph JSON must be provided"
         graph_definition: GraphDefinition = GraphDefinition.from_dict(graph_json)
@@ -158,6 +168,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         cache: RequestCache = input_cache if input_cache is not None else RequestCache()
         async with cache:
             # Retrieve start resources based on graph definition
+            step_start = time.perf_counter()
             start: str = graph_definition.start
             parent_response: FhirGetResponse
             cache_hits: int
@@ -171,10 +182,18 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 add_cached_bundles_to_result=add_cached_bundles_to_result,
                 compare_hash=compare_hash,
             )
+            profiling["steps"]["get_start_resources"] = time.perf_counter() - step_start
 
             # If no parent resources found, yield empty response and exit
             parent_response_resource_count = parent_response.get_resource_count()
             if parent_response_resource_count == 0:
+                profiling["total_time"] = time.perf_counter() - profiling["start_time"]
+                if logger:
+                    logger.info(
+                        f"[PROFILING] process_simulate_graph_async: total={profiling['total_time']:.3f}s, "
+                        f"get_start_resources={profiling['steps'].get('get_start_resources', 0):.3f}s, "
+                        f"no parent resources found"
+                    )
                 yield parent_response
                 return  # no resources to process
 
@@ -196,6 +215,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 )
 
             # now process the graph links
+            step_start = time.perf_counter()
             child_responses: list[FhirGetResponse] = []
             parent_link_map: list[tuple[list[GraphDefinitionLink], FhirBundleEntryList]] = []
 
@@ -204,6 +224,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 parent_link_map.append((graph_definition.link, parent_bundle_entries))
 
             # Process graph links in parallel
+            link_processing_count = 0
             while len(parent_link_map):
                 new_parent_link_map: list[tuple[list[GraphDefinitionLink], FhirBundleEntryList]] = []
 
@@ -230,19 +251,38 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                         add_cached_bundles_to_result=add_cached_bundles_to_result,
                         ifModifiedSince=ifModifiedSince,
                     ):
+                        # Track extend operation
+                        extend_start = time.perf_counter()
                         child_responses.extend(link_responses)
+                        extend_time = time.perf_counter() - extend_start
+                        profiling["extend_calls"].append(
+                            {"location": "child_responses.extend", "count": len(link_responses), "time": extend_time}
+                        )
+                        link_processing_count += 1
 
                 # Update parent link map for next iteration
                 parent_link_map = new_parent_link_map
 
+            profiling["steps"]["process_graph_links"] = time.perf_counter() - step_start
+            profiling["steps"]["link_processing_iterations"] = link_processing_count
+
             # Combine and process responses
+            step_start = time.perf_counter()
             parent_response = cast(FhirGetBundleResponse, parent_response.extend(child_responses))
+            extend_time = time.perf_counter() - step_start
+            profiling["steps"]["parent_response.extend"] = extend_time
+            profiling["extend_calls"].append(
+                {"location": "parent_response.extend", "count": len(child_responses), "time": extend_time}
+            )
 
             # Optional resource sorting
             if sort_resources:
+                step_start = time.perf_counter()
                 parent_response = parent_response.sort_resources()
+                profiling["steps"]["sort_resources"] = time.perf_counter() - step_start
 
             # Prepare final response based on bundling preferences
+            step_start = time.perf_counter()
             full_response: FhirGetResponse
             if separate_bundle_resources:
                 full_response = FhirGetListByResourceTypeResponse.from_response(other_response=parent_response)
@@ -250,10 +290,38 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 full_response = FhirGetListResponse.from_response(other_response=parent_response)
             else:
                 full_response = parent_response
+            profiling["steps"]["prepare_final_response"] = time.perf_counter() - step_start
 
             # Set response URL
             full_response.url = url or parent_response.url
 
+            # Calculate profiling summary
+            profiling["total_time"] = time.perf_counter() - profiling["start_time"]
+            total_extend_time = sum(call["time"] for call in profiling["extend_calls"])
+            total_extend_count = sum(call["count"] for call in profiling["extend_calls"])
+
+            # Log profiling information
+            if logger:
+                logger.info(
+                    f"[PROFILING] process_simulate_graph_async for id={id_}: "
+                    f"total={profiling['total_time']:.3f}s, "
+                    f"get_start_resources={profiling['steps'].get('get_start_resources', 0):.3f}s, "
+                    f"process_graph_links={profiling['steps'].get('process_graph_links', 0):.3f}s, "
+                    f"parent_response.extend={profiling['steps'].get('parent_response.extend', 0):.3f}s, "
+                    f"sort_resources={profiling['steps'].get('sort_resources', 0):.3f}s, "
+                    f"prepare_final_response={profiling['steps'].get('prepare_final_response', 0):.3f}s"
+                )
+                logger.info(
+                    f"[PROFILING] process_simulate_graph_async extend operations: "
+                    f"total_calls={len(profiling['extend_calls'])}, "
+                    f"total_items={total_extend_count}, "
+                    f"total_time={total_extend_time:.3f}s"
+                )
+                for call in profiling["extend_calls"]:
+                    logger.info(
+                        f"[PROFILING]   extend at {call['location']}: items={call['count']}, time={call['time']:.3f}s"
+                    )
+
             # Log cache performance
             if logger:
                 logger.info(
@@ -276,26 +344,9 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
     ) -> list[FhirGetResponse]:
         """
         Parallel processing function for graph definition links.
-
-        This method is designed to be used with AsyncParallelProcessor to process
-        graph links concurrently, improving performance for complex FHIR resource
-        graph traversals.
-
-        Key Responsibilities:
-        - Process individual graph links in parallel
-        - Track and log processing details
-        - Handle resource retrieval for each link
-        - Manage parallel processing context
-
-        Args:
-            context: Parallel processing context information
-            row: Current GraphDefinitionLink being processed
-            parameters: Parameters for link processing
-            additional_parameters: Extra parameters for extended processing
-
-        Returns:
-            List of FhirGetResponse objects retrieved during link processing
         """
+        profiling_start = time.perf_counter()
+
         # Record the start time for performance tracking
         start_time: datetime = datetime.now()
 
@@ -326,11 +377,8 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             logger=parameters.logger,
             cache=parameters.cache,
             scope_parser=parameters.scope_parser,
-            # Handle parent link map from additional parameters
             parent_link_map=(additional_parameters["parent_link_map"] if additional_parameters else []),
-            # Determine request size, default to 1 if not specified
             request_size=(additional_parameters["request_size"] if additional_parameters else 1),
-            # Track unsupported resources for ID-based search
             id_search_unsupported_resources=(
                 additional_parameters["id_search_unsupported_resources"] if additional_parameters else []
             ),
@@ -346,6 +394,8 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         # Record end time for performance tracking
         end_time: datetime = datetime.now()
 
+        total_time = time.perf_counter() - profiling_start
+
         # Log detailed processing information
         if parameters.logger:
             parameters.logger.debug(
@@ -357,6 +407,11 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 + f" | duration: {end_time - start_time}"
                 + f" | resource_count: {len(result)}"
             )
+            parameters.logger.info(
+                f"[PROFILING] process_link_async_parallel_function for path={row.path}: "
+                f"total={total_time:.3f}s, "
+                f"results={len(result)}"
+            )
 
         # Return the list of retrieved responses
         return result
@@ -842,9 +897,18 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         logger: Logger | None,
         compare_hash: bool = True,
     ) -> FhirGetResponse | None:
+        profiling_start = time.perf_counter()
+        http_request_time = 0.0
+        http_request_count = 0
+        cache_check_time = 0.0
+        cache_update_time = 0.0
+        append_time = 0.0
+
         result: FhirGetResponse | None = None
         non_cached_id_list: list[str] = []
+
         # first check to see if we can find these in the cache
+        cache_check_start = time.perf_counter()
         if ids:
             for resource_id in ids:
                 cache_entry: RequestCacheEntry | None = await cache.get_async(
@@ -857,9 +921,12 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     if logger:
                         logger.info(f"Cache entry not found for {resource_type}/{resource_id} (1by1)")
                     non_cached_id_list.append(resource_id)
+        cache_check_time = time.perf_counter() - cache_check_start
 
+        cache_update_start = time.perf_counter()
         for single_id in non_cached_id_list:
             result2: FhirGetResponse
+            http_start = time.perf_counter()
             async for result2 in self._get_with_session_async(
                 page_number=None,
                 ids=[single_id],
@@ -868,10 +935,15 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 fn_handle_streaming_chunk=None,
                 resource_type=resource_type,
             ):
+                http_request_time += time.perf_counter() - http_start
+                http_request_count += 1
+
                 if result2.resource_type == "OperationOutcome":
                     result2 = FhirGetErrorResponse.from_response(other_response=result2)
                 if result:
+                    append_start = time.perf_counter()
                     result = result.append(result2)
+                    append_time += time.perf_counter() - append_start
                 else:
                     result = result2
                 if result2.successful:
@@ -905,6 +977,21 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     )
                     if cache_updated and logger:
                         logger.info(f"Inserted {result2.status} for {resource_type}/{single_id} into cache (1by1)")
+        cache_update_time = time.perf_counter() - cache_update_start - http_request_time - append_time
+
+        total_time = time.perf_counter() - profiling_start
+        processing_time = total_time - http_request_time - cache_check_time - cache_update_time - append_time
+
+        if logger and http_request_count > 0:
+            logger.info(
+                f"[PROFILING] _get_resources_by_id_one_by_one_async for {resource_type}: "
+                f"total={total_time:.3f}s, "
+                f"http_requests={http_request_time:.3f}s ({http_request_count} calls), "
+                f"cache_check={cache_check_time:.3f}s, "
+                f"cache_update={cache_update_time:.3f}s, "
+                f"append={append_time:.3f}s, "
+                f"processing={processing_time:.3f}s"
+            )
 
         return result
 
@@ -921,6 +1008,13 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         add_cached_bundles_to_result: bool = True,
         compare_hash: bool = True,
     ) -> tuple[FhirGetResponse, int]:
+        profiling_start = time.perf_counter()
+        http_request_time = 0.0
+        http_request_count = 0
+        cache_check_time = 0.0
+        cache_update_time = 0.0
+        append_time = 0.0
+
         assert resource_type
         if not scope_parser.scope_allows(resource_type=resource_type):
             if logger:
@@ -954,14 +1048,13 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
 
         non_cached_id_list: list[str] = []
         # get any cached resources
+        cache_check_start = time.perf_counter()
         if id_list:
             for resource_id in id_list:
                 cache_entry: RequestCacheEntry | None = await cache.get_async(
                     resource_type=resource_type, resource_id=resource_id
                 )
                 if cache_entry:
-                    # if there is an entry then it means we tried to get it in the past
-                    # so don't get it again whether we were successful or not
                     if logger:
                         logger.info(
                             f"{cache_entry.status} Returning {resource_type}/{resource_id} from cache (ByParam)"
@@ -970,6 +1063,7 @@ 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)
+        cache_check_time = time.perf_counter() - cache_check_start
 
         all_result: FhirGetResponse | None = None
         # either we have non-cached ids or this is a query without id but has other parameters
@@ -981,6 +1075,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             # call the server to get the resources
             result1: FhirGetResponse
             result: FhirGetResponse | None
+            http_start = time.perf_counter()
             async for result1 in self._get_with_session_async(
                 page_number=None,
                 ids=non_cached_id_list,
@@ -989,6 +1084,8 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 fn_handle_streaming_chunk=None,
                 resource_type=resource_type,
             ):
+                http_request_time += time.perf_counter() - http_start
+                http_request_count += 1
                 result = result1
                 # if we got a failure then check if we can get it one by one
                 if (not result or result.status != 200) and len(non_cached_id_list) > 1:
@@ -1001,6 +1098,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                                 f" Fetching one by one ids: {non_cached_id_list}"
                             )
                     # For some resources if search by _id doesn't work then fetch one by one.
+                    one_by_one_start = time.perf_counter()
                     result = await self._get_resources_by_id_one_by_one_async(
                         resource_type=resource_type,
                         ids=non_cached_id_list,
@@ -1009,6 +1107,9 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                         logger=logger,
                         compare_hash=compare_hash,
                     )
+                    one_by_one_time = time.perf_counter() - one_by_one_start
+                    http_request_time += one_by_one_time
+                    http_request_count += len(non_cached_id_list)
                 else:
                     if logger:
                         logger.info(f"Fetched {resource_type} resources using _id for url {self._url}")
@@ -1024,11 +1125,14 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
 
                     # append to the response
                     if all_result:
+                        append_start = time.perf_counter()
                         all_result = all_result.append(result)
+                        append_time += time.perf_counter() - append_start
                     else:
                         all_result = result
         # If non_cached_id_list is not empty and resource_type does not support ?_id search then fetch it one by one
         elif len(non_cached_id_list):
+            one_by_one_start = time.perf_counter()
             all_result = await self._get_resources_by_id_one_by_one_async(
                 resource_type=resource_type,
                 ids=non_cached_id_list,
@@ -1037,10 +1141,13 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 logger=logger,
                 compare_hash=compare_hash,
             )
+            http_request_time += time.perf_counter() - one_by_one_start
+            http_request_count += len(non_cached_id_list)
 
         # This list tracks the non-cached ids that were found
         found_non_cached_id_list: list[str] = []
         # Cache the fetched entries
+        cache_update_start = time.perf_counter()
         if all_result:
             non_cached_bundle_entry: FhirBundleEntry
             for non_cached_bundle_entry in all_result.get_bundle_entries():
@@ -1074,7 +1181,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                             logger.debug(f"Inserted {resource_type}/{non_cached_resource_id} into cache (ByParam)")
                         found_non_cached_id_list.append(non_cached_resource_id)
 
-        # now add all the non-cached ids that were NOT found to the cache too so we don't look for them again
         for non_cached_id in non_cached_id_list:
             if non_cached_id not in found_non_cached_id_list:
                 cache_updated = await cache.add_async(
@@ -1089,6 +1195,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 )
                 if cache_updated and logger:
                     logger.info(f"Inserted 404 for {resource_type}/{non_cached_id} into cache (ByParam)")
+        cache_update_time = time.perf_counter() - cache_update_start
 
         bundle_response: FhirGetBundleResponse = (
             FhirGetBundleResponse.from_response(other_response=all_result)
@@ -1130,6 +1237,21 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 storage_mode=self._storage_mode,
             )
         )
+
+        total_time = time.perf_counter() - profiling_start
+        processing_time = total_time - http_request_time - cache_check_time - cache_update_time - append_time
+
+        if logger and http_request_count > 0:
+            logger.info(
+                f"[PROFILING] _get_resources_by_parameters_async for {resource_type}: "
+                f"total={total_time:.3f}s, "
+                f"http_requests={http_request_time:.3f}s ({http_request_count} calls), "
+                f"cache_check={cache_check_time:.3f}s, "
+                f"cache_update={cache_update_time:.3f}s, "
+                f"append={append_time:.3f}s, "
+                f"processing={processing_time:.3f}s"
+            )
+
         return bundle_response, cache.cache_hits
 
     # noinspection PyPep8Naming

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/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
@@ -132,8 +133,21 @@ class FhirGetBundleResponse(FhirGetResponse):
         :param others: list of FhirGetResponse objects
         :return: self
         """
+        if not others:
+            return self
+
+        all_entries: list[FhirBundleEntry] = []
         for other_response in others:
-            self.append(other_response=other_response)
+            other_response_entries: FhirBundleEntryList = other_response.get_bundle_entries()
+            if len(other_response_entries) > 0:
+                all_entries.extend(other_response_entries)
+
+        # Now extend with all entries at once instead of one response at a time
+        if all_entries:
+            if self._bundle_entries is None:
+                self._bundle_entries = FhirBundleEntryList(all_entries)
+            else:
+                self._bundle_entries.extend(all_entries)
 
         return self
 
@@ -311,36 +325,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/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-4.2.18.dist-info → helix_fhir_client_sdk-4.2.20.dist-info}/METADATA

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

{helix_fhir_client_sdk-4.2.18.dist-info → helix_fhir_client_sdk-4.2.20.dist-info}/RECORD

@@ -32,7 +32,7 @@ helix_fhir_client_sdk/graph/fhir_graph_mixin.py,sha256=z0j9FmO2bOnmzgQmczfkWC70u
 helix_fhir_client_sdk/graph/graph_definition.py,sha256=FTa1GLjJ6oooAhNw7SPk-Y8duB-5WtJtnwADao-afaI,3878
 helix_fhir_client_sdk/graph/graph_link_parameters.py,sha256=3rknHL6SBgpT2A1fr-AikEFrR_9nIJUotZ82XFzROLo,599
 helix_fhir_client_sdk/graph/graph_target_parameters.py,sha256=fdYQpPZxDnyWyevuwDwxeTXOJoE2PgS5QhPaXpwtFcU,705
-helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py,sha256=h8K4peHcoY_4_Ln4Vz54Ls87W7bXegm4SZV2s2L4cCM,60302
+helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py,sha256=CNXlqjkdrebypCY4JHmz1XbGT3kpcSpich9ourE76H0,66430
 helix_fhir_client_sdk/graph/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 helix_fhir_client_sdk/graph/test/test_graph_mixin.py,sha256=LNd4LVjryVLgzWeTXMDpsbdauXl7u3LMfj9irnNfb_k,5469
 helix_fhir_client_sdk/graph/test/test_simulate_graph_processor_mixin.py,sha256=EQDfhqJfUrP6SptXRP7ayEN7g5cZQMA00ccXzeXiSXM,46312
@@ -46,15 +46,15 @@ helix_fhir_client_sdk/responses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 helix_fhir_client_sdk/responses/bundle_expander.py,sha256=ilR5eMgciSgzsdQvKB6bHtn9jtpvn3uS-EBz-hrahzo,1065
 helix_fhir_client_sdk/responses/fhir_client_protocol.py,sha256=IWM7LNQ1ZbgaySLGqpCwWAKyArT5HgBdNhkmSEivNMo,7100
 helix_fhir_client_sdk/responses/fhir_delete_response.py,sha256=0K11vyfZ0LtL-G61NHzDqHrZgEHjMVZr00VWpWcktZA,2941
-helix_fhir_client_sdk/responses/fhir_get_response.py,sha256=3PXvFoMZ7ix2ZzucIjY-49RL3foLR07dD57BdulyMGI,17657
+helix_fhir_client_sdk/responses/fhir_get_response.py,sha256=v0ndKFb6o8PNqYYxGlLETzQnxGmwK3YympH4gotXpY4,17550
 helix_fhir_client_sdk/responses/fhir_merge_response.py,sha256=uvUjEGJgMDlAkcc5_LjgAsTFZqREQMlV79sbxUZwtwE,2862
 helix_fhir_client_sdk/responses/fhir_response_processor.py,sha256=fOSvqWjVI1BA6aDxxu9aqEvcKxtnFRmU2hMrgtmUCUM,34056
 helix_fhir_client_sdk/responses/fhir_update_response.py,sha256=_6zZz85KQP69WFxejlX8BBWAKWtzsMGSJjR_zqhl_m4,2727
 helix_fhir_client_sdk/responses/get_result.py,sha256=hkbZeu9h-01ZZckAuckn6UDR9GXGgRAIiKEN6ELRj80,1252
 helix_fhir_client_sdk/responses/paging_result.py,sha256=tpmfdgrtaAmmViVxlw-EBHoe0PVjSQW9zicwRmhUVpI,1360
-helix_fhir_client_sdk/responses/resource_separator.py,sha256=jugaEkJYunx8VGVFCLwWNSjrBlI8DDm61LzSx9oR8iE,3230
+helix_fhir_client_sdk/responses/resource_separator.py,sha256=7Ic0_SPNKCBAk6l07Ke2-AoObkBMnKdmtbbtBBCtVjE,2606
 helix_fhir_client_sdk/responses/get/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-helix_fhir_client_sdk/responses/get/fhir_get_bundle_response.py,sha256=H-e-Rp_cwU508uJqQfDDCoJR5vN9-5DYsaW7K0yTsxM,18183
+helix_fhir_client_sdk/responses/get/fhir_get_bundle_response.py,sha256=PA1bzR4DkF91uTBM5tZCZ_AB0ovE49EJjq4O-1-Ya90,19357
 helix_fhir_client_sdk/responses/get/fhir_get_error_response.py,sha256=oNdKs_r7K4qRHD7fyeDhZz3v0wGTT2esAPPtDhxOyeI,12325
 helix_fhir_client_sdk/responses/get/fhir_get_list_by_resource_type_response.py,sha256=ssfb1IB2QTvqwWRzFs_VqPKH6mwcnWNo3iVh82M-Jso,13775
 helix_fhir_client_sdk/responses/get/fhir_get_list_response.py,sha256=KT5g6MjB9yWWUaSZpx1jK9Tm2yVmcFyZMHBBnDDAPtU,11858
@@ -130,7 +130,7 @@ helix_fhir_client_sdk/validators/async_fhir_validator.py,sha256=i1BC98hZF6JhMQQz
 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.18.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+helix_fhir_client_sdk-4.2.20.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=c5y1rWJ32nBSUnK1FfyymY005dNowd4Nf1xrbuQolNk,5368
@@ -213,7 +213,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.18.dist-info/METADATA,sha256=pCDGhnLDd-gwFGKTsEffDW5YHvStshWWOsFcEvRRAjc,7210
-helix_fhir_client_sdk-4.2.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-helix_fhir_client_sdk-4.2.18.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
-helix_fhir_client_sdk-4.2.18.dist-info/RECORD,,
+helix_fhir_client_sdk-4.2.20.dist-info/METADATA,sha256=A2csXjl7i8RJGVOVOi3hJgkOm68CGpDUNudPitzq_EA,7210
+helix_fhir_client_sdk-4.2.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+helix_fhir_client_sdk-4.2.20.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
+helix_fhir_client_sdk-4.2.20.dist-info/RECORD,,