compressedfhir 3.0.2__py3-none-any.whl

compressedfhir/utilities/json_serializers/type_preservation_decoder.py

@@ -0,0 +1,135 @@
+import logging
+from collections import OrderedDict
+from datetime import datetime, date, time
+from decimal import Decimal
+from logging import Logger
+from typing import Any, Dict, Callable, Optional, Union, cast, List
+from zoneinfo import ZoneInfo
+
+
+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)
+
+        def time_decoder(d: Union[str, Dict[str, Any]]) -> time:
+            if isinstance(d, str):
+                return time.fromisoformat(d)
+            elif isinstance(d, dict) and "iso" in d:
+                # Extract ISO time string
+                iso_time: str = d["iso"]
+
+                # Parse time from ISO format
+                parsed_time = time.fromisoformat(iso_time)
+
+                # Add timezone if specified
+                tz_info = d.get("tzinfo")
+                if tz_info:
+                    try:
+                        tz_aware_time = parsed_time.replace(tzinfo=ZoneInfo(tz_info))
+                        return tz_aware_time
+                    except Exception as e:
+                        raise ValueError(f"Invalid timezone: {tz_info}") from e
+                else:
+                    # If no timezone info, return naive time
+                    return parsed_time
+            return cast(time, d)
+
+        default_decoders: Dict[str, Callable[[Any], Any]] = {
+            "datetime": datetime_decoder,
+            "date": date_decoder,
+            "time": time_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,55 @@
+import json
+from collections.abc import Callable
+from datetime import datetime, date, time
+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()},
+        time: lambda t: {
+            "__type__": "time",
+            "iso": t.isoformat(),
+            "tzinfo": str(t.tzinfo) if t.tzinfo else None,
+        },
+        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)

compressedfhir/utilities/string_compressor/v1/test/test_string_compressor.py

@@ -0,0 +1,189 @@
+# Basic Compression and Decompression Tests
+from typing import Optional, Union
+
+import pytest
+import zlib
+
+from compressedfhir.utilities.string_compressor.v1.string_compressor import (
+    StringCompressor,
+)
+
+
+@pytest.mark.parametrize(
+    "input_text",
+    [
+        "Hello, World!",
+        "Python is awesome",
+        "12345",
+        "",  # Empty string
+        "🌍🚀",  # Unicode characters
+    ],
+)
+def test_compress_decompress_basic(input_text: str) -> None:
+    """
+    Test basic compression and decompression functionality
+    """
+    # Compress
+    compressed = StringCompressor.compress(input_text)
+
+    # Verify compression reduces size
+    # assert len(compressed) < len(input_text.encode('utf-8'))
+
+    # Decompress
+    decompressed = StringCompressor.decompress(compressed)
+
+    # Verify original text is preserved
+    assert decompressed == input_text
+
+
+# Error Handling Tests
+def test_compress_invalid_input() -> None:
+    """
+    Test compression with invalid input type
+    """
+    with pytest.raises(TypeError, match="Input must be a string"):
+        StringCompressor.compress(123)  # type:ignore[arg-type]
+
+    with pytest.raises(TypeError, match="Input must be a string"):
+        StringCompressor.compress(None)  # type:ignore[arg-type]
+
+
+def test_decompress_invalid_input() -> None:
+    """
+    Test decompression with invalid input type
+    """
+    with pytest.raises(TypeError, match="Input must be bytes or bytearray"):
+        StringCompressor.decompress("not bytes")  # type:ignore[arg-type]
+
+    with pytest.raises(TypeError, match="Input must be bytes or bytearray"):
+        StringCompressor.decompress(123)  # type:ignore[arg-type]
+
+
+# Safe Method Tests
+@pytest.mark.parametrize("input_text", ["Test string", None, ""])
+def test_compress_safe(input_text: Optional[str]) -> None:
+    """
+    Test safe compression method
+    """
+    compressed = StringCompressor.compress_safe(input_text)
+
+    if input_text is None:
+        assert compressed is None
+    else:
+        assert isinstance(compressed, bytes)
+        # Verify we can decompress
+        decompressed = StringCompressor.decompress_safe(compressed)
+        assert decompressed == input_text
+
+
+@pytest.mark.parametrize(
+    "input_data", [b"compressed data", None, bytearray(b"another compressed data")]
+)
+def test_decompress_safe(input_data: Optional[Union[bytes, bytearray]]) -> None:
+    """
+    Test safe decompression method
+    """
+    if input_data is None:
+        decompressed = StringCompressor.decompress_safe(input_data)
+        assert decompressed is None
+    else:
+        # First compress a string
+        original = "Test string to compress"
+        compressed = StringCompressor.compress(original)
+
+        # Then decompress
+        decompressed = StringCompressor.decompress_safe(compressed)
+        assert decompressed == original
+
+
+# Encoding Tests
+@pytest.mark.parametrize("encoding", ["utf-8", "ascii", "latin-1"])
+def test_custom_encoding(encoding: str) -> None:
+    """
+    Test compression and decompression with different encodings
+    """
+    input_text = "Hello, World!"
+
+    # Compress with custom encoding
+    compressed = StringCompressor.compress(input_text, encoding=encoding)
+
+    # Decompress with same encoding
+    decompressed = StringCompressor.decompress(compressed, encoding=encoding)
+
+    assert decompressed == input_text
+
+
+# Compression Efficiency Tests
+def test_compression_efficiency() -> None:
+    """
+    Test that compression actually reduces data size
+    """
+    # Long repetitive string for better compression
+    input_text = "Hello " * 1000
+
+    # Compress
+    compressed = StringCompressor.compress(input_text)
+
+    # Check compression ratio
+    original_size = len(input_text.encode("utf-8"))
+    compressed_size = len(compressed)
+
+    # Verify significant size reduction
+    assert compressed_size < original_size
+
+    # Verify lossless decompression
+    decompressed = StringCompressor.decompress(compressed)
+    assert decompressed == input_text
+
+
+# Edge Case Tests
+def test_very_large_string() -> None:
+    """
+    Test compression and decompression of a very large string
+    """
+    # Generate a large string
+    large_text = "A" * (1024 * 1024)  # 1MB of text
+
+    # Compress
+    compressed = StringCompressor.compress(large_text)
+
+    # Decompress
+    decompressed = StringCompressor.decompress(compressed)
+
+    assert decompressed == large_text
+
+
+# Error Scenario Tests
+def test_decompress_corrupted_data() -> None:
+    """
+    Test decompression of corrupted data
+    """
+    # Create some corrupted compressed data
+    with pytest.raises(zlib.error):
+        StringCompressor.decompress(b"corrupted data")
+
+
+# Performance Benchmark (optional)
+def test_compression_performance() -> None:
+    """
+    Basic performance test for compression and decompression
+    """
+    import timeit
+
+    # Test string
+    test_string = "Performance test " * 100
+
+    # Measure compression time
+    compression_time = timeit.timeit(
+        lambda: StringCompressor.compress(test_string), number=100
+    )
+
+    # Measure decompression time
+    compressed = StringCompressor.compress(test_string)
+    decompression_time = timeit.timeit(
+        lambda: StringCompressor.decompress(compressed), number=100
+    )
+
+    # Basic performance assertions (these can be adjusted)
+    assert compression_time < 1.0  # 100 compressions in less than 1 second
+    assert decompression_time < 1.0  # 100 decompressions in less than 1 second