helix.fhir.client.sdk 4.2.5__tar.gz → 4.2.7__tar.gz

{helix_fhir_client_sdk-4.2.5/helix.fhir.client.sdk.egg-info → helix_fhir_client_sdk-4.2.7}/PKG-INFO

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

helix_fhir_client_sdk-4.2.7/VERSION

@@ -0,0 +1 @@
+4.2.7

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7/helix.fhir.client.sdk.egg-info}/PKG-INFO

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

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/fhir_auth_mixin.py

@@ -180,6 +180,7 @@ class FhirAuthMixin(FhirClientProtocol):
             access_token_expiry_date=self._access_token_expiry_date,
             refresh_token_func=self._refresh_token_function,
             tracer_request_func=self._trace_request_function,
+            persistent_session=self._persistent_session,
         ) as client:
             if self._auth_wellknown_url:
                 host_name: str = furl(self._auth_wellknown_url).host
@@ -281,6 +282,7 @@ class FhirAuthMixin(FhirClientProtocol):
             access_token_expiry_date=self._access_token_expiry_date,
             refresh_token_func=self._refresh_token_function,
             tracer_request_func=self._trace_request_function,
+            persistent_session=self._persistent_session,
         ) as client:
             response: RetryableAioHttpResponse = await client.post(url=auth_server_url, headers=headers, data=payload)
             # token = response.text.encode('utf8')

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/fhir_client.py

@@ -480,24 +480,6 @@ class FhirClient(
         self._persistent_session = session
         return self
 
-    def use_persistent_session(self, value: bool) -> FhirClient:
-        """
-        Sets the use_persistent_session flag
-
-        :param value: whether to use the persistent session
-        """
-        self._use_persistent_session = value
-        return self
-
-    def close_session_after_request(self, value: bool) -> FhirClient:
-        """
-        Sets the _close_session flag (default is True)
-
-        :param value: whether to close the session after each request
-        """
-        self._close_session = value
-        return self
-
     # noinspection PyUnusedLocal
     @staticmethod
     async def on_request_end(

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/fhir_delete_mixin.py

@@ -57,8 +57,6 @@ class FhirDeleteMixin(FhirClientProtocol):
             access_token_expiry_date=self._access_token_expiry_date,
             tracer_request_func=self._trace_request_function,
             persistent_session=self._persistent_session,
-            use_persistent_session=self._use_persistent_session,
-            close_session_on_exit=self._close_session,
         ) as client:
             response: RetryableAioHttpResponse = await client.delete(url=full_uri.tostr(), headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)
@@ -128,6 +126,7 @@ class FhirDeleteMixin(FhirClientProtocol):
             access_token=self._access_token,
             access_token_expiry_date=self._access_token_expiry_date,
             tracer_request_func=self._trace_request_function,
+            persistent_session=self._persistent_session,
         ) as client:
             response: RetryableAioHttpResponse = await client.delete(url=full_url, headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/fhir_merge_mixin.py

@@ -182,8 +182,6 @@ class FhirMergeMixin(FhirClientProtocol):
                             access_token=self._access_token,
                             access_token_expiry_date=self._access_token_expiry_date,
                             persistent_session=self._persistent_session,
-                            use_persistent_session=self._use_persistent_session,
-                            close_session_on_exit=self._close_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/fhir_merge_resources_mixin.py

@@ -3,7 +3,7 @@ import time
 from collections import deque
 from collections.abc import AsyncGenerator
 from typing import (
-    cast, Any
+    cast,
 )
 from urllib import parse
 
@@ -45,200 +45,6 @@ from helix_fhir_client_sdk.validators.async_fhir_validator import AsyncFhirValid
 
 
 class FhirMergeResourcesMixin(FhirClientProtocol):
-    async def merge_bundle_without_storage(
-        self,
-        id_: str | None,
-        bundle: FhirBundle,
-    ) -> FhirMergeResourceResponse:
-        """
-        Optimized version of merge_bundle_async without storage_mode overhead.
-        Calls $merge function on FHIR server with minimal processing.
-
-        :param id_: id of the resource to merge
-        :param bundle: FHIR Bundle to merge
-        :return: FhirMergeResourceResponse
-        """
-        # Initialize profiling dictionary
-        profiling: dict[str, float] = {
-            "total_time": 0.0,
-            "build_url": 0.0,
-            "get_access_token": 0.0,
-            "prepare_payload": 0.0,
-            "http_post": 0.0,
-            "parse_response": 0.0,
-            "create_response_objects": 0.0,
-        }
-        
-        merge_start_time = time.time()
-        
-        assert self._url, "No FHIR server url was set"
-        assert isinstance(bundle, FhirBundle), f"Expected FhirBundle, got {type(bundle)}"
-        assert len(bundle.entry) > 0, "Bundle must have at least one entry"
-
-        request_id: str | None = None
-        response_status: int = 500
-        
-        # Build URL
-        build_url_start = time.time()
-        full_uri: furl = furl(self._url)
-        assert self._resource
-        full_uri /= self._resource
-        
-        # Prepare headers
-        headers = {"Content-Type": "application/fhir+json"}
-        headers.update(self._additional_request_headers)
-        profiling["build_url"] = time.time() - build_url_start
-        
-        # Get access token
-        get_token_start = time.time()
-        access_token_result: GetAccessTokenResult = await self.get_access_token_async()
-        access_token: str | None = access_token_result.access_token
-        if access_token:
-            headers["Authorization"] = f"Bearer {access_token}"
-        profiling["get_access_token"] = time.time() - get_token_start
-
-        # Prepare JSON payload
-        prepare_payload_start = time.time()
-        first_resource: FhirResource | None = bundle.entry[0].resource
-        assert first_resource is not None
-        json_payload: str = first_resource.json() if len(bundle.entry) == 1 else bundle.json()
-        
-        # Build merge URL
-        obj_id: str = id_ or "1"
-        resource_uri: furl = full_uri / parse.quote(str(obj_id), safe="") / "$merge"
-        profiling["prepare_payload"] = time.time() - prepare_payload_start
-        
-        response_text: str | None = None
-        responses: list[dict[str, Any]] = []
-        errors: list[dict[str, Any]] = []
-        
-        try:
-            async with RetryableAioHttpClient(
-                fn_get_session=lambda: self.create_http_session(),
-                refresh_token_func=self._refresh_token_function,
-                tracer_request_func=self._trace_request_function,
-                retries=self._retry_count,
-                exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
-                use_data_streaming=self._use_data_streaming,
-                send_data_as_chunked=self._send_data_as_chunked,
-                compress=self._compress,
-                throw_exception_on_error=self._throw_exception_on_error,
-                log_all_url_results=self._log_all_response_urls,
-                access_token=self._access_token,
-                access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
-                use_persistent_session=self._use_persistent_session,
-                close_session_on_exit=self._close_session,
-            ) as client:
-                http_post_start = time.time()
-                response: RetryableAioHttpResponse = await client.post(
-                    url=resource_uri.url,
-                    data=json_payload,
-                    headers=headers,
-                )
-                profiling["http_post"] = time.time() - http_post_start
-                
-                response_status = response.status
-                request_id = response.response_headers.get("X-Request-ID", None)
-                
-                parse_response_start = time.time()
-                if response.status == 200:
-                    response_text = await response.get_text_async()
-                    if response_text:
-                        try:
-                            # Parse response as plain dicts for speed
-                            parsed_response = json.loads(response_text)
-                            if isinstance(parsed_response, list):
-                                responses = parsed_response
-                            else:
-                                responses = [parsed_response]
-                        except (ValueError, json.JSONDecodeError) as e:
-                            errors.append({
-                                "issue": [{
-                                    "severity": "error",
-                                    "code": "exception",
-                                    "diagnostics": f"Failed to parse response: {str(e)}"
-                                }]
-                            })
-                else:
-                    # HTTP error
-                    response_text = await response.get_text_async()
-                    errors.append({
-                        "issue": [{
-                            "severity": "error",
-                            "code": "exception",
-                            "diagnostics": response_text or f"HTTP {response.status}"
-                        }]
-                    })
-                profiling["parse_response"] = time.time() - parse_response_start
-                    
-        except requests.exceptions.HTTPError as e:
-            raise FhirSenderException(
-                request_id=request_id,
-                url=resource_uri.url,
-                headers=headers,
-                json_data=json_payload,
-                response_text=response_text,
-                response_status_code=response_status,
-                exception=e,
-                variables=FhirClientLogger.get_variables_to_log(vars(self)),
-                message=f"HttpError: {e}",
-                elapsed_time=time.time() - merge_start_time,
-            ) from e
-        except Exception as e:
-            raise FhirSenderException(
-                request_id=request_id,
-                url=resource_uri.url,
-                headers=headers,
-                json_data=json_payload,
-                response_text=response_text,
-                response_status_code=response_status,
-                exception=e,
-                variables=FhirClientLogger.get_variables_to_log(vars(self)),
-                message=f"Unknown Error: {e}",
-                elapsed_time=time.time() - merge_start_time,
-            ) from e
-        
-        # Convert dict responses to proper objects using fast method
-        create_objects_start = time.time()
-        response_entries: deque[BaseFhirMergeResourceResponseEntry] = deque()
-        
-        for resp_dict in responses:
-            response_entries.append(
-                FhirMergeResourceResponseEntry.from_dict_without_storage(resp_dict)
-            )
-        
-        for error_dict in errors:
-            response_entries.append(
-                FhirMergeResponseEntryError.from_dict(error_dict)
-            )
-        profiling["create_response_objects"] = time.time() - create_objects_start
-        
-        profiling["total_time"] = time.time() - merge_start_time
-        
-        # Log profiling information if logger is available
-        if self._logger:
-            self._logger.info(
-                f"merge_bundle_without_storage profiling: "
-                f"total={profiling['total_time']:.3f}s, "
-                f"build_url={profiling['build_url']:.3f}s, "
-                f"get_token={profiling['get_access_token']:.3f}s, "
-                f"prepare_payload={profiling['prepare_payload']:.3f}s, "
-                f"http_post={profiling['http_post']:.3f}s, "
-                f"parse_response={profiling['parse_response']:.3f}s, "
-                f"create_objects={profiling['create_response_objects']:.3f}s"
-            )
-        
-        return FhirMergeResourceResponse(
-            request_id=request_id,
-            url=resource_uri.url,
-            responses=response_entries,
-            error=None if response_status == 200 else (response_text or f"HTTP {response_status}"),
-            access_token=self._access_token,
-            status=response_status,
-            response_text=response_text,
-        )
-
     async def merge_bundle_async(
         self,
         id_: str | None,
@@ -319,8 +125,6 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                         access_token=self._access_token,
                         access_token_expiry_date=self._access_token_expiry_date,
                         persistent_session=self._persistent_session,
-                        use_persistent_session=self._use_persistent_session,
-                        close_session_on_exit=self._close_session,
                     ) as client:
                         # should we check if it exists and do a POST then?
                         response: RetryableAioHttpResponse = await client.post(
@@ -537,9 +341,7 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                             log_all_url_results=self._log_all_response_urls,
                             access_token=self._access_token,
                             access_token_expiry_date=self._access_token_expiry_date,
-                            close_session_on_exit=self._close_session,
                             persistent_session=self._persistent_session,
-                            use_persistent_session=self._use_persistent_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/fhir_patch_mixin.py

@@ -73,8 +73,6 @@ class FhirPatchMixin(FhirClientProtocol):
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
                 persistent_session=self._persistent_session,
-                use_persistent_session=self._use_persistent_session,
-                close_session_on_exit=self._close_session,
             ) as client:
                 response: RetryableAioHttpResponse = await client.patch(
                     url=full_uri.url, json=deserialized_data, headers=headers

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/fhir_update_mixin.py

@@ -107,8 +107,6 @@ class FhirUpdateMixin(FhirClientProtocol):
             access_token=self._access_token,
             access_token_expiry_date=self._access_token_expiry_date,
             persistent_session=self._persistent_session,
-            use_persistent_session=self._use_persistent_session,
-            close_session_on_exit=self._close_session,
         ) as client:
             response = await client.put(url=full_uri.url, data=json_data, headers=headers)
             request_id = response.response_headers.get("X-Request-ID", None)

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py

@@ -80,7 +80,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         add_cached_bundles_to_result: bool = True,
         input_cache: RequestCache | None = None,
         compare_hash: bool = True,
-        make_persistent_connection: bool = False,
     ) -> AsyncGenerator[FhirGetResponse, None]:
         """
         Asynchronously simulate a FHIR $graph query with advanced processing capabilities.
@@ -120,7 +119,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             add_cached_bundles_to_result: Optional flag to add cached bundles to result
             input_cache: Optional cache for resource retrieval
             compare_hash: Flag to compare resource hashes for changes
-            make_persistent_connection: Flag to make a persistent HTTP connection
 
         Yields:
             FhirGetResponse objects representing retrieved resources
@@ -134,17 +132,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         # Parse authentication scopes for resource access control
         scope_parser: FhirScopeParser = FhirScopeParser(scopes=auth_scopes)
 
-        persistent_session = None
-        if make_persistent_connection:
-            # Create a persistent HTTP session for reuse across all requests in this graph traversal
-            persistent_session = self.create_http_session()
-
-            # Store the origninal create_http_session method
-            original_create_http_session = self.create_http_session
-
-            # Override create_http_session to return the persistent session
-            self.create_http_session = lambda: persistent_session  # type: ignore[method-assign]
-
         # Ensure bundle resources are not separated by default
         self.separate_bundle_resources(False)
 
@@ -279,13 +266,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             # Yield the final response
             yield full_response
 
-        if persistent_session:
-            # Clean up: close the persistent session
-            await persistent_session.close()
-
-        if make_persistent_connection:
-            self.create_http_session = original_create_http_session  # type: ignore[method-assign]
-
     # noinspection PyUnusedLocal
     async def process_link_async_parallel_function(
         self,
@@ -1172,7 +1152,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         add_cached_bundles_to_result: bool = True,
         input_cache: RequestCache | None = None,
         compare_hash: bool = True,
-        make_persistent_connection: bool = False,
     ) -> FhirGetResponse:
         """
         Simulates the $graph query on the FHIR server
@@ -1195,7 +1174,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         :param add_cached_bundles_to_result: Optional flag to add cached bundles to result
         :param input_cache: Optional cache to use for input
         :param compare_hash: Optional flag to compare hash of the resources
-        :param make_persistent_connection: Whether to make the connection persistent for reuse across all requests in this graph traversal
         :return: FhirGetResponse
         """
         if contained:
@@ -1226,7 +1204,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 add_cached_bundles_to_result=add_cached_bundles_to_result,
                 input_cache=input_cache,
                 compare_hash=compare_hash,
-                make_persistent_connection=make_persistent_connection,
             )
         )
         assert result, "No result returned from simulate_graph_async"

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/queue/request_queue_mixin.py

@@ -130,9 +130,7 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                close_session_on_exit=self._close_session,
                 persistent_session=self._persistent_session,
-                use_persistent_session=self._use_persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present
@@ -301,9 +299,7 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                close_session_on_exit=self._close_session,
                 persistent_session=self._persistent_session,
-                use_persistent_session=self._use_persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/responses/fhir_client_protocol.py

@@ -90,8 +90,6 @@ class FhirClientProtocol(Protocol):
     _last_page_lock: Lock
 
     _persistent_session: ClientSession | None = None
-    _use_persistent_session: bool = False
-    _close_session: bool = True
 
     _use_post_for_search: bool = False
 

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/responses/merge/fhir_merge_resource_response_entry.py

@@ -75,34 +75,6 @@ class FhirMergeResourceResponseEntry(BaseFhirMergeResourceResponseEntry):
             status=data.get("status"),
         )
 
-    @classmethod
-    def from_dict_without_storage(
-        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
-        """
-        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=(FhirResource.construct(**data.get("resource")) if data.get("resource") else None),
-            status=data.get("status"),
-        )
-
     @classmethod
     @override
     def from_json(

{helix_fhir_client_sdk-4.2.5 → helix_fhir_client_sdk-4.2.7}/helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py

@@ -46,8 +46,6 @@ class RetryableAioHttpClient:
         access_token: str | None,
         access_token_expiry_date: datetime | None,
         persistent_session: ClientSession | None = None,
-        use_persistent_session: bool = False,
-        close_session_on_exit: bool = True,
     ) -> None:
         """
         RetryableClient provides a way to make HTTP calls with automatic retry and automatic refreshing of access tokens
@@ -73,12 +71,10 @@ class RetryableAioHttpClient:
         self.log_all_url_results: bool = log_all_url_results
         self.access_token: str | None = access_token
         self.access_token_expiry_date: datetime | None = access_token_expiry_date
-        self.close_session_on_exit: bool = close_session_on_exit
         self.persistent_session: ClientSession | None = persistent_session
-        self.use_persistent_session: bool = use_persistent_session
 
     async def __aenter__(self) -> "RetryableAioHttpClient":
-        if self.use_persistent_session and self.persistent_session is not None:
+        if self.persistent_session is not None:
             self.session = self.persistent_session
         else:
             self.session = self.fn_get_session()
@@ -90,7 +86,7 @@ class RetryableAioHttpClient:
         exc_val: BaseException | None,
         exc_tb: type[BaseException] | None | None,
     ) -> None:
-        if self.session is not None and self.close_session_on_exit:
+        if not self.persistent_session and self.session is not None:
             await self.session.close()
 
     @staticmethod

helix_fhir_client_sdk-4.2.5/VERSION

@@ -1 +0,0 @@
-4.2.5