compressedfhir 1.0.3__tar.gz → 1.0.4__tar.gz

{compressedfhir-1.0.3/compressedfhir.egg-info → compressedfhir-1.0.4}/PKG-INFO

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

compressedfhir-1.0.4/VERSION

@@ -0,0 +1 @@
+1.0.4

{compressedfhir-1.0.3 → compressedfhir-1.0.4}/compressedfhir/utilities/compressed_dict/v1/compressed_dict.py

@@ -176,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 = TypePreservationSerializer.serialize(
-                dictionary, separators=(",", ":")
-            )
+            json_str = TypePreservationSerializer.serialize(dictionary)
             return zlib.compress(
                 json_str.encode("utf-8"), level=zlib.Z_BEST_COMPRESSION
             )
@@ -219,9 +217,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)
 

{compressedfhir-1.0.3 → compressedfhir-1.0.4}/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-1.0.4/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-1.0.4/compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py

@@ -0,0 +1,171 @@
+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 (
+    TypePreservationSerializer,
+)
+
+
+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
+
+
+def test_complex_data_serialization() -> None:
+    """
+    Test serialization and deserialization of complex data
+    """
+    complex_data = {
+        "timestamp": datetime.now(timezone.utc),
+        "today": date.today(),
+        "precise_value": Decimal("3.14159"),
+        "complex_number": 3 + 4j,
+        "byte_data": b"Hello",
+        "unique_items": {1, 2, 3},
+        "custom_obj": TestCustomObject("test", 42),
+    }
+
+    # Serialize
+    serialized = TypePreservationSerializer.serialize(complex_data)
+
+    # Deserialize
+    deserialized = TypePreservationSerializer.deserialize(serialized)
+
+    # Verify types
+    assert isinstance(deserialized["timestamp"], datetime)
+    assert isinstance(deserialized["today"], date)
+    assert isinstance(deserialized["precise_value"], Decimal)
+    assert isinstance(deserialized["complex_number"], complex)
+    assert isinstance(deserialized["byte_data"], bytes)
+    assert isinstance(deserialized["unique_items"], set)
+    assert isinstance(deserialized["custom_obj"], TestCustomObject)
+
+
+def test_nested_complex_data() -> None:
+    """
+    Test serialization of nested complex data
+    """
+    nested_data = {"level1": {"level2": {"timestamp": datetime.now(timezone.utc)}}}
+
+    serialized = TypePreservationSerializer.serialize(nested_data)
+    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-1.0.4/compressedfhir/utilities/json_serializers/type_preservation_decoder.py

@@ -0,0 +1,110 @@
+import logging
+from collections import OrderedDict
+from datetime import datetime, date
+from decimal import Decimal
+from logging import Logger
+from typing import Any, Dict, Callable, Optional, Union, cast, List
+
+
+class TypePreservationDecoder:
+    """
+    Advanced JSON decoder for complex type reconstruction with nested type support
+    """
+
+    @classmethod
+    def decode(
+        cls,
+        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, 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
+        """
+        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": 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 {})}
+
+        # 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-1.0.3 → compressedfhir-1.0.4}/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 → compressedfhir-1.0.4/compressedfhir.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compressedfhir
-Version: 1.0.3
+Version: 1.0.4
 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/VERSION

@@ -1 +0,0 @@
-1.0.3

compressedfhir-1.0.3/compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py

@@ -1,82 +0,0 @@
-from datetime import datetime, date
-from decimal import Decimal
-from typing import Type, Any, Dict
-
-import pytest
-
-from compressedfhir.utilities.json_serializers.type_preservation_decoder import (
-    TypePreservationDecoder,
-)
-
-
-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_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"

compressedfhir-1.0.3/compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py

@@ -1,60 +0,0 @@
-from datetime import datetime, timezone, date
-from decimal import Decimal
-from typing import Any
-
-from compressedfhir.utilities.json_serializers.type_preservation_serializer import (
-    TypePreservationSerializer,
-)
-
-
-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
-
-
-def test_complex_data_serialization() -> None:
-    """
-    Test serialization and deserialization of complex data
-    """
-    complex_data = {
-        "timestamp": datetime.now(timezone.utc),
-        "today": date.today(),
-        "precise_value": Decimal("3.14159"),
-        "complex_number": 3 + 4j,
-        "byte_data": b"Hello",
-        "unique_items": {1, 2, 3},
-        "custom_obj": TestCustomObject("test", 42),
-    }
-
-    # Serialize
-    serialized = TypePreservationSerializer.serialize(complex_data)
-
-    # Deserialize
-    deserialized = TypePreservationSerializer.deserialize(serialized)
-
-    # Verify types
-    assert isinstance(deserialized["timestamp"], datetime)
-    assert isinstance(deserialized["today"], date)
-    assert isinstance(deserialized["precise_value"], Decimal)
-    assert isinstance(deserialized["complex_number"], complex)
-    assert isinstance(deserialized["byte_data"], bytes)
-    assert isinstance(deserialized["unique_items"], set)
-    assert isinstance(deserialized["custom_obj"], TestCustomObject)
-
-
-def test_nested_complex_data() -> None:
-    """
-    Test serialization of nested complex data
-    """
-    nested_data = {"level1": {"level2": {"timestamp": datetime.now(timezone.utc)}}}
-
-    serialized = TypePreservationSerializer.serialize(nested_data)
-    deserialized = TypePreservationSerializer.deserialize(serialized)
-
-    assert isinstance(deserialized["level1"]["level2"]["timestamp"], datetime)

compressedfhir-1.0.3/compressedfhir/utilities/json_serializers/type_preservation_decoder.py

@@ -1,63 +0,0 @@
-from datetime import datetime, date
-from decimal import Decimal
-from typing import Any, Dict, Callable
-
-
-class TypePreservationDecoder:
-    """
-    Advanced JSON decoder for complex type reconstruction
-    """
-
-    @classmethod
-    def decode(
-        cls,
-        dct: Dict[str, Any],
-        custom_decoders: Dict[str, Callable[[Any], Any]] | None = None,
-    ) -> Any:
-        """
-        Decode complex types
-
-        Args:
-            dct: Dictionary to decode
-            custom_decoders: Optional additional custom decoders
-
-        Returns:
-            Reconstructed object or original dictionary
-        """
-        # Default decoders for built-in types
-        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"]),
-        }
-
-        # 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