compressedfhir 3.0.2__py3-none-any.whl

compressedfhir/utilities/json_helpers.py

@@ -0,0 +1,181 @@
+import json
+from typing import Any, Dict, List, cast, Union, Optional, OrderedDict, overload
+from datetime import datetime, date
+
+import orjson
+
+
+class FhirClientJsonHelpers:
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def json_serial(obj: Any) -> str:
+        """JSON serializer for objects not serializable by default json code"""
+
+        # https://stackoverflow.com/questions/11875770/how-to-overcome-datetime-datetime-not-json-serializable
+        if isinstance(obj, (datetime, date)):
+            return obj.isoformat()
+        return str(obj)
+
+    @staticmethod
+    def remove_empty_elements(
+        d: List[Dict[str, Any]] | Dict[str, Any],
+    ) -> List[Dict[str, Any]] | Dict[str, Any]:
+        """
+        Recursively remove empty lists, empty dicts, or None elements from a dictionary
+        or a list of dictionaries
+        :param d: dictionary or list of dictionaries
+        :return: dictionary or list of dictionaries
+        """
+
+        def empty(x: Any) -> bool:
+            # Check if the input is None, an empty list, an empty dict, or an empty string
+            return (
+                x is None
+                or x == []
+                or x == {}
+                or (isinstance(x, str) and x.strip() == "")
+            )
+
+        if not isinstance(d, (dict, list)):
+            return d
+        elif isinstance(d, list):
+            return [
+                cast(Dict[str, Any], v)
+                for v in (FhirClientJsonHelpers.remove_empty_elements(v) for v in d)
+                if not empty(v)
+            ]
+        else:
+            return {
+                k: v
+                for k, v in (
+                    (k, FhirClientJsonHelpers.remove_empty_elements(v))
+                    for k, v in d.items()
+                )
+                if not empty(v)
+            }
+
+    @staticmethod
+    @overload
+    def remove_empty_elements_from_ordered_dict(
+        d: List[OrderedDict[str, Any]],
+    ) -> List[OrderedDict[str, Any]]: ...
+
+    @staticmethod
+    @overload
+    def remove_empty_elements_from_ordered_dict(
+        d: OrderedDict[str, Any],
+    ) -> OrderedDict[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]:
+        """
+        Recursively remove empty lists, empty dicts, or None elements from a dictionary
+        or a list of dictionaries
+        :param d: dictionary or list of dictionaries
+        :return: dictionary or list of dictionaries
+        """
+
+        def empty(x: Any) -> bool:
+            # Check if the input is None, an empty list, an empty dict, or an empty string
+            return (
+                x is None
+                or x == []
+                or x == {}
+                or (isinstance(x, str) and x.strip() == "")
+            )
+
+        if not isinstance(d, (OrderedDict, list, Dict)):
+            return d
+        elif isinstance(d, list):
+            return [
+                v
+                for v in (
+                    FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(v)
+                    for v in d
+                )
+                if not empty(v)
+            ]
+        else:
+            return OrderedDict[str, Any](
+                {
+                    k: v
+                    for k, v in (
+                        (
+                            k,
+                            FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(
+                                v
+                            ),
+                        )
+                        for k, v in d.items()
+                    )
+                    if not empty(v)
+                }
+            )
+
+    @staticmethod
+    def convert_dict_to_fhir_json(dict_: Dict[str, Any]) -> str:
+        """
+        Returns dictionary as json string
+
+
+        :return:
+        """
+        instance_variables: Dict[str, Any] = cast(
+            Dict[str, Any], FhirClientJsonHelpers.remove_empty_elements(dict_)
+        )
+
+        instance_variables_text: str = json.dumps(
+            instance_variables, default=FhirClientJsonHelpers.json_serial
+        )
+        return instance_variables_text
+
+    @staticmethod
+    def orjson_dumps(
+        obj: Any, indent: Optional[int] = None, sort_keys: bool = False
+    ) -> str:
+        """
+        Wrapper for orjson.dumps() to mimic json.dumps() behavior
+
+        Args:
+            obj: Object to serialize
+            indent: Optional indentation (note: orjson has limited indent support)
+            sort_keys: Whether to sort dictionary keys
+
+        Returns:
+            JSON string
+        """
+        # Serialization options
+        options = 0
+
+        # Handle sorting keys
+        if sort_keys:
+            options |= orjson.OPT_SORT_KEYS
+
+        # Handle indentation (limited support)
+        if indent is not None:
+            options |= orjson.OPT_INDENT_2  # Fixed indentation
+
+        # Serialize to bytes
+        json_bytes = orjson.dumps(obj, option=options)
+
+        # Convert bytes to string
+        return json_bytes.decode("utf-8")
+
+    @staticmethod
+    def orjson_loads(json_input: Union[str, bytes]) -> Any:
+        """
+        Safely load JSON with type flexibility
+        """
+        try:
+            # Converts input to appropriate type if needed
+            if isinstance(json_input, str):
+                json_input = json_input.encode("utf-8")
+
+            return orjson.loads(json_input)
+        except (orjson.JSONDecodeError, TypeError) as e:
+            print(f"JSON Parsing Error: {e}")
+            return None

compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py

@@ -0,0 +1,165 @@
+from datetime import datetime, date, time
+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,
+        ),
+        (
+            "datetime",
+            {
+                "__type__": "datetime",
+                "iso": "2023-01-01T00:00:00-08:00",
+                "tzinfo": "Pacific/Honolulu",
+            },
+            datetime,
+        ),
+        ("date", {"__type__": "date", "iso": "2023-01-01"}, date),
+        ("time", {"__type__": "time", "iso": "14:30:15"}, time),
+        (
+            "time",
+            {"__type__": "time", "iso": "14:30:15", "tzinfo": "Pacific/Honolulu"},
+            time,
+        ),
+        ("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,71 @@
+import logging
+from datetime import datetime, timezone, date, time
+from decimal import Decimal
+from logging import Logger
+from typing import Type, Any
+from zoneinfo import ZoneInfo
+
+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"),
+        (
+            datetime,
+            datetime(2023, 1, 1, tzinfo=ZoneInfo("Pacific/Honolulu")),
+            "datetime",
+        ),
+        (date, date(2023, 1, 1), "date"),
+        (time, time(14, 30, 15), "time"),
+        (time, time(14, 30, 15, tzinfo=ZoneInfo("Pacific/Honolulu")), "time"),
+        (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
+    """
+    logger: Logger = logging.getLogger(__name__)
+    encoder = TypePreservationEncoder()
+    serialized = encoder.default(input_value)
+
+    logger.info(serialized)
+    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

compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py

@@ -0,0 +1,197 @@
+import logging
+from collections import OrderedDict
+from datetime import datetime, timezone, date, time
+from decimal import Decimal
+from logging import Logger
+from typing import Any
+from zoneinfo import ZoneInfo
+
+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_no_tz": datetime.now(),
+        "timestamp": datetime.now(timezone.utc),
+        "timestamp_pst": datetime.now(ZoneInfo("Pacific/Honolulu")),
+        "today": date.today(),
+        "my_time": time(14, 30, 15),
+        "my_time_pst": time(14, 30, 15, tzinfo=ZoneInfo("Pacific/Honolulu")),
+        "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, OrderedDict)
+    assert isinstance(deserialized["timestamp_no_tz"], datetime)
+    assert deserialized["timestamp_no_tz"] == complex_data["timestamp_no_tz"]
+    assert isinstance(deserialized["timestamp"], datetime)
+    assert deserialized["timestamp"] == complex_data["timestamp"]
+    assert isinstance(deserialized["timestamp_pst"], datetime)
+    assert deserialized["timestamp_pst"] == complex_data["timestamp_pst"]
+    assert isinstance(deserialized["today"], date)
+    assert deserialized["today"] == complex_data["today"]
+    assert isinstance(deserialized["my_time"], time)
+    assert deserialized["my_time"] == complex_data["my_time"]
+    assert isinstance(deserialized["my_time_pst"], time)
+    assert deserialized["my_time_pst"] == complex_data["my_time_pst"]
+    assert isinstance(deserialized["precise_value"], Decimal)
+    assert deserialized["precise_value"] == complex_data["precise_value"]
+    assert isinstance(deserialized["complex_number"], complex)
+    assert deserialized["complex_number"] == complex_data["complex_number"]
+    assert isinstance(deserialized["byte_data"], bytes)
+    assert deserialized["byte_data"] == complex_data["byte_data"]
+    assert isinstance(deserialized["unique_items"], set)
+    assert deserialized["unique_items"] == complex_data["unique_items"]
+    assert isinstance(deserialized["custom_obj"], TestCustomObject)
+    assert deserialized["custom_obj"] == complex_data["custom_obj"]
+
+
+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 = {
+        "resourceType": "Coverage",
+        "id": "3456789012345670304",
+        "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,
+                },
+            }
+        ],
+        "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",
+                }
+            ]
+        },
+        "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: str = TypePreservationSerializer.serialize(nested_dict)
+    logger.info(serialized)
+    logger.info("-------- Deserialized --------")
+    deserialized: OrderedDict[str, Any] = TypePreservationSerializer.deserialize(
+        serialized
+    )
+    logger.info(deserialized)
+
+    assert isinstance(deserialized, OrderedDict)
+
+    assert isinstance(deserialized["period"]["start"], date)
+    assert isinstance(deserialized["period"]["end"], date)
+    assert nested_dict == deserialized