compressedfhir 1.0.8__tar.gz → 1.0.10__tar.gz

{compressedfhir-1.0.8/compressedfhir.egg-info → compressedfhir-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compressedfhir
-Version: 1.0.8
+Version: 1.0.10
 Summary: Stores FHIR JSON resources in compressed form in memory
 Home-page: https://github.com/icanbwell/compressed-fhir
 Author: Imran Qureshi

compressedfhir-1.0.10/VERSION

@@ -0,0 +1 @@
+1.0.10

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_bundle.py

@@ -68,7 +68,7 @@ class FhirBundle:
         self.link: Optional[List[FhirLink]] = link
         self.meta: Optional[FhirMeta] = meta
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         entries: List[Dict[str, Any]] | None = (
             [entry.dict() for entry in self.entry] if self.entry else None
         )
@@ -289,4 +289,8 @@ class FhirBundle:
 
         :return: Plain dictionary representation of the Bundle
         """
-        return OrderedDictToDictConverter.convert(self.dict())
+        return (
+            OrderedDictToDictConverter.convert(self.dict())  # type: ignore[arg-type]
+            if isinstance(self.dict(), OrderedDict)
+            else self.dict()
+        )

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_bundle_entry.py

@@ -134,7 +134,7 @@ class FhirBundleEntry:
         else:
             self._resource = None
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         result: OrderedDict[str, Any] = OrderedDict[str, Any]()
         if self.fullUrl is not None:
             result["fullUrl"] = self.fullUrl

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_bundle_entry_request.py

@@ -27,7 +27,7 @@ class FhirBundleEntryRequest:
         self.ifNoneMatch: Optional[str] = ifNoneMatch
         self.ifNoneExist: Optional[str] = ifNoneExist
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         result: OrderedDict[str, Any] = OrderedDict[str, Any](
             {"url": self.url, "method": self.method}
         )

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_bundle_entry_response.py

@@ -27,7 +27,7 @@ class FhirBundleEntryResponse:
         self.etag: Optional[str] = etag
         self.location: Optional[str] = location
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         result: OrderedDict[str, Any] = OrderedDict[str, Any]({"status": self.status})
         if self.lastModified is not None:
             result["lastModified"] = self.lastModified.isoformat()

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_bundle_entry_search.py

@@ -21,7 +21,7 @@ class FhirBundleEntrySearch:
         self.mode: Optional[str] = mode
         self.score: Optional[float] = score
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         """
         Converts the FhirBundleEntrySearch instance to a dictionary.
 

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_identifier.py

@@ -28,7 +28,7 @@ class FhirIdentifier:
         self.system: Optional[str] = system
         self.value: Optional[str] = value
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         """
         Convert the FhirIdentifier object to a dictionary.
 

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_link.py

@@ -22,7 +22,7 @@ class FhirLink:
         self.url: str = url
         self.relation: str = relation
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         """
         Converts the FhirLink instance to a dictionary.
 

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_meta.py

@@ -17,7 +17,7 @@ class FhirMeta:
     security: list[Dict[str, Any]] | None = None
     tag: list[str] | None = None
 
-    def dict(self) -> OrderedDict[str, Any]:
+    def dict(self) -> OrderedDict[str, Any] | Dict[str, Any]:
         result: OrderedDict[str, Any] = OrderedDict[str, Any]()
         if self.version_id is not None:
             result["versionId"] = self.version_id

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/fhir/fhir_resource.py

@@ -150,7 +150,7 @@ class FhirResource(CompressedDict[str, Any]):
         """Convert the resource to a JSON string."""
 
         # working_dict preserves the python types so create a fhir friendly version
-        raw_dict: OrderedDict[str, Any] = self.raw_dict()
+        raw_dict: OrderedDict[str, Any] | Dict[str, Any] = self.raw_dict()
 
         raw_dict = FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(
             raw_dict

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/utilities/compressed_dict/v1/compressed_dict.py

@@ -62,10 +62,10 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         self._storage_mode: CompressedDictStorageMode = storage_mode
 
         # Working copy of the dictionary during context
-        self._working_dict: Optional[OrderedDict[K, V]] = None
+        self._working_dict: Optional[OrderedDict[K, V]] | Dict[K, V] = None
 
         # Private storage options
-        self._raw_dict: OrderedDict[K, V] = OrderedDict[K, V]()
+        self._raw_dict: OrderedDict[K, V] | Dict[K, V] = OrderedDict[K, V]()
         self._serialized_dict: Optional[bytes] = None
 
         self._properties_to_cache: List[K] | None = properties_to_cache
@@ -78,13 +78,16 @@ class CompressedDict[K, V](MutableMapping[K, V]):
 
         # Populate initial dictionary if provided
         if initial_dict:
-            # Ensure we use an OrderedDict to maintain original order
-            initial_dict_ordered = (
-                initial_dict
-                if isinstance(initial_dict, OrderedDict)
-                else OrderedDict[K, V](initial_dict)
-            )
-            self.replace(value=initial_dict_ordered)
+            if self._storage_mode.storage_type != "raw":
+                # Ensure we use an OrderedDict to maintain original order
+                initial_dict_ordered = (
+                    initial_dict
+                    if isinstance(initial_dict, OrderedDict)
+                    else OrderedDict[K, V](initial_dict)
+                )
+                self.replace(value=initial_dict_ordered)
+            else:
+                self._update_serialized_dict(current_dict=initial_dict)
 
     @contextmanager
     def transaction(self) -> Iterator["CompressedDict[K, V]"]:
@@ -142,8 +145,8 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         if not self._working_dict:
             self._working_dict = self.create_working_dict()
 
-    def create_working_dict(self) -> OrderedDict[K, V]:
-        working_dict: OrderedDict[K, V]
+    def create_working_dict(self) -> OrderedDict[K, V] | Dict[K, V]:
+        working_dict: OrderedDict[K, V] | Dict[K, V]
         # Deserialize the dictionary before entering the context
         if self._storage_mode.storage_type == "raw":
             # For raw mode, create a deep copy of the existing dictionary
@@ -163,7 +166,9 @@ class CompressedDict[K, V](MutableMapping[K, V]):
 
     @staticmethod
     def _serialize_dict(
-        *, dictionary: OrderedDict[K, V], storage_type: CompressedDictStorageType
+        *,
+        dictionary: OrderedDict[K, V] | Dict[K, V],
+        storage_type: CompressedDictStorageType,
     ) -> bytes:
         """
         Serialize entire dictionary using MessagePack
@@ -247,14 +252,15 @@ class CompressedDict[K, V](MutableMapping[K, V]):
             unpacked_dict,
         )
 
-    def _get_dict(self) -> OrderedDict[K, V]:
+    def _get_dict(self) -> OrderedDict[K, V] | Dict[K, V]:
         """
         Get the dictionary, deserializing if necessary
 
         Returns:
             Current dictionary state
         """
-
+        if self._storage_mode.storage_type == "raw":
+            return self._raw_dict
         if self._working_dict is None:
             raise CompressedDictAccessError(
                 "Dictionary access is only allowed within an transaction() block. "
@@ -262,9 +268,6 @@ class CompressedDict[K, V](MutableMapping[K, V]):
                 f"You tried to access it with storage type {self._storage_mode.storage_type}."
             )
 
-        if self._storage_mode.storage_type == "raw":
-            return self._raw_dict
-
         # For non-raw modes, do not keep deserialized dict
         return self._working_dict
 
@@ -282,11 +285,6 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         if self._properties_to_cache and key in self._properties_to_cache:
             return self._cached_properties[key]
 
-        if self._working_dict is None:
-            raise CompressedDictAccessError(
-                "Dictionary access is only allowed within an transaction() block. "
-                "Use 'with compressed_dict.transaction() as d:' to access the dictionary."
-            )
         return self._get_dict()[key]
 
     def __setitem__(self, key: K, value: V) -> None:
@@ -310,7 +308,9 @@ class CompressedDict[K, V](MutableMapping[K, V]):
             # Update the cached properties if the key is in the list
             self._cached_properties[key] = value
 
-    def _update_serialized_dict(self, current_dict: OrderedDict[K, V] | None) -> None:
+    def _update_serialized_dict(
+        self, current_dict: OrderedDict[K, V] | Dict[K, V] | None
+    ) -> None:
         if current_dict is None:
             self._cached_properties.clear()
             self._length = 0
@@ -425,7 +425,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         """
         return self._get_dict().items()
 
-    def raw_dict(self) -> OrderedDict[K, V]:
+    def raw_dict(self) -> OrderedDict[K, V] | Dict[K, V]:
         """
         Returns the raw dictionary.  Deserializes if necessary.
         Note that this dictionary preserves the python types so it is not FHIR friendly.
@@ -442,7 +442,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
             # in the self._working_dict to keep memory low
             return self.create_working_dict()
 
-    def dict(self) -> OrderedDict[K, V]:
+    def dict(self) -> OrderedDict[K, V] | Dict[K, V]:
         """
         Convert to a FHIR friendly dictionary where the python types like datetime are converted to string versions
         For example, datetime will be represented as a iso format string per FHIR instead of a python datetime object.
@@ -450,18 +450,22 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         Returns:
             FHIR friendly dictionary
         """
-        return cast(
-            OrderedDict[K, V],
-            json.loads(
-                self.json(),
-                object_pairs_hook=lambda pairs: OrderedDict(pairs),
-            ),
+        return (
+            cast(
+                OrderedDict[K, V],
+                json.loads(
+                    self.json(),
+                    object_pairs_hook=lambda pairs: OrderedDict(pairs),
+                ),
+            )
+            if self._storage_mode != CompressedDictStorageMode.raw()
+            else self.raw_dict()
         )
 
     def json(self) -> str:
         """Convert the resource to a JSON string."""
 
-        raw_dict: OrderedDict[K, V] = self.raw_dict()
+        raw_dict: OrderedDict[K, V] | Dict[K, V] = self.raw_dict()
 
         return json.dumps(obj=raw_dict, cls=FhirJSONEncoder)
 
@@ -663,7 +667,10 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         Returns:
             Plain dictionary
         """
-        return OrderedDictToDictConverter.convert(self.raw_dict())
+        if isinstance(self.raw_dict(), OrderedDict):
+            return OrderedDictToDictConverter.convert(self.raw_dict())  # type: ignore[arg-type]
+        else:
+            return self.raw_dict()
 
     @classmethod
     def from_json(cls, json_str: str) -> "CompressedDict[K, V]":

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/utilities/json_helpers.py

@@ -59,19 +59,25 @@ class FhirClientJsonHelpers:
     @staticmethod
     @overload
     def remove_empty_elements_from_ordered_dict(
-        d: List[OrderedDict[str, Any]],
-    ) -> List[OrderedDict[str, Any]]: ...
+        d: List[OrderedDict[str, Any] | Dict[str, Any]],
+    ) -> List[OrderedDict[str, Any] | Dict[str, Any]]: ...
 
     @staticmethod
     @overload
     def remove_empty_elements_from_ordered_dict(
-        d: OrderedDict[str, Any],
-    ) -> OrderedDict[str, Any]: ...
+        d: OrderedDict[str, Any] | Dict[str, Any],
+    ) -> OrderedDict[str, Any] | Dict[str, Any]: ...
 
     @staticmethod
     def remove_empty_elements_from_ordered_dict(
-        d: List[OrderedDict[str, Any]] | OrderedDict[str, Any],
-    ) -> List[OrderedDict[str, Any]] | OrderedDict[str, Any]:
+        d: List[OrderedDict[str, Any] | Dict[str, Any]]
+        | OrderedDict[str, Any]
+        | Dict[str, Any],
+    ) -> (
+        List[OrderedDict[str, Any] | Dict[str, Any]]
+        | OrderedDict[str, Any]
+        | Dict[str, Any]
+    ):
         """
         Recursively remove empty lists, empty dicts, or None elements from a dictionary
         or a list of dictionaries

{compressedfhir-1.0.8 → compressedfhir-1.0.10}/compressedfhir/utilities/test/test_json_helpers.py

@@ -42,18 +42,20 @@ class TestFhirClientJsonHelpers:
             [("a", 1), ("b", ""), ("c", None), ("d", []), ("e", {}), ("f", [1, 2, 3])]
         )
         expected_dict = OrderedDict([("a", 1), ("f", [1, 2, 3])])
-        result: List[OrderedDict[str, Any]] | OrderedDict[str, Any] = (
-            FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(input_dict)
-        )
+        result: (
+            List[OrderedDict[str, Any] | Dict[str, Any]]
+            | OrderedDict[str, Any]
+            | Dict[str, Any]
+        ) = FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(input_dict)
         assert result == expected_dict
 
         # Test list of OrderedDicts
-        input_list: List[OrderedDict[str, Any]] = [
+        input_list: List[OrderedDict[str, Any] | Dict[str, Any]] = [
             OrderedDict([("a", 1), ("b", None)]),
             OrderedDict([("c", []), ("d", "test")]),
             OrderedDict([("e", {})]),
         ]
-        expected_list: List[OrderedDict[str, Any]] = [
+        expected_list: List[OrderedDict[str, Any] | Dict[str, Any]] = [
             OrderedDict([("a", 1)]),
             OrderedDict([("d", "test")]),
         ]

{compressedfhir-1.0.8 → compressedfhir-1.0.10/compressedfhir.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compressedfhir
-Version: 1.0.8
+Version: 1.0.10
 Summary: Stores FHIR JSON resources in compressed form in memory
 Home-page: https://github.com/icanbwell/compressed-fhir
 Author: Imran Qureshi

compressedfhir-1.0.8/VERSION

@@ -1 +0,0 @@
-1.0.8