compressedfhir 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

compressedfhir/fhir/fhir_bundle.py

@@ -13,6 +13,9 @@ from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode im
 )
 from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
 from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+from compressedfhir.utilities.ordered_dict_to_dict_converter.ordered_dict_to_dict_converter import (
+    OrderedDictToDictConverter,
+)
 
 
 class FhirBundle:
@@ -286,6 +289,4 @@ class FhirBundle:
 
         :return: Plain dictionary representation of the Bundle
         """
-        return cast(
-            Dict[str, Any], json.loads(json.dumps(self.dict(), cls=FhirJSONEncoder))
-        )
+        return OrderedDictToDictConverter.convert(self.dict())

compressedfhir/fhir/fhir_bundle_entry.py

@@ -217,7 +217,7 @@ class FhirBundleEntry:
         return (
             f"BundleEntry({self.resource.resource_type}/{self.resource.id})"
             if self.resource
-            else f"BundleEntry(Empty)"
+            else "BundleEntry(Empty)"
         )
 
     def copy(self) -> "FhirBundleEntry":

compressedfhir/fhir/fhir_bundle_entry_response.py

@@ -41,7 +41,6 @@ class FhirBundleEntryResponse:
     def from_dict(
         cls, d: Dict[str, Any] | OrderedDict[str, Any]
     ) -> "FhirBundleEntryResponse":
-
         date_last_modified: Optional[datetime] = None
         if "lastModified" in d:
             if isinstance(d["lastModified"], datetime):

compressedfhir/fhir/fhir_resource.py

@@ -65,17 +65,6 @@ class FhirResource(CompressedDict[str, Any]):
         """Convert the resource to a JSON string."""
         return json.dumps(obj=self.dict(), cls=FhirJSONEncoder)
 
-    @classmethod
-    def from_json(cls, json_str: str) -> "FhirResource":
-        """
-        Create a FhirResource object from a JSON string.
-
-        :param json_str: The JSON string to convert.
-        :return: A FhirResource object.
-        """
-        data = json.loads(json_str)
-        return cls.from_dict(data)
-
     def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirResource":
         """Create a copy of the resource."""
         return FhirResource(
@@ -112,22 +101,6 @@ class FhirResource(CompressedDict[str, Any]):
 
         return result
 
-    @classmethod
-    def from_dict(
-        cls,
-        d: Dict[str, Any],
-        *,
-        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
-    ) -> "FhirResource":
-        """
-        Creates a FhirResource object from a dictionary.
-
-        :param d: The dictionary to convert.
-        :param storage_mode: The storage mode for the CompressedDict.
-        :return: A FhirResource object.
-        """
-        return cls(initial_dict=d, storage_mode=storage_mode)
-
     def remove_nulls(self) -> None:
         """
         Removes None values from the resource dictionary.
@@ -161,3 +134,40 @@ class FhirResource(CompressedDict[str, Any]):
         else:
             assert isinstance(value, FhirMeta)
             self["meta"] = value.dict()
+
+    @classmethod
+    @override
+    def from_json(cls, json_str: str) -> "FhirResource":
+        """
+        Creates a FhirResource object from a JSON string.
+
+        :param json_str: JSON string representing the resource.
+        :return: A FhirResource object.
+        """
+        return cast(FhirResource, super().from_json(json_str=json_str))
+
+    @classmethod
+    @override
+    def from_dict(
+        cls,
+        d: Dict[str, Any],
+        *,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
+        properties_to_cache: List[str] | None = None,
+    ) -> "FhirResource":
+        """
+        Creates a FhirResource object from a dictionary.
+
+        :param d: Dictionary representing the resource.
+        :param storage_mode: Storage mode for the CompressedDict.
+        :param properties_to_cache: List of properties to cache.
+        :return: A FhirResource object.
+        """
+        return cast(
+            FhirResource,
+            super().from_dict(
+                d=d,
+                storage_mode=storage_mode,
+                properties_to_cache=properties_to_cache,
+            ),
+        )

compressedfhir/fhir/fhir_resource_list.py

@@ -103,7 +103,7 @@ class FhirResourceList(BaseResourceList[FhirResource]):
         if len(self) == 0:
             return resources_by_type
 
-        entry: FhirResource
+        resource: FhirResource
         for resource in [r for r in self if r is not None]:
             resource_type: str = resource.resource_type or "unknown"
             if resource_type not in resources_by_type:

compressedfhir/utilities/compressed_dict/v1/compressed_dict.py

@@ -1,5 +1,4 @@
 import copy
-import json
 from collections.abc import KeysView, ValuesView, ItemsView, MutableMapping
 from contextlib import contextmanager
 from typing import Dict, Optional, Iterator, cast, List, Any, overload, OrderedDict
@@ -14,7 +13,12 @@ from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode im
     CompressedDictStorageMode,
     CompressedDictStorageType,
 )
-from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
+from compressedfhir.utilities.json_serializers.type_preservation_serializer import (
+    TypePreservationSerializer,
+)
+from compressedfhir.utilities.ordered_dict_to_dict_converter.ordered_dict_to_dict_converter import (
+    OrderedDictToDictConverter,
+)
 
 
 class CompressedDict[K, V](MutableMapping[K, V]):
@@ -146,7 +150,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
             # For serialized modes, deserialize
             working_dict = (
                 self._deserialize_dict(
-                    serialized_dict=self._serialized_dict,
+                    serialized_dict_bytes=self._serialized_dict,
                     storage_type=self._storage_mode.storage_type,
                 )
                 if self._serialized_dict
@@ -172,9 +176,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         assert isinstance(dictionary, OrderedDict)
         if storage_type == "compressed":
             # Serialize to JSON and compress with zlib
-            json_str = json.dumps(
-                dictionary, separators=(",", ":"), cls=FhirJSONEncoder
-            )  # Most compact JSON representation
+            json_str = TypePreservationSerializer.serialize(dictionary)
             return zlib.compress(
                 json_str.encode("utf-8"), level=zlib.Z_BEST_COMPRESSION
             )
@@ -195,34 +197,35 @@ class CompressedDict[K, V](MutableMapping[K, V]):
     @staticmethod
     def _deserialize_dict(
         *,
-        serialized_dict: bytes,
+        serialized_dict_bytes: bytes,
         storage_type: CompressedDictStorageType,
     ) -> OrderedDict[K, V]:
         """
         Deserialize entire dictionary from MessagePack
 
         Args:
-            serialized_dict: Serialized dictionary bytes
+            serialized_dict_bytes: Serialized dictionary bytes
 
         Returns:
             Deserialized dictionary
         """
-        assert serialized_dict is not None, "Serialized dictionary cannot be None"
+        assert serialized_dict_bytes is not None, "Serialized dictionary cannot be None"
+        assert isinstance(serialized_dict_bytes, bytes)
 
         if storage_type == "compressed":
             # Decompress and parse JSON
-            decompressed = zlib.decompress(serialized_dict)
-            decoded_text = decompressed.decode("utf-8")
+            decompressed_bytes: bytes = zlib.decompress(serialized_dict_bytes)
+            decoded_text: str = decompressed_bytes.decode("utf-8")
             # noinspection PyTypeChecker
-            decompressed_dict = json.loads(decoded_text, object_pairs_hook=OrderedDict)
+            decompressed_dict = TypePreservationSerializer.deserialize(decoded_text)
             assert isinstance(decompressed_dict, OrderedDict)
             return cast(OrderedDict[K, V], decompressed_dict)
 
         # Decompress if needed
         to_unpack = (
-            zlib.decompress(serialized_dict)
+            zlib.decompress(serialized_dict_bytes)
             if storage_type == "compressed_msgpack"
-            else serialized_dict
+            else serialized_dict_bytes
         )
 
         # Deserialize
@@ -630,6 +633,37 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         Returns:
             Plain dictionary
         """
-        return cast(
-            Dict[K, V], json.loads(json.dumps(self.dict(), cls=FhirJSONEncoder))
+        return OrderedDictToDictConverter.convert(self.dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "CompressedDict[K, V]":
+        """
+        Create a FhirResource object from a JSON string.
+
+        :param json_str: The JSON string to convert.
+        :return: A FhirResource object.
+        """
+        data = TypePreservationSerializer.deserialize(json_str)
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_dict(
+        cls,
+        d: Dict[K, V],
+        *,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
+        properties_to_cache: List[K] | None = None,
+    ) -> "CompressedDict[K, V]":
+        """
+        Creates a FhirResource object from a dictionary.
+
+        :param d: The dictionary to convert.
+        :param storage_mode: The storage mode for the CompressedDict.
+        :param properties_to_cache: Optional list of properties to cache
+        :return: A FhirResource object.
+        """
+        return cls(
+            initial_dict=d,
+            storage_mode=storage_mode,
+            properties_to_cache=properties_to_cache,
         )

compressedfhir/utilities/compressed_dict/v1/compressed_dict_storage_mode.py

@@ -4,13 +4,13 @@ from typing import Literal, TypeAlias
 CompressedDictStorageType: TypeAlias = Literal[
     "raw", "compressed", "msgpack", "compressed_msgpack"
 ]
-"""
-CompressedDictStorageType is a type alias for the different storage types
-raw: No compression
-compressed: Compressed using zlib
-msgpack: Compressed using msgpack
-compressed_msgpack: Compressed using msgpack with zlib
-"""
+###
+# CompressedDictStorageType is a type alias for the different storage types
+# raw: No compression
+# compressed: Compressed using zlib
+# msgpack: Compressed using msgpack
+# compressed_msgpack: Compressed using msgpack with zlib
+###
 
 
 @dataclasses.dataclass(slots=True)

compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 import pytest
 from typing import Any, cast
 
@@ -358,3 +360,108 @@ def test_transaction_error_handling() -> None:
         # Verify the dictionary state remains unchanged
         with compressed_dict.transaction() as d:
             assert d.dict() == {"key1": "value1", "key2": "value2"}
+
+
+def test_nested_dict_with_datetime() -> None:
+    nested_dict = {
+        "beneficiary": {"reference": "Patient/1234567890123456703", "type": "Patient"},
+        "class": [
+            {
+                "name": "Aetna Plan",
+                "type": {
+                    "coding": [
+                        {
+                            "code": "plan",
+                            "display": "Plan",
+                            "system": "http://terminology.hl7.org/CodeSystem/coverage-class",
+                        }
+                    ]
+                },
+                "value": "AE303",
+            }
+        ],
+        "costToBeneficiary": [
+            {
+                "type": {"text": "Annual Physical Exams NMC - In Network"},
+                "valueQuantity": {
+                    "system": "http://aetna.com/Medicare/CostToBeneficiary/ValueQuantity/code",
+                    "unit": "$",
+                    "value": 50.0,
+                },
+            }
+        ],
+        "id": "3456789012345670304",
+        "identifier": [
+            {
+                "system": "https://sources.aetna.com/coverage/identifier/membershipid/59",
+                "type": {
+                    "coding": [
+                        {
+                            "code": "SN",
+                            "system": "http://terminology.hl7.org/CodeSystem/v2-0203",
+                        }
+                    ]
+                },
+                "value": "435679010300+AE303+2021-01-01",
+            },
+            {
+                "id": "uuid",
+                "system": "https://www.icanbwell.com/uuid",
+                "value": "92266603-aa8b-58c6-99bd-326fd1da1896",
+            },
+        ],
+        "meta": {
+            "security": [
+                {"code": "aetna", "system": "https://www.icanbwell.com/owner"},
+                {"code": "aetna", "system": "https://www.icanbwell.com/access"},
+                {"code": "aetna", "system": "https://www.icanbwell.com/vendor"},
+                {"code": "proa", "system": "https://www.icanbwell.com/connectionType"},
+            ],
+            "source": "http://mock-server:1080/test_patient_access_transformer/source/4_0_0/Coverage/3456789012345670304",
+        },
+        "network": "Medicare - MA/NY/NJ - Full Reciprocity",
+        "payor": [
+            {
+                "display": "Aetna",
+                "reference": "Organization/6667778889990000015",
+                "type": "Organization",
+            }
+        ],
+        "period": {
+            "end": datetime.fromisoformat("2021-12-31").date(),
+            "start": datetime.fromisoformat("2021-01-01").date(),
+        },
+        "policyHolder": {"reference": "Patient/1234567890123456703", "type": "Patient"},
+        "relationship": {
+            "coding": [
+                {
+                    "code": "self",
+                    "system": "http://terminology.hl7.org/CodeSystem/subscriber-relationship",
+                }
+            ]
+        },
+        "resourceType": "Coverage",
+        "status": "active",
+        "subscriber": {"reference": "Patient/1234567890123456703", "type": "Patient"},
+        "subscriberId": "435679010300",
+        "type": {
+            "coding": [
+                {
+                    "code": "PPO",
+                    "display": "preferred provider organization policy",
+                    "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
+                }
+            ]
+        },
+    }
+
+    compressed_dict = CompressedDict(
+        initial_dict=nested_dict,
+        storage_mode=CompressedDictStorageMode.compressed(),
+        properties_to_cache=[],
+    )
+
+    plain_dict = compressed_dict.to_plain_dict()
+
+    assert plain_dict["period"]["start"] == nested_dict["period"]["start"]  # type: ignore[index]
+    assert plain_dict == nested_dict

compressedfhir/utilities/fhir_json_encoder.py

@@ -18,7 +18,7 @@ class FhirJSONEncoder(json.JSONEncoder):
     def default(self, o: Any) -> Any:
         # Existing type handlers
         if dataclasses.is_dataclass(o):
-            return dataclasses.asdict(o)  # type:ignore
+            return dataclasses.asdict(o)  # type:ignore[arg-type]
 
         if isinstance(o, Enum):
             return o.value

compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py

@@ -0,0 +1,150 @@
+from datetime import datetime, date
+from decimal import Decimal
+from typing import Type, Any, Dict, Optional
+import pytest
+
+from compressedfhir.utilities.json_serializers.type_preservation_decoder import (
+    TypePreservationDecoder,
+)
+
+
+class TestCustomObject:
+    def __init__(
+        self,
+        name: str,
+        value: int,
+        created_at: Optional[datetime] = None,
+        nested_data: Optional[Dict[str, Any]] = None,
+    ):
+        self.name: str = name
+        self.value: int = value
+        self.created_at: Optional[datetime] = created_at
+        self.nested_data: Optional[Dict[str, Any]] = nested_data
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, TestCustomObject):
+            return False
+        return (
+            self.name == other.name
+            and self.value == other.value
+            and self.created_at == other.created_at
+            and self.nested_data == other.nested_data
+        )
+
+
+@pytest.mark.parametrize(
+    "input_type, input_dict, expected_type",
+    [
+        (
+            "datetime",
+            {"__type__": "datetime", "iso": "2023-01-01T00:00:00+00:00"},
+            datetime,
+        ),
+        ("date", {"__type__": "date", "iso": "2023-01-01"}, date),
+        ("decimal", {"__type__": "decimal", "value": "3.14"}, Decimal),
+        ("complex", {"__type__": "complex", "real": 3, "imag": 4}, complex),
+        ("bytes", {"__type__": "bytes", "value": "test"}, bytes),
+        ("set", {"__type__": "set", "values": [1, 2, 3]}, set),
+    ],
+)
+def test_complex_type_decoding(
+    input_type: str, input_dict: Dict[str, Any], expected_type: Type[Any]
+) -> None:
+    """
+    Test decoding of various complex types
+    """
+    decoded = TypePreservationDecoder.decode(input_dict)
+    assert isinstance(decoded, expected_type)
+
+
+def test_custom_object_decoding() -> None:
+    """
+    Test decoding of custom objects
+    """
+    custom_obj_dict = {
+        "__type__": "TestCustomObject",
+        "__module__": __name__,
+        "attributes": {"name": "test", "value": 42},
+    }
+    decoded = TypePreservationDecoder.decode(custom_obj_dict)
+    assert isinstance(decoded, TestCustomObject)
+    assert decoded.name == "test"
+    assert decoded.value == 42
+
+
+def test_custom_decoder() -> None:
+    """
+    Test custom decoder functionality
+    """
+
+    def custom_decoder(data: Dict[str, Any]) -> Any:
+        if data.get("__type__") == "special_type":
+            return f"Decoded: {data['value']}"
+        return data
+
+    special_dict = {"__type__": "special_type", "value": "test"}
+    decoded = TypePreservationDecoder.decode(
+        special_dict, custom_decoders={"special_type": custom_decoder}
+    )
+    assert decoded == "Decoded: test"
+
+
+def test_nested_datetime_decoding() -> None:
+    """
+    Test decoding of nested datetime fields
+    """
+    nested_datetime_dict = {
+        "__type__": "TestCustomObject",
+        "__module__": __name__,
+        "attributes": {
+            "name": "test",
+            "value": 42,
+            "created_at": {"__type__": "datetime", "iso": "2023-06-15T10:30:00"},
+            "nested_data": {
+                "timestamp": {"__type__": "datetime", "iso": "2023-06-16T15:45:00"}
+            },
+        },
+    }
+
+    decoded: TestCustomObject = TypePreservationDecoder.decode(nested_datetime_dict)
+
+    assert isinstance(decoded, TestCustomObject)
+    assert decoded.name == "test"
+    assert decoded.value == 42
+
+    # Check nested datetime fields
+    assert hasattr(decoded, "created_at")
+    assert isinstance(decoded.created_at, datetime)
+    assert decoded.created_at.year == 2023
+    assert decoded.created_at.month == 6
+    assert decoded.created_at.day == 15
+
+    assert hasattr(decoded, "nested_data")
+    assert isinstance(decoded.nested_data, dict)
+    assert "timestamp" in decoded.nested_data
+    assert isinstance(decoded.nested_data["timestamp"], datetime)
+    assert decoded.nested_data["timestamp"].year == 2023
+    assert decoded.nested_data["timestamp"].month == 6
+    assert decoded.nested_data["timestamp"].day == 16
+
+
+def test_direct_value_decoding() -> None:
+    """
+    Test decoding of direct values without type markers
+    """
+    # Test datetime direct string
+    datetime_str = "2023-01-01T00:00:00"
+    decoded_datetime = TypePreservationDecoder.decode(datetime_str)
+    assert decoded_datetime == datetime_str
+
+    # Test list with mixed types
+    mixed_list = [
+        {"__type__": "datetime", "iso": "2023-06-15T10:30:00"},
+        42,
+        "plain string",
+    ]
+    decoded_list = TypePreservationDecoder.decode(mixed_list)
+    assert len(decoded_list) == 3
+    assert isinstance(decoded_list[0], datetime)
+    assert decoded_list[1] == 42
+    assert decoded_list[2] == "plain string"

compressedfhir/utilities/json_serializers/test/test_type_preservation_encoder.py

@@ -0,0 +1,59 @@
+from datetime import datetime, timezone, date
+from decimal import Decimal
+from typing import Type, Any
+
+import pytest
+
+from compressedfhir.utilities.json_serializers.type_preservation_encoder import (
+    TypePreservationEncoder,
+)
+
+
+class TestCustomObject:
+    def __init__(self, name: str, value: int):
+        self.name: str = name
+        self.value: int = value
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, TestCustomObject):
+            return False
+        return self.name == other.name and self.value == other.value
+
+
+@pytest.mark.parametrize(
+    "input_type, input_value, expected_type",
+    [
+        (datetime, datetime(2023, 1, 1, tzinfo=timezone.utc), "datetime"),
+        (date, date(2023, 1, 1), "date"),
+        (Decimal, Decimal("3.14"), "decimal"),
+        (complex, 3 + 4j, "complex"),
+        (bytes, b"test", "bytes"),
+        (set, {1, 2, 3}, "set"),
+    ],
+)
+def test_complex_type_serialization(
+    input_type: Type[Any], input_value: Any, expected_type: str
+) -> None:
+    """
+    Test serialization of various complex types
+    """
+    encoder = TypePreservationEncoder()
+    serialized = encoder.default(input_value)
+
+    assert isinstance(serialized, dict)
+    assert serialized.get("__type__") == expected_type
+
+
+# noinspection PyMethodMayBeStatic
+def test_custom_object_serialization() -> None:
+    """
+    Test serialization of custom objects
+    """
+    custom_obj = TestCustomObject("test", 42)
+    encoder = TypePreservationEncoder()
+    serialized = encoder.default(custom_obj)
+
+    assert isinstance(serialized, dict)
+    assert serialized.get("__type__") == "TestCustomObject"
+    assert serialized.get("__module__") == __name__
+    assert "attributes" in serialized