compressedfhir 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

compressedfhir/fhir/fhir_resource.py

@@ -61,14 +61,10 @@ class FhirResource(CompressedDict[str, Any]):
             else None
         )
 
-    def json(self) -> str:
-        """Convert the resource to a JSON string."""
-        return json.dumps(obj=self.dict(), cls=FhirJSONEncoder)
-
     def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirResource":
         """Create a copy of the resource."""
         return FhirResource(
-            initial_dict=super().dict(),
+            initial_dict=super().raw_dict(),
             storage_mode=self._storage_mode,
         )
 
@@ -84,29 +80,6 @@ class FhirResource(CompressedDict[str, Any]):
         """
         return copy.deepcopy(self)
 
-    @override
-    def dict(self, *, remove_nulls: bool = True) -> OrderedDict[str, Any]:
-        """
-        Converts the FhirResource object to a dictionary.
-
-        :param remove_nulls: If True, removes None values from the dictionary.
-        :return: A dictionary representation of the FhirResource object.
-        """
-        ordered_dict = super().dict()
-        result: OrderedDict[str, Any] = copy.deepcopy(ordered_dict)
-        if remove_nulls:
-            result = FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(
-                result
-            )
-
-        return result
-
-    def remove_nulls(self) -> None:
-        """
-        Removes None values from the resource dictionary.
-        """
-        self.replace(value=self.dict(remove_nulls=True))
-
     @property
     def id(self) -> Optional[str]:
         """Get the ID from the resource dictionary."""
@@ -171,3 +144,15 @@ class FhirResource(CompressedDict[str, Any]):
                 properties_to_cache=properties_to_cache,
             ),
         )
+
+    @override
+    def json(self) -> str:
+        """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 = FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(
+            raw_dict
+        )
+        return json.dumps(obj=raw_dict, cls=FhirJSONEncoder)

compressedfhir/fhir/fhir_resource_map.py

@@ -43,7 +43,7 @@ class FhirResourceMap:
         """
         result: OrderedDict[str, Any] = OrderedDict[str, Any]()
         for key, value in self._resource_map.items():
-            result[key] = [resource.dict(remove_nulls=True) for resource in value]
+            result[key] = [resource.dict() for resource in value]
         return result
 
     def get(self, *, resource_type: str) -> Optional[FhirResourceList]:

compressedfhir/fhir/test/test_fhir_resource.py

@@ -102,124 +102,3 @@ class TestFhirResource:
         assert parsed_json == initial_data
         assert "resourceType" in parsed_json
         assert "id" in parsed_json
-
-
-class TestFhirResourceRemoveNulls:
-    def test_remove_nulls_simple_dict(self) -> None:
-        """
-        Test removing None values from a simple dictionary
-        """
-        initial_dict: Dict[str, Any] = {
-            "name": "John Doe",
-            "age": None,
-            "active": True,
-            "email": None,
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            # Check that None values are removed
-            assert "age" not in resource
-            assert "email" not in resource
-            assert resource.get("name") == "John Doe"
-            assert resource.get("active") is True
-
-    def test_remove_nulls_nested_dict(self) -> None:
-        """
-        Test removing None values from a nested dictionary
-        """
-        initial_dict: Dict[str, Any] = {
-            "patient": {
-                "name": "Jane Smith",
-                "contact": None,
-                "address": {"street": None, "city": "New York"},
-            },
-            "status": None,
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert "status" not in resource
-            assert "contact" not in resource.get("patient", {})
-            assert resource.get("patient", {}).get("address", {}).get("street") is None
-            assert (
-                resource.get("patient", {}).get("address", {}).get("city") == "New York"
-            )
-
-    def test_remove_nulls_list_of_dicts(self) -> None:
-        """
-        Test removing None values from a list of dictionaries
-        """
-        initial_dict: Dict[str, Any] = {
-            "patients": [
-                {"name": "Alice", "age": None},
-                {"name": "Bob", "age": 30},
-                {"name": None, "active": False},
-            ]
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert len(resource.get("patients", [])) == 3
-            assert resource.get("patients", [])[0].get("name") == "Alice"
-            assert resource.get("patients", [])[1].get("name") == "Bob"
-            assert resource.get("patients", [])[1].get("age") == 30
-
-    def test_remove_nulls_empty_dict(self) -> None:
-        """
-        Test removing None values from an empty dictionary
-        """
-        resource = FhirResource(initial_dict={})
-        resource.remove_nulls()
-
-        assert len(resource) == 0
-
-    def test_remove_nulls_no_changes(self) -> None:
-        """
-        Test removing None values when no None values exist
-        """
-        initial_dict: Dict[str, Any] = {
-            "name": "Test User",
-            "active": True,
-            "score": 100,
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        original_dict = resource.copy()
-        resource.remove_nulls()
-
-        assert resource == original_dict
-
-    def test_remove_nulls_with_custom_storage_mode(self) -> None:
-        """
-        Test removing None values with a custom storage mode
-        """
-        initial_dict: Dict[str, Any] = {
-            "name": "Custom Mode User",
-            "email": None,
-            "active": True,
-        }
-        resource = FhirResource(
-            initial_dict=initial_dict, storage_mode=CompressedDictStorageMode.default()
-        )
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert "email" not in resource
-            assert resource.get("name") == "Custom Mode User"
-            assert resource.get("active") is True
-
-    def test_remove_nulls_preserves_false_and_zero_values(self) -> None:
-        """
-        Test that False and 0 values are not removed
-        """
-        initial_dict: Dict[str, Any] = {"active": False, "score": 0, "name": None}
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert resource.get("active") is False
-            assert resource.get("score") == 0
-            assert "name" not in resource

compressedfhir/utilities/compressed_dict/v1/compressed_dict.py

@@ -1,4 +1,5 @@
 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
@@ -13,6 +14,7 @@ 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,
 )
@@ -176,9 +178,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 = TypePreservationSerializer.serialize(
-                dictionary, separators=(",", ":")
-            )
+            json_str = TypePreservationSerializer.serialize(dictionary)
             return zlib.compress(
                 json_str.encode("utf-8"), level=zlib.Z_BEST_COMPRESSION
             )
@@ -219,9 +219,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
             decompressed_bytes: bytes = zlib.decompress(serialized_dict_bytes)
             decoded_text: str = decompressed_bytes.decode("utf-8")
             # noinspection PyTypeChecker
-            decompressed_dict = TypePreservationSerializer.deserialize(
-                decoded_text, object_pairs_hook=OrderedDict
-            )
+            decompressed_dict = TypePreservationSerializer.deserialize(decoded_text)
             assert isinstance(decompressed_dict, OrderedDict)
             return cast(OrderedDict[K, V], decompressed_dict)
 
@@ -427,19 +425,43 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         """
         return self._get_dict().items()
 
-    def dict(self, *, remove_nulls: bool = True) -> OrderedDict[K, V]:
+    def raw_dict(self) -> OrderedDict[K, V]:
         """
-        Convert to a standard dictionary
+        Returns the raw dictionary.  Deserializes if necessary.
+        Note that this dictionary preserves the python types so it is not FHIR friendly.
+        Use dict() if you want a FHIR friendly version.
 
         Returns:
-            Standard dictionary with all values
+            raw dictionary
         """
         if self._working_dict:
             return self._working_dict
         else:
-            # if the working dict is None, return it but don't store it in the self._working_dict to keep memory low
+            # if the working dict is not None, return it but don't store it in the self._working_dict to keep memory low
             return self.create_working_dict()
 
+    def dict(self) -> OrderedDict[K, V]:
+        """
+        Convert to a FHIR friendly dictionary where the python types like datetime are converted to string versions
+
+        Returns:
+            FHIR friendly dictionary
+        """
+        return cast(
+            OrderedDict[K, V],
+            json.loads(
+                self.json(),
+                object_pairs_hook=lambda pairs: OrderedDict(pairs),
+            ),
+        )
+
+    def json(self) -> str:
+        """Convert the resource to a JSON string."""
+
+        raw_dict: OrderedDict[K, V] = self.raw_dict()
+
+        return json.dumps(obj=raw_dict, cls=FhirJSONEncoder)
+
     def __repr__(self) -> str:
         """
         String representation of the dictionary
@@ -563,7 +585,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         """
         # Create a new instance with the same storage mode
         new_instance = CompressedDict(
-            initial_dict=copy.deepcopy(self.dict()),
+            initial_dict=copy.deepcopy(self.raw_dict()),
             storage_mode=self._storage_mode,
             properties_to_cache=self._properties_to_cache,
         )
@@ -637,7 +659,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         Returns:
             Plain dictionary
         """
-        return OrderedDictToDictConverter.convert(self.dict())
+        return OrderedDictToDictConverter.convert(self.raw_dict())
 
     @classmethod
     def from_json(cls, json_str: str) -> "CompressedDict[K, V]":

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
 
@@ -232,7 +234,7 @@ def test_transaction_basic_raw_storage() -> None:
 
     # After transaction
     assert compressed_dict._transaction_depth == 0
-    assert compressed_dict.dict() == {
+    assert compressed_dict.raw_dict() == {
         "key1": "value1",
         "key2": "value2",
         "key3": "value3",
@@ -260,7 +262,7 @@ def test_transaction_nested_context() -> None:
         assert compressed_dict._transaction_depth == 1
 
     assert compressed_dict._transaction_depth == 0
-    assert compressed_dict.dict() == {"key1": "value1", "key2": "value2"}
+    assert compressed_dict.raw_dict() == {"key1": "value1", "key2": "value2"}
 
 
 def test_transaction_access_error() -> None:
@@ -309,7 +311,7 @@ def test_transaction_different_storage_modes() -> None:
         with compressed_dict.transaction() as d:
             d["key2"] = "value2"
 
-        assert compressed_dict.dict() == {"key1": "value1", "key2": "value2"}
+        assert compressed_dict.raw_dict() == {"key1": "value1", "key2": "value2"}
 
 
 def test_transaction_with_properties_to_cache() -> None:
@@ -328,7 +330,7 @@ def test_transaction_with_properties_to_cache() -> None:
     with compressed_dict.transaction() as d:
         d["key2"] = "value2"
 
-    assert compressed_dict.dict() == {
+    assert compressed_dict.raw_dict() == {
         "key1": "value1",
         "important_prop": "cached_value",
         "key2": "value2",
@@ -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/json_serializers/test/test_type_preservation_decoder.py

@@ -1,7 +1,6 @@
 from datetime import datetime, date
 from decimal import Decimal
-from typing import Type, Any, Dict
-
+from typing import Type, Any, Dict, Optional
 import pytest
 
 from compressedfhir.utilities.json_serializers.type_preservation_decoder import (
@@ -10,14 +9,27 @@ from compressedfhir.utilities.json_serializers.type_preservation_decoder import
 
 
 class TestCustomObject:
-    def __init__(self, name: str, value: int):
+    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
+        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(
@@ -42,7 +54,6 @@ def test_complex_type_decoding(
     Test decoding of various complex types
     """
     decoded = TypePreservationDecoder.decode(input_dict)
-
     assert isinstance(decoded, expected_type)
 
 
@@ -55,9 +66,7 @@ def test_custom_object_decoding() -> None:
         "__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
@@ -74,9 +83,68 @@ def test_custom_decoder() -> None:
         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_serializer.py

@@ -1,5 +1,7 @@
+import logging
 from datetime import datetime, timezone, date
 from decimal import Decimal
+from logging import Logger
 from typing import Any
 
 from compressedfhir.utilities.json_serializers.type_preservation_serializer import (
@@ -58,3 +60,112 @@ def test_nested_complex_data() -> None:
     deserialized = TypePreservationSerializer.deserialize(serialized)
 
     assert isinstance(deserialized["level1"]["level2"]["timestamp"], datetime)
+
+
+def test_nested_dict() -> None:
+    """
+    Test serialization of nested dictionaries
+    """
+    logger: Logger = logging.getLogger(__name__)
+    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",
+                }
+            ]
+        },
+    }
+
+    logger.info("-------- Serialized --------")
+    serialized = TypePreservationSerializer.serialize(nested_dict)
+    logger.info(serialized)
+    logger.info("-------- Deserialized --------")
+    deserialized = TypePreservationSerializer.deserialize(serialized)
+    logger.info(deserialized)
+
+    assert isinstance(deserialized["period"]["start"], date)
+    assert isinstance(deserialized["period"]["end"], date)
+    assert nested_dict == deserialized

compressedfhir/utilities/json_serializers/type_preservation_decoder.py

@@ -1,63 +1,110 @@
+import logging
+from collections import OrderedDict
 from datetime import datetime, date
 from decimal import Decimal
-from typing import Any, Dict, Callable
+from logging import Logger
+from typing import Any, Dict, Callable, Optional, Union, cast, List
 
 
 class TypePreservationDecoder:
     """
-    Advanced JSON decoder for complex type reconstruction
+    Advanced JSON decoder for complex type reconstruction with nested type support
     """
 
     @classmethod
     def decode(
         cls,
-        dct: Dict[str, Any],
-        custom_decoders: Dict[str, Callable[[Any], Any]] | None = None,
+        dct: Union[str, Dict[str, Any], List[Any]],
+        custom_decoders: Optional[Dict[str, Callable[[Any], Any]]] = None,
+        use_ordered_dict: bool = True,
     ) -> Any:
         """
-        Decode complex types
+        Decode complex types, including nested datetime fields
 
         Args:
             dct: Dictionary to decode
             custom_decoders: Optional additional custom decoders
+            use_ordered_dict: Flag to control whether to use OrderedDict or not
 
         Returns:
             Reconstructed object or original dictionary
         """
-        # Default decoders for built-in types
+        logger: Logger = logging.getLogger(__name__)
+
+        # Default decoders for built-in types with nested support
+        def datetime_decoder(d: Union[str, Dict[str, Any]]) -> datetime:
+            if isinstance(d, str):
+                return datetime.fromisoformat(d)
+            elif isinstance(d, dict) and "iso" in d:
+                return datetime.fromisoformat(d["iso"])
+            return cast(datetime, d)
+
+        def date_decoder(d: Union[str, Dict[str, Any]]) -> date:
+            if isinstance(d, str):
+                return date.fromisoformat(d)
+            elif isinstance(d, dict) and "iso" in d:
+                return date.fromisoformat(d["iso"])
+            return cast(date, d)
+
         default_decoders: Dict[str, Callable[[Any], Any]] = {
-            "datetime": lambda d: datetime.fromisoformat(d["iso"]),
-            "date": lambda d: date.fromisoformat(d["iso"]),
-            "decimal": lambda d: Decimal(d["value"]),
-            "complex": lambda d: complex(d["real"], d["imag"]),
-            "bytes": lambda d: d["value"].encode("latin-1"),
-            "set": lambda d: set(d["values"]),
+            "datetime": datetime_decoder,
+            "date": date_decoder,
+            "decimal": lambda d: Decimal(d["value"] if isinstance(d, dict) else d),
+            "complex": lambda d: complex(d["real"], d["imag"])
+            if isinstance(d, dict)
+            else d,
+            "bytes": lambda d: d["value"].encode("latin-1")
+            if isinstance(d, dict)
+            else d,
+            "set": lambda d: set(d["values"]) if isinstance(d, dict) else d,
         }
 
         # Merge custom decoders with default decoders
         decoders = {**default_decoders, **(custom_decoders or {})}
 
-        # Check for type marker
-        if "__type__" in dct:
-            type_name = dct["__type__"]
-
-            # Handle built-in type decoders
-            if type_name in decoders:
-                return decoders[type_name](dct)
-
-            # Handle custom object reconstruction
-            if "__module__" in dct and "attributes" in dct:
-                try:
-                    # Dynamically import the class
-                    module = __import__(dct["__module__"], fromlist=[type_name])
-                    cls_ = getattr(module, type_name)
-
-                    # Create instance and set attributes
-                    obj = cls_.__new__(cls_)
-                    obj.__dict__.update(dct["attributes"])
-                    return obj
-                except (ImportError, AttributeError) as e:
-                    print(f"Could not reconstruct {type_name}: {e}")
-                    return dct
-
-        return dct
+        # Recursively decode nested structures
+        def recursive_decode(value: Any) -> Any:
+            if isinstance(value, dict):
+                # Check for type marker in the dictionary
+                if "__type__" in value:
+                    type_name = value["__type__"]
+
+                    # Handle built-in type decoders
+                    if type_name in decoders:
+                        return decoders[type_name](value)
+
+                    # Handle custom object reconstruction
+                    if "__module__" in value and "attributes" in value:
+                        try:
+                            # Dynamically import the class
+                            module = __import__(
+                                value["__module__"], fromlist=[type_name]
+                            )
+                            cls_ = getattr(module, type_name)
+
+                            # Create instance and set attributes with recursive decoding
+                            obj = cls_.__new__(cls_)
+                            obj.__dict__.update(
+                                {
+                                    k: recursive_decode(v)
+                                    for k, v in value["attributes"].items()
+                                }
+                            )
+                            return obj
+                        except (ImportError, AttributeError) as e:
+                            logger.error(f"Could not reconstruct {type_name}: {e}")
+                            return value
+
+                # Recursively decode dictionary values
+                # Conditionally use OrderedDict or regular dict
+                dict_type = OrderedDict if use_ordered_dict else dict
+                return dict_type((k, recursive_decode(v)) for k, v in value.items())
+
+            # Recursively decode list or tuple
+            elif isinstance(value, (list, tuple)):
+                return type(value)(recursive_decode(item) for item in value)
+
+            return value
+
+        # Start recursive decoding
+        return recursive_decode(dct)

compressedfhir/utilities/json_serializers/type_preservation_serializer.py

@@ -26,7 +26,9 @@ class TypePreservationSerializer:
         Returns:
             JSON string representation
         """
-        return json.dumps(data, cls=TypePreservationEncoder, indent=2, **kwargs)
+        return json.dumps(
+            data, cls=TypePreservationEncoder, separators=(",", ":"), **kwargs
+        )
 
     @classmethod
     def deserialize(

{compressedfhir-1.0.3.dist-info → compressedfhir-1.0.5.dist-info}/METADATA

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

{compressedfhir-1.0.3.dist-info → compressedfhir-1.0.5.dist-info}/RECORD

@@ -11,16 +11,16 @@ compressedfhir/fhir/fhir_bundle_entry_search.py,sha256=uYVJxuNN3gt3Q6BZ5FhRs47x7
 compressedfhir/fhir/fhir_identifier.py,sha256=tA_nmhBaYHu5zjJdE0IWMFEF8lrIPV3_nu-yairiIKw,2711
 compressedfhir/fhir/fhir_link.py,sha256=jf2RrwmsPrKW3saP77y42xVqI0xwHFYXxm6YHQJk7gU,1922
 compressedfhir/fhir/fhir_meta.py,sha256=vNI4O6SoG4hJRHyd-bJ_QnYFTfBHyR3UA6h21ByQmWo,1669
-compressedfhir/fhir/fhir_resource.py,sha256=GIz0g8O-Nw9Av8M5wYRoRY4FS2kEk2Nb03RPSeDYUqo,5588
+compressedfhir/fhir/fhir_resource.py,sha256=5v_xcAUCFcqzQodT8uiw292NUG86gWJ4UbyhY2Vy79c,5084
 compressedfhir/fhir/fhir_resource_list.py,sha256=qlAAwWWphtFicBxPG8iriz2eOHGcrWJk5kGThmvkbPE,4480
-compressedfhir/fhir/fhir_resource_map.py,sha256=6Zt_K8KVolS-lgT_Ztu_6YxNo8BXhweQfWO-QFriInA,6588
+compressedfhir/fhir/fhir_resource_map.py,sha256=XFJ0o5_kLUeHYKp1q_Bxsoyp2-rLX7P4c9FwQ7YfGWM,6571
 compressedfhir/fhir/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 compressedfhir/fhir/test/test_bundle_entry.py,sha256=Ki2sSu1V1WZkAM6UTCghtzjvjYYI8UcF6AXnx8FWlMI,5115
 compressedfhir/fhir/test/test_bundle_entry_list.py,sha256=KtMrbQYezdEw9FJbBzwSePdJK2R9P03mSRfo59T-6iM,6041
 compressedfhir/fhir/test/test_bundle_entry_request.py,sha256=9bN3Vt9BAXPLjH7FFt_MYSdanFJzWk9HbA0C9kZxPXY,2853
 compressedfhir/fhir/test/test_bundle_entry_response.py,sha256=jk5nUi07_q-yz-qz2YR86vU91e3DVxc2cptrS6tsCco,2539
 compressedfhir/fhir/test/test_fhir_bundle.py,sha256=Kt1IpxEnUuPOJBDWsdy4cC7kR3FR-uPOf7PB9ejJ7ZM,8700
-compressedfhir/fhir/test/test_fhir_resource.py,sha256=4Fl6QaqjW4CsYqkxVj2WRXITv_MeozUIrZgN4bMBGIw,8002
+compressedfhir/fhir/test/test_fhir_resource.py,sha256=nsSLs-sKDaYpoTVyXuBNnKJ0-somxDNX368lpTf3HUw,3828
 compressedfhir/fhir/test/test_fhir_resource_list.py,sha256=SrSPJ1yWU4UgMUCht6JwgKh2Y5JeTS4-Wky0kWZOXH8,5664
 compressedfhir/fhir/test/test_fhir_resource_map.py,sha256=jtQ5fq_jhmFfhHGyK5mdiwIQiO-Sfp2eG9mco_Tr9Qk,10995
 compressedfhir/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,19 +28,19 @@ compressedfhir/utilities/fhir_json_encoder.py,sha256=hn-ZuDrTEdYZmILk_5_k4R72PQB
 compressedfhir/utilities/json_helpers.py,sha256=lEiPapLN0p-kLu6PFm-h971ieXRxwPB2M-8FCZ2Buo8,5642
 compressedfhir/utilities/compressed_dict/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 compressedfhir/utilities/compressed_dict/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-compressedfhir/utilities/compressed_dict/v1/compressed_dict.py,sha256=sf8mGBdvYpjcMfVSWUVFGTiEi_pimutwCWyfKbAY2OU,21314
+compressedfhir/utilities/compressed_dict/v1/compressed_dict.py,sha256=C2mblG2P8qx0XWpDJO-7OGBqyQRTp0WelaUbwopI7qc,22049
 compressedfhir/utilities/compressed_dict/v1/compressed_dict_access_error.py,sha256=xuwED0KGZcQORIcZRfi--5CdXplHJ5vYLBUqpbDi344,132
 compressedfhir/utilities/compressed_dict/v1/compressed_dict_storage_mode.py,sha256=mEdtJjPX2I9DqP0Ly_VsZZWhEMNTI1psqQ8iJtUQ2oE,1412
 compressedfhir/utilities/compressed_dict/v1/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py,sha256=7AsOX1Nw7Woo9C7OzdBXMXFQhgEBAZZ8py1aHfFh-4k,11970
+compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py,sha256=5yUnjkmP3A4dSPzDXY3u1YBQ8BxCANdtCF9uGF1T9i4,15840
 compressedfhir/utilities/json_serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-compressedfhir/utilities/json_serializers/type_preservation_decoder.py,sha256=vLGSuyN7FXlpoJwpBvCPf27RpA1DmmKQ0BO_xPOLJiw,2135
+compressedfhir/utilities/json_serializers/type_preservation_decoder.py,sha256=Af2ZsLZiUF9kUhRvkV7i6Ctf_OtTND_lb5PezHtolJU,4382
 compressedfhir/utilities/json_serializers/type_preservation_encoder.py,sha256=f7RL67l7QtDbijCPq1ki6axrLte1vH--bi1AsN7Y3yk,1646
-compressedfhir/utilities/json_serializers/type_preservation_serializer.py,sha256=jhut-eqVMhAYnAVA9GOH8moJBn20pqA7-MBqsW-JXeY,1488
+compressedfhir/utilities/json_serializers/type_preservation_serializer.py,sha256=cE1ka2RxKy_8P0xhgqvPyWqJ3C0Br-aqIHP9BPkCg7A,1523
 compressedfhir/utilities/json_serializers/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py,sha256=sVdZoZ6u8luyjmBLae_6Bk8lsYTaxBNU-e-P-nWyVMk,2329
+compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py,sha256=GQotwYQJe9VZQotvLWmQWMkSIBne53bolmgflBoR7DU,4752
 compressedfhir/utilities/json_serializers/test/test_type_preservation_encoder.py,sha256=O4VczBdsJF35WozZiwSdJ8638qDn01JQsai2wTXu5Vo,1737
-compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py,sha256=RwshpoLN-f3bXmT1QhwWANpndGMxwtyu9O-1SMMwmgQ,1985
+compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py,sha256=dTYdgI1wMgWU0DJCNJlbMmsnhr-Q_2SPXeydLsn70rA,6043
 compressedfhir/utilities/ordered_dict_to_dict_converter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 compressedfhir/utilities/ordered_dict_to_dict_converter/ordered_dict_to_dict_converter.py,sha256=CMerJQD7O0vMyGtUp1rKSerZA1tDZeY5GTQT3AykL4w,831
 compressedfhir/utilities/string_compressor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -51,9 +51,9 @@ compressedfhir/utilities/string_compressor/v1/test/test_string_compressor.py,sha
 compressedfhir/utilities/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 compressedfhir/utilities/test/test_fhir_json_encoder.py,sha256=6pbNmZp5eBWY66bHjgjm_pZVhs5HDKP8hCGnwNFzpEw,5171
 compressedfhir/utilities/test/test_json_helpers.py,sha256=V0R9oHDQAs0m0012niEz50sHJxMSUQvA3km7kK8HgjE,3860
-compressedfhir-1.0.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+compressedfhir-1.0.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-compressedfhir-1.0.3.dist-info/METADATA,sha256=4HYsDmJhx91m8f7HbhReC5tL6mkP3Z7a_ZqDbzIEgaI,3456
-compressedfhir-1.0.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-compressedfhir-1.0.3.dist-info/top_level.txt,sha256=YMKdvBBdiCzFbpI9fG8BUDjaRd-f4R0qAvUoVETpoWw,21
-compressedfhir-1.0.3.dist-info/RECORD,,
+compressedfhir-1.0.5.dist-info/METADATA,sha256=jitzP2jc8_vqD1C9RYDNyetYivS_DOHuUplgJZy8t20,3456
+compressedfhir-1.0.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+compressedfhir-1.0.5.dist-info/top_level.txt,sha256=YMKdvBBdiCzFbpI9fG8BUDjaRd-f4R0qAvUoVETpoWw,21
+compressedfhir-1.0.5.dist-info/RECORD,,