compressedfhir 1.0.2__tar.gz → 1.0.3__tar.gz

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

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

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

{compressedfhir-1.0.2 → compressedfhir-1.0.3}/compressedfhir/fhir/fhir_bundle.py

@@ -13,6 +13,9 @@ from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode im
 )
 from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
 from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+from compressedfhir.utilities.ordered_dict_to_dict_converter.ordered_dict_to_dict_converter import (
+    OrderedDictToDictConverter,
+)
 
 
 class FhirBundle:
@@ -286,6 +289,4 @@ class FhirBundle:
 
         :return: Plain dictionary representation of the Bundle
         """
-        return cast(
-            Dict[str, Any], json.loads(json.dumps(self.dict(), cls=FhirJSONEncoder))
-        )
+        return OrderedDictToDictConverter.convert(self.dict())

{compressedfhir-1.0.2 → compressedfhir-1.0.3}/compressedfhir/fhir/fhir_bundle_entry.py

@@ -217,7 +217,7 @@ class FhirBundleEntry:
         return (
             f"BundleEntry({self.resource.resource_type}/{self.resource.id})"
             if self.resource
-            else f"BundleEntry(Empty)"
+            else "BundleEntry(Empty)"
         )
 
     def copy(self) -> "FhirBundleEntry":

{compressedfhir-1.0.2 → compressedfhir-1.0.3}/compressedfhir/fhir/fhir_bundle_entry_response.py

@@ -41,7 +41,6 @@ class FhirBundleEntryResponse:
     def from_dict(
         cls, d: Dict[str, Any] | OrderedDict[str, Any]
     ) -> "FhirBundleEntryResponse":
-
         date_last_modified: Optional[datetime] = None
         if "lastModified" in d:
             if isinstance(d["lastModified"], datetime):

{compressedfhir-1.0.2 → compressedfhir-1.0.3}/compressedfhir/fhir/fhir_resource.py

@@ -65,17 +65,6 @@ class FhirResource(CompressedDict[str, Any]):
         """Convert the resource to a JSON string."""
         return json.dumps(obj=self.dict(), cls=FhirJSONEncoder)
 
-    @classmethod
-    def from_json(cls, json_str: str) -> "FhirResource":
-        """
-        Create a FhirResource object from a JSON string.
-
-        :param json_str: The JSON string to convert.
-        :return: A FhirResource object.
-        """
-        data = json.loads(json_str)
-        return cls.from_dict(data)
-
     def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirResource":
         """Create a copy of the resource."""
         return FhirResource(
@@ -112,22 +101,6 @@ class FhirResource(CompressedDict[str, Any]):
 
         return result
 
-    @classmethod
-    def from_dict(
-        cls,
-        d: Dict[str, Any],
-        *,
-        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
-    ) -> "FhirResource":
-        """
-        Creates a FhirResource object from a dictionary.
-
-        :param d: The dictionary to convert.
-        :param storage_mode: The storage mode for the CompressedDict.
-        :return: A FhirResource object.
-        """
-        return cls(initial_dict=d, storage_mode=storage_mode)
-
     def remove_nulls(self) -> None:
         """
         Removes None values from the resource dictionary.
@@ -161,3 +134,40 @@ class FhirResource(CompressedDict[str, Any]):
         else:
             assert isinstance(value, FhirMeta)
             self["meta"] = value.dict()
+
+    @classmethod
+    @override
+    def from_json(cls, json_str: str) -> "FhirResource":
+        """
+        Creates a FhirResource object from a JSON string.
+
+        :param json_str: JSON string representing the resource.
+        :return: A FhirResource object.
+        """
+        return cast(FhirResource, super().from_json(json_str=json_str))
+
+    @classmethod
+    @override
+    def from_dict(
+        cls,
+        d: Dict[str, Any],
+        *,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
+        properties_to_cache: List[str] | None = None,
+    ) -> "FhirResource":
+        """
+        Creates a FhirResource object from a dictionary.
+
+        :param d: Dictionary representing the resource.
+        :param storage_mode: Storage mode for the CompressedDict.
+        :param properties_to_cache: List of properties to cache.
+        :return: A FhirResource object.
+        """
+        return cast(
+            FhirResource,
+            super().from_dict(
+                d=d,
+                storage_mode=storage_mode,
+                properties_to_cache=properties_to_cache,
+            ),
+        )

{compressedfhir-1.0.2 → compressedfhir-1.0.3}/compressedfhir/fhir/fhir_resource_list.py

@@ -103,7 +103,7 @@ class FhirResourceList(BaseResourceList[FhirResource]):
         if len(self) == 0:
             return resources_by_type
 
-        entry: FhirResource
+        resource: FhirResource
         for resource in [r for r in self if r is not None]:
             resource_type: str = resource.resource_type or "unknown"
             if resource_type not in resources_by_type:

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

@@ -1,5 +1,4 @@
 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
@@ -14,7 +13,12 @@ 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,
+)
+from compressedfhir.utilities.ordered_dict_to_dict_converter.ordered_dict_to_dict_converter import (
+    OrderedDictToDictConverter,
+)
 
 
 class CompressedDict[K, V](MutableMapping[K, V]):
@@ -146,7 +150,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
             # For serialized modes, deserialize
             working_dict = (
                 self._deserialize_dict(
-                    serialized_dict=self._serialized_dict,
+                    serialized_dict_bytes=self._serialized_dict,
                     storage_type=self._storage_mode.storage_type,
                 )
                 if self._serialized_dict
@@ -172,9 +176,9 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         assert isinstance(dictionary, OrderedDict)
         if storage_type == "compressed":
             # Serialize to JSON and compress with zlib
-            json_str = json.dumps(
-                dictionary, separators=(",", ":"), cls=FhirJSONEncoder
-            )  # Most compact JSON representation
+            json_str = TypePreservationSerializer.serialize(
+                dictionary, separators=(",", ":")
+            )
             return zlib.compress(
                 json_str.encode("utf-8"), level=zlib.Z_BEST_COMPRESSION
             )
@@ -195,34 +199,37 @@ class CompressedDict[K, V](MutableMapping[K, V]):
     @staticmethod
     def _deserialize_dict(
         *,
-        serialized_dict: bytes,
+        serialized_dict_bytes: bytes,
         storage_type: CompressedDictStorageType,
     ) -> OrderedDict[K, V]:
         """
         Deserialize entire dictionary from MessagePack
 
         Args:
-            serialized_dict: Serialized dictionary bytes
+            serialized_dict_bytes: Serialized dictionary bytes
 
         Returns:
             Deserialized dictionary
         """
-        assert serialized_dict is not None, "Serialized dictionary cannot be None"
+        assert serialized_dict_bytes is not None, "Serialized dictionary cannot be None"
+        assert isinstance(serialized_dict_bytes, bytes)
 
         if storage_type == "compressed":
             # Decompress and parse JSON
-            decompressed = zlib.decompress(serialized_dict)
-            decoded_text = decompressed.decode("utf-8")
+            decompressed_bytes: bytes = zlib.decompress(serialized_dict_bytes)
+            decoded_text: str = decompressed_bytes.decode("utf-8")
             # noinspection PyTypeChecker
-            decompressed_dict = json.loads(decoded_text, object_pairs_hook=OrderedDict)
+            decompressed_dict = TypePreservationSerializer.deserialize(
+                decoded_text, object_pairs_hook=OrderedDict
+            )
             assert isinstance(decompressed_dict, OrderedDict)
             return cast(OrderedDict[K, V], decompressed_dict)
 
         # Decompress if needed
         to_unpack = (
-            zlib.decompress(serialized_dict)
+            zlib.decompress(serialized_dict_bytes)
             if storage_type == "compressed_msgpack"
-            else serialized_dict
+            else serialized_dict_bytes
         )
 
         # Deserialize
@@ -630,6 +637,37 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         Returns:
             Plain dictionary
         """
-        return cast(
-            Dict[K, V], json.loads(json.dumps(self.dict(), cls=FhirJSONEncoder))
+        return OrderedDictToDictConverter.convert(self.dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "CompressedDict[K, V]":
+        """
+        Create a FhirResource object from a JSON string.
+
+        :param json_str: The JSON string to convert.
+        :return: A FhirResource object.
+        """
+        data = TypePreservationSerializer.deserialize(json_str)
+        return cls.from_dict(data)
+
+    @classmethod
+    def from_dict(
+        cls,
+        d: Dict[K, V],
+        *,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
+        properties_to_cache: List[K] | None = None,
+    ) -> "CompressedDict[K, V]":
+        """
+        Creates a FhirResource object from a dictionary.
+
+        :param d: The dictionary to convert.
+        :param storage_mode: The storage mode for the CompressedDict.
+        :param properties_to_cache: Optional list of properties to cache
+        :return: A FhirResource object.
+        """
+        return cls(
+            initial_dict=d,
+            storage_mode=storage_mode,
+            properties_to_cache=properties_to_cache,
         )

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

@@ -4,13 +4,13 @@ from typing import Literal, TypeAlias
 CompressedDictStorageType: TypeAlias = Literal[
     "raw", "compressed", "msgpack", "compressed_msgpack"
 ]
-"""
-CompressedDictStorageType is a type alias for the different storage types
-raw: No compression
-compressed: Compressed using zlib
-msgpack: Compressed using msgpack
-compressed_msgpack: Compressed using msgpack with zlib
-"""
+###
+# CompressedDictStorageType is a type alias for the different storage types
+# raw: No compression
+# compressed: Compressed using zlib
+# msgpack: Compressed using msgpack
+# compressed_msgpack: Compressed using msgpack with zlib
+###
 
 
 @dataclasses.dataclass(slots=True)

{compressedfhir-1.0.2 → compressedfhir-1.0.3}/compressedfhir/utilities/fhir_json_encoder.py

@@ -18,7 +18,7 @@ class FhirJSONEncoder(json.JSONEncoder):
     def default(self, o: Any) -> Any:
         # Existing type handlers
         if dataclasses.is_dataclass(o):
-            return dataclasses.asdict(o)  # type:ignore
+            return dataclasses.asdict(o)  # type:ignore[arg-type]
 
         if isinstance(o, Enum):
             return o.value

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

@@ -0,0 +1,82 @@
+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_encoder.py

@@ -0,0 +1,59 @@
+from datetime import datetime, timezone, date
+from decimal import Decimal
+from typing import Type, Any
+
+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"),
+        (date, date(2023, 1, 1), "date"),
+        (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
+    """
+    encoder = TypePreservationEncoder()
+    serialized = encoder.default(input_value)
+
+    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-1.0.3/compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,63 @@
+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

compressedfhir-1.0.3/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-1.0.3/compressedfhir/utilities/json_serializers/type_preservation_serializer.py

@@ -0,0 +1,55 @@
+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, indent=2, **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-1.0.3/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-1.0.3/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-1.0.3/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

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

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

{compressedfhir-1.0.2 → compressedfhir-1.0.3}/compressedfhir.egg-info/SOURCES.txt

@@ -46,6 +46,21 @@ compressedfhir/utilities/compressed_dict/v1/compressed_dict_access_error.py
 compressedfhir/utilities/compressed_dict/v1/compressed_dict_storage_mode.py
 compressedfhir/utilities/compressed_dict/v1/test/__init__.py
 compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py
+compressedfhir/utilities/json_serializers/__init__.py
+compressedfhir/utilities/json_serializers/type_preservation_decoder.py
+compressedfhir/utilities/json_serializers/type_preservation_encoder.py
+compressedfhir/utilities/json_serializers/type_preservation_serializer.py
+compressedfhir/utilities/json_serializers/test/__init__.py
+compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py
+compressedfhir/utilities/json_serializers/test/test_type_preservation_encoder.py
+compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py
+compressedfhir/utilities/ordered_dict_to_dict_converter/__init__.py
+compressedfhir/utilities/ordered_dict_to_dict_converter/ordered_dict_to_dict_converter.py
+compressedfhir/utilities/string_compressor/__init__.py
+compressedfhir/utilities/string_compressor/v1/__init__.py
+compressedfhir/utilities/string_compressor/v1/string_compressor.py
+compressedfhir/utilities/string_compressor/v1/test/__init__.py
+compressedfhir/utilities/string_compressor/v1/test/test_string_compressor.py
 compressedfhir/utilities/test/__init__.py
 compressedfhir/utilities/test/test_fhir_json_encoder.py
 compressedfhir/utilities/test/test_json_helpers.py

compressedfhir-1.0.2/VERSION

@@ -1 +0,0 @@
-1.0.2