compressedfhir 1.0.1__tar.gz → 1.0.3__tar.gz

compressedfhir-1.0.3/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: compressedfhir
+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
+Author-email: imran.qureshi@icanbwell.com
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgpack>=1.0.0
+Requires-Dist: orjson>=3.10.16
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Compressed FHIR
+
+A Python library for storing FHIR JSON resources in a compressed form in memory, optimizing memory usage while maintaining fast access to FHIR data.
+
+## Overview
+
+Compressed FHIR is a specialized library that provides efficient memory storage for FHIR (Fast Healthcare Interoperability Resources) JSON resources. It uses zlib or msgpack for compression while ensuring quick access to the stored healthcare data.
+
+## Features
+
+- Efficient memory storage of FHIR resources
+- Fast access to compressed FHIR data
+- Compatible with standard FHIR JSON formats
+- Minimal memory footprint
+- Python 3.10+ support
+
+## Installation
+
+You can install the package using pip:
+
+```bash
+pip install compressedfhir
+```
+
+Or using pipenv:
+
+```bash
+pipenv install compressedfhir
+```
+
+## Requirements
+
+- Python 3.10 or higher
+- msgpack >= 1.0.0
+- orjson >= 3.10.16
+
+## Usage
+
+```python
+from typing import Any
+from collections import OrderedDict
+
+from compressedfhir.fhir.fhir_resource import FhirResource
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import CompressedDictStorageMode
+
+
+resource1 = FhirResource(
+    initial_dict={"resourceType": "Observation", "id": "456"},
+    storage_mode=CompressedDictStorageMode.default(),
+)
+
+my_dict: OrderedDict[str,Any] = resource1.dict()
+my_plain_dict: dict[str, Any] = resource1.to_plain_dict()
+my_json: str = resource1.json()
+
+with resource1.transaction():
+   assert "email" not in resource1
+   assert resource1.get("name") == "Custom Mode User"
+   assert resource1.get("active") is True
+```
+
+## Development Setup
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/icanbwell/compressed-fhir.git
+   cd compressed-fhir
+   ```
+
+2. Install dependencies using pipenv:
+   ```bash
+   pipenv install --dev
+   ```
+
+3. Set up pre-commit hooks:
+   ```bash
+   pre-commit install
+   ```
+
+## Docker Support
+
+The project includes Docker support for development and deployment:
+
+```bash
+# Build the Docker image
+docker build -t compressed-fhir .
+
+# Run using docker-compose
+docker-compose up
+```
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
+
+## Authors
+
+- Imran Qureshi (imran.qureshi@icanbwell.com)
+
+## Support
+
+For support, please open an issue in the GitHub repository or contact the maintainers.
+
+## Project Status
+
+Current status: Beta
+
+The project is under active development. Please check the GitHub repository for the latest updates and changes.

compressedfhir-1.0.3/README.md

@@ -0,0 +1,112 @@
+# Compressed FHIR
+
+A Python library for storing FHIR JSON resources in a compressed form in memory, optimizing memory usage while maintaining fast access to FHIR data.
+
+## Overview
+
+Compressed FHIR is a specialized library that provides efficient memory storage for FHIR (Fast Healthcare Interoperability Resources) JSON resources. It uses zlib or msgpack for compression while ensuring quick access to the stored healthcare data.
+
+## Features
+
+- Efficient memory storage of FHIR resources
+- Fast access to compressed FHIR data
+- Compatible with standard FHIR JSON formats
+- Minimal memory footprint
+- Python 3.10+ support
+
+## Installation
+
+You can install the package using pip:
+
+```bash
+pip install compressedfhir
+```
+
+Or using pipenv:
+
+```bash
+pipenv install compressedfhir
+```
+
+## Requirements
+
+- Python 3.10 or higher
+- msgpack >= 1.0.0
+- orjson >= 3.10.16
+
+## Usage
+
+```python
+from typing import Any
+from collections import OrderedDict
+
+from compressedfhir.fhir.fhir_resource import FhirResource
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import CompressedDictStorageMode
+
+
+resource1 = FhirResource(
+    initial_dict={"resourceType": "Observation", "id": "456"},
+    storage_mode=CompressedDictStorageMode.default(),
+)
+
+my_dict: OrderedDict[str,Any] = resource1.dict()
+my_plain_dict: dict[str, Any] = resource1.to_plain_dict()
+my_json: str = resource1.json()
+
+with resource1.transaction():
+   assert "email" not in resource1
+   assert resource1.get("name") == "Custom Mode User"
+   assert resource1.get("active") is True
+```
+
+## Development Setup
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/icanbwell/compressed-fhir.git
+   cd compressed-fhir
+   ```
+
+2. Install dependencies using pipenv:
+   ```bash
+   pipenv install --dev
+   ```
+
+3. Set up pre-commit hooks:
+   ```bash
+   pre-commit install
+   ```
+
+## Docker Support
+
+The project includes Docker support for development and deployment:
+
+```bash
+# Build the Docker image
+docker build -t compressed-fhir .
+
+# Run using docker-compose
+docker-compose up
+```
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
+
+## Authors
+
+- Imran Qureshi (imran.qureshi@icanbwell.com)
+
+## Support
+
+For support, please open an issue in the GitHub repository or contact the maintainers.
+
+## Project Status
+
+Current status: Beta
+
+The project is under active development. Please check the GitHub repository for the latest updates and changes.

compressedfhir-1.0.3/VERSION

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

{compressedfhir-1.0.1 → 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.1 → 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.1 → compressedfhir-1.0.3}/compressedfhir/fhir/fhir_bundle_entry_request.py

@@ -43,14 +43,16 @@ class FhirBundleEntryRequest:
     def from_dict(
         cls, d: Dict[str, Any] | OrderedDict[str, Any]
     ) -> "FhirBundleEntryRequest":
+        date_if_modified_since: Optional[datetime] = None
+        if "ifModifiedSince" in d:
+            if isinstance(d["ifModifiedSince"], datetime):
+                date_if_modified_since = d["ifModifiedSince"]
+            elif isinstance(d["ifModifiedSince"], str):
+                date_if_modified_since = datetime.fromisoformat(d["ifModifiedSince"])
         return cls(
             url=d.get("url", "https://example.com"),
             method=d.get("method", "GET"),
-            ifModifiedSince=(
-                datetime.fromisoformat(d["ifModifiedSince"])
-                if "ifModifiedSince" in d
-                else None
-            ),
+            ifModifiedSince=date_if_modified_since,
             ifNoneMatch=d["ifNoneMatch"] if "ifNoneMatch" in d else None,
             ifNoneExist=d["ifNoneExist"] if "ifNoneExist" in d else None,
         )

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

@@ -41,13 +41,16 @@ 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):
+                date_last_modified = d["lastModified"]
+            elif isinstance(d["lastModified"], str):
+                date_last_modified = datetime.fromisoformat(d["lastModified"])
+
         return cls(
             status=d["status"] if "status" in d else "200",
-            lastModified=(
-                datetime.fromisoformat(d["lastModified"])
-                if "lastModified" in d
-                else None
-            ),
+            lastModified=date_last_modified,
             etag=d["etag"] if "etag" in d else None,
             location=d["location"] if "location" in d else None,
         )

{compressedfhir-1.0.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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"