helix.fhir.client.sdk 4.2.21__py3-none-any.whl → 4.2.23__py3-none-any.whl

helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py

@@ -124,15 +124,6 @@ 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)
@@ -168,7 +159,6 @@ 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
@@ -182,18 +172,10 @@ 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
 
@@ -207,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} "
@@ -215,7 +196,6 @@ 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]] = []
 
@@ -224,7 +204,6 @@ 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]] = []
 
@@ -251,38 +230,22 @@ 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
-
+            start_time = time.time()
             # 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}
-            )
+            if logger:
+                logger.info(f"Parent_response.extend time: {time.time() - start_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)
@@ -290,38 +253,10 @@ 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(
@@ -344,9 +279,26 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
     ) -> list[FhirGetResponse]:
         """
         Parallel processing function for graph definition links.
-        """
-        profiling_start = time.perf_counter()
 
+        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
+        """
         # Record the start time for performance tracking
         start_time: datetime = datetime.now()
 
@@ -377,8 +329,11 @@ 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 []
             ),
@@ -394,8 +349,6 @@ 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(
@@ -407,11 +360,6 @@ 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
@@ -897,18 +845,10 @@ 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(
@@ -921,12 +861,9 @@ 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],
@@ -935,15 +872,10 @@ 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:
@@ -977,22 +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)")
-        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
 
     async def _get_resources_by_parameters_async(
@@ -1008,13 +924,6 @@ 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:
@@ -1048,13 +957,14 @@ 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)"
@@ -1063,8 +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)
-        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
         if (
@@ -1075,7 +983,6 @@ 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,
@@ -1084,8 +991,6 @@ 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:
@@ -1098,7 +1003,6 @@ 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,
@@ -1107,9 +1011,6 @@ 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}")
@@ -1125,14 +1026,11 @@ 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,
@@ -1141,13 +1039,10 @@ 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():
@@ -1181,6 +1076,7 @@ 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(
@@ -1195,7 +1091,6 @@ 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)
@@ -1237,21 +1132,6 @@ 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/get/fhir_get_bundle_response.py

@@ -1,5 +1,4 @@
 import json
-import logging
 from collections.abc import AsyncGenerator, Generator
 from datetime import datetime
 from logging import Logger
@@ -27,7 +26,7 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_url_result import (
     RetryableAioHttpUrlResult,
 )
 
-logger = logging.getLogger(__name__)
+
 class FhirGetBundleResponse(FhirGetResponse):
     """
     This class represents a response from a FHIR server.
@@ -116,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
 
@@ -133,34 +133,8 @@ class FhirGetBundleResponse(FhirGetResponse):
         :param others: list of FhirGetResponse objects
         :return: self
         """
-        if not others:
-            return self
-
-        # Optimization: Since duplicates are already filtered by cache,
-        # we can bypass ALL duplicate checking and directly extend the deque
-        import time
-        collect_start = time.perf_counter()
-        all_entries: list[FhirBundleEntry] = []
         for other_response in others:
-            get_start = time.perf_counter()
-            other_response_entries: FhirBundleEntryList = other_response.get_bundle_entries()
-            get_time = time.perf_counter() - get_start
-            logger.info(f"[DEBUG] get_bundle_entries took {get_time:.3f}s for response with {len(other_response_entries)} entries")
-            if len(other_response_entries) > 0:
-                all_entries.extend(other_response_entries)
-        collect_time = time.perf_counter() - collect_start
-        print(f"[DEBUG] Collecting all entries from {len(others)} responses took {collect_time:.3f}s")
-
-        if all_entries:
-            if self._bundle_entries is None:
-                self._bundle_entries = FhirBundleEntryList()
-
-            extend_start = time.perf_counter()
-            from collections import deque
-            deque.extend(self._bundle_entries, all_entries)
-            extend_time = time.perf_counter() - extend_start
-            logger.info(f"[DEBUG] deque.extend of {len(all_entries)} entries took {extend_time:.3f}s")
-
+            self.append(other_response=other_response)
         return self
 
     @override
@@ -337,6 +311,9 @@ 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
         """
         # Build a lookup of cache entries by (resource_type, id)
         cache_map: dict[tuple[str, str], str | None] = {}
@@ -378,14 +355,6 @@ class FhirGetBundleResponse(FhirGetResponse):
             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
 

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

@@ -1,4 +1,5 @@
 import dataclasses
+from copy import deepcopy
 from typing import Any, cast
 
 
@@ -26,42 +27,46 @@ class ResourceSeparator:
         extra_context_to_return: dict[str, Any] | None,
     ) -> ResourceSeparatorResult:
         """
-        Separate contained resources without copying or mutating input resources.
-        """
-        resources_dicts: list[dict[str, str | None | list[dict[str, Any]]]] = []
-        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]]] = {}
+        Given a list of resources, return a list of resources with the contained resources separated out.
 
-            # 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
+        :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.
 
-            # 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
+        :return: None
+        """
+        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
             if extra_context_to_return:
-                resource_map.update(extra_context_to_return)
-
-            resources_dicts.append(resource_map)
+                resources_dict.update(extra_context_to_return)
+            resources_dicts.append(resources_dict)
 
-        return ResourceSeparatorResult(resources_dicts=resources_dicts, total_count=total_resource_count)
+        return ResourceSeparatorResult(resources_dicts=resources_dicts, total_count=resource_count)

{helix_fhir_client_sdk-4.2.21.dist-info → helix_fhir_client_sdk-4.2.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.21
+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.21.dist-info → helix_fhir_client_sdk-4.2.23.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=CNXlqjkdrebypCY4JHmz1XbGT3kpcSpich9ourE76H0,66430
+helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py,sha256=vNoiTL3wgo9slfwn-a8YsIeiwZIxVWVBaCQ-Ne1_4Gk,60460
 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
@@ -52,16 +52,16 @@ helix_fhir_client_sdk/responses/fhir_response_processor.py,sha256=fOSvqWjVI1BA6a
 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=7Ic0_SPNKCBAk6l07Ke2-AoObkBMnKdmtbbtBBCtVjE,2606
+helix_fhir_client_sdk/responses/resource_separator.py,sha256=jugaEkJYunx8VGVFCLwWNSjrBlI8DDm61LzSx9oR8iE,3230
 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=ouQlsnqbDgFkMvjxOHtdLh-BMRhmVmP76sqtAjWefro,20147
+helix_fhir_client_sdk/responses/get/fhir_get_bundle_response.py,sha256=ryNaHVBZOxsf3uKMhKrFIUCnpmC8h_X7d3-0mzwoqhQ,18659
 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
 helix_fhir_client_sdk/responses/get/fhir_get_response_factory.py,sha256=OrizzAVoXvxnQbBxszeS9PUtbzg97RGNEJfD4PuOLig,6815
 helix_fhir_client_sdk/responses/get/fhir_get_single_response.py,sha256=pLjjDyxBvA_FNI7sGU2hM9urue3Bzrrwo_RcrOD5yz8,9755
 helix_fhir_client_sdk/responses/get/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-helix_fhir_client_sdk/responses/get/test/test_get_bundle_response.py,sha256=k66eMtb0e4QcWYeF_M3TUrwCXQgD5EOcpUaijzg7a2I,19545
+helix_fhir_client_sdk/responses/get/test/test_get_bundle_response.py,sha256=DF4sjy074jiro8jASavd-2hMkjIR6sIdIytzhIyBRuU,19674
 helix_fhir_client_sdk/responses/get/test/test_get_error_response.py,sha256=8P4zGgeHe-6OaSX152ixFW4W0iG2scK89O0VY_YcxuY,7613
 helix_fhir_client_sdk/responses/get/test/test_get_list_by_resource_type_response.py,sha256=eIZlhTYg5Iqh0vTmVAlesenQDyT8eCmFs1U4JngIM8w,12942
 helix_fhir_client_sdk/responses/get/test/test_get_list_response.py,sha256=vOsdgqSd5TwwgbwEX_kYvDyOnqAaKBKGAZFr4EZpGDM,14428
@@ -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.21.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+helix_fhir_client_sdk-4.2.23.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.21.dist-info/METADATA,sha256=YjnoCZPuhvIXjOWEC647V37vZ0IzeXqhn-xBeCbGhuE,7210
-helix_fhir_client_sdk-4.2.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-helix_fhir_client_sdk-4.2.21.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
-helix_fhir_client_sdk-4.2.21.dist-info/RECORD,,
+helix_fhir_client_sdk-4.2.23.dist-info/METADATA,sha256=rIrYEAk9e96PhiNUoqRSwUAm-vA3qWB-34bOmhXwuoU,7210
+helix_fhir_client_sdk-4.2.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+helix_fhir_client_sdk-4.2.23.dist-info/top_level.txt,sha256=BRnDS6ceQxs-4u2jXznATObgP8G2cGAerlH0ZS4sJ6M,46
+helix_fhir_client_sdk-4.2.23.dist-info/RECORD,,