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

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/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/utilities/json_serializers/type_preservation_encoder.py

@@ -0,0 +1,50 @@
+import json
+from collections.abc import Callable
+from datetime import datetime, date
+from decimal import Decimal
+from typing import Any, Dict, Type
+
+
+class TypePreservationEncoder(json.JSONEncoder):
+    """
+    Advanced JSON encoder for complex type serialization
+    """
+
+    TYPE_MAP: Dict[Type[Any], Callable[[Any], Any]] = {
+        datetime: lambda dt: {
+            "__type__": "datetime",
+            "iso": dt.isoformat(),
+            "tzinfo": str(dt.tzinfo) if dt.tzinfo else None,
+        },
+        date: lambda d: {"__type__": "date", "iso": d.isoformat()},
+        Decimal: lambda d: {"__type__": "decimal", "value": str(d)},
+        complex: lambda c: {"__type__": "complex", "real": c.real, "imag": c.imag},
+        bytes: lambda b: {"__type__": "bytes", "value": b.decode("latin-1")},
+        set: lambda s: {"__type__": "set", "values": list(s)},
+    }
+
+    def default(self, obj: Any) -> Any:
+        """
+        Custom serialization for complex types
+
+        Args:
+            obj: Object to serialize
+
+        Returns:
+            Serializable representation of the object
+        """
+        # Check if the type is in our custom type map
+        for type_, serializer in self.TYPE_MAP.items():
+            if isinstance(obj, type_):
+                return serializer(obj)
+
+        # Handle custom objects with __dict__
+        if hasattr(obj, "__dict__"):
+            return {
+                "__type__": obj.__class__.__name__,
+                "__module__": obj.__class__.__module__,
+                "attributes": obj.__dict__,
+            }
+
+        # Fallback to default JSON encoder
+        return super().default(obj)

compressedfhir/utilities/json_serializers/type_preservation_serializer.py

@@ -0,0 +1,57 @@
+import json
+from typing import Any, Callable, Dict
+
+from compressedfhir.utilities.json_serializers.type_preservation_decoder import (
+    TypePreservationDecoder,
+)
+from compressedfhir.utilities.json_serializers.type_preservation_encoder import (
+    TypePreservationEncoder,
+)
+
+
+class TypePreservationSerializer:
+    """
+    Comprehensive serialization and deserialization utility
+    """
+
+    @classmethod
+    def serialize(cls, data: Any, **kwargs: Any) -> str:
+        """
+        Serialize data with advanced type handling
+
+        Args:
+            data: Data to serialize
+            kwargs: Additional JSON dumps arguments
+
+        Returns:
+            JSON string representation
+        """
+        return json.dumps(
+            data, cls=TypePreservationEncoder, separators=(",", ":"), **kwargs
+        )
+
+    @classmethod
+    def deserialize(
+        cls,
+        json_str: str,
+        custom_decoders: Dict[str, Callable[[Any], Any]] | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """
+        Deserialize JSON string with advanced type reconstruction
+
+        Args:
+            json_str: JSON string to deserialize
+            custom_decoders: Optional additional custom decoders
+            kwargs: Additional JSON loads arguments
+
+        Returns:
+            Reconstructed object
+        """
+        return json.loads(
+            json_str,
+            object_hook=lambda dct: TypePreservationDecoder.decode(
+                dct, custom_decoders
+            ),
+            **kwargs,
+        )

compressedfhir/utilities/ordered_dict_to_dict_converter/ordered_dict_to_dict_converter.py

@@ -0,0 +1,24 @@
+from typing import OrderedDict, cast
+
+
+class OrderedDictToDictConverter:
+    @staticmethod
+    def convert[K, V](ordered_dict: OrderedDict[K, V]) -> dict[K, V]:
+        """
+        Converts an OrderedDict to a regular dict in a recursive manner.
+
+
+        :param ordered_dict: The OrderedDict to convert
+        :return: A regular dict with the same key-value pairs
+        """
+
+        def _convert[T](value: T) -> T:
+            if isinstance(value, OrderedDict):
+                return cast(T, {k: _convert(v) for k, v in value.items()})
+            elif isinstance(value, dict):
+                return cast(T, {k: _convert(v) for k, v in value.items()})
+            elif isinstance(value, list):
+                return cast(T, [_convert(item) for item in value])
+            return value
+
+        return _convert(ordered_dict)

compressedfhir/utilities/string_compressor/v1/string_compressor.py

@@ -0,0 +1,99 @@
+import zlib
+from typing import Union, Optional
+
+
+class StringCompressor:
+    """
+    A utility class for compressing and decompressing strings using zlib.
+
+    Provides methods to compress strings to bytes and decompress bytes back to strings.
+    Uses UTF-8 encoding and zlib's best compression level.
+    """
+
+    @staticmethod
+    def compress(text: str, encoding: str = "utf-8") -> bytes:
+        """
+        Compress a given string to bytes using zlib.
+
+        Args:
+            text (str): The input string to compress
+            encoding (str, optional): The encoding to use. Defaults to 'utf-8'
+
+        Returns:
+            bytes: Compressed representation of the input string
+
+        Raises:
+            TypeError: If input is not a string
+            zlib.error: If compression fails
+        """
+        if not isinstance(text, str):
+            raise TypeError("Input must be a string")
+
+        try:
+            # Encode string to bytes, then compress with best compression
+            return zlib.compress(text.encode(encoding), level=zlib.Z_BEST_COMPRESSION)
+        except Exception as e:
+            raise zlib.error(f"Compression failed: {e}")
+
+    @staticmethod
+    def decompress(
+        compressed_data: Union[bytes, bytearray], encoding: str = "utf-8"
+    ) -> str:
+        """
+        Decompress bytes back to the original string.
+
+        Args:
+            compressed_data (Union[bytes, bytearray]): Compressed data to decompress
+            encoding (str, optional): The encoding to use. Defaults to 'utf-8'
+
+        Returns:
+            str: Decompressed original string
+
+        Raises:
+            TypeError: If input is not bytes or bytearray
+            zlib.error: If decompression fails
+        """
+        if not isinstance(compressed_data, (bytes, bytearray)):
+            raise TypeError("Input must be bytes or bytearray")
+
+        try:
+            # Decompress bytes, then decode to string
+            return zlib.decompress(compressed_data).decode(encoding)
+        except Exception as e:
+            raise zlib.error(f"Decompression failed: {e}")
+
+    @classmethod
+    def compress_safe(
+        cls, text: Optional[str], encoding: str = "utf-8"
+    ) -> Optional[bytes]:
+        """
+        Safely compress a string, handling None input.
+
+        Args:
+            text (Optional[str]): The input string to compress
+            encoding (str, optional): The encoding to use. Defaults to 'utf-8'
+
+        Returns:
+            Optional[bytes]: Compressed bytes or None if input is None
+        """
+        if text is None:
+            return None
+        return cls.compress(text, encoding)
+
+    @classmethod
+    def decompress_safe(
+        cls, compressed_data: Optional[Union[bytes, bytearray]], encoding: str = "utf-8"
+    ) -> Optional[str]:
+        """
+        Safely decompress bytes, handling None input.
+
+        Args:
+            compressed_data (Optional[Union[bytes, bytearray]]): Compressed data to decompress
+            encoding (str, optional): The encoding to use. Defaults to 'utf-8'
+
+        Returns:
+            Optional[str]: Decompressed string or None if input is None
+        """
+        if compressed_data is None:
+            return None
+        return cls.decompress(compressed_data, encoding)