compressedfhir 0.0.1__py3-none-any.whl

compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py

@@ -0,0 +1,360 @@
+import pytest
+from typing import Any, cast
+
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict import (
+    CompressedDict,
+)
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_access_error import (
+    CompressedDictAccessError,
+)
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+    CompressedDictStorageType,
+)
+
+
+class TestCompressedDict:
+    def test_init_empty(self) -> None:
+        """Test initialization with no initial data"""
+        cd: CompressedDict[str, Any] = CompressedDict(
+            storage_mode=CompressedDictStorageMode(storage_type="raw"),
+            properties_to_cache=[],
+        )
+        assert len(cd) == 0
+        assert cd._storage_mode.storage_type == "raw"
+
+    def test_init_with_dict(self) -> None:
+        """Test initialization with initial dictionary"""
+        initial_data = {"a": 1, "b": 2, "c": 3}
+        cd = CompressedDict(
+            initial_dict=initial_data,
+            storage_mode=CompressedDictStorageMode(storage_type="raw"),
+            properties_to_cache=[],
+        )
+
+        with cd.transaction():
+            assert len(cd) == 3
+            assert cd["a"] == 1
+            assert cd["b"] == 2
+            assert cd["c"] == 3
+
+    @pytest.mark.parametrize("storage_type", ["raw", "msgpack", "compressed_msgpack"])
+    def test_storage_modes(self, storage_type: CompressedDictStorageType) -> None:
+        """Test different storage modes"""
+        initial_data = {"key": "value"}
+        cd = CompressedDict(
+            initial_dict=initial_data,
+            storage_mode=CompressedDictStorageMode(storage_type=storage_type),
+            properties_to_cache=[],
+        )
+        assert cd._storage_mode.storage_type == storage_type
+        with cd.transaction():
+            assert cd["key"] == "value"
+
+    def test_setitem_and_getitem(self) -> None:
+        """Test setting and getting items"""
+        cd: CompressedDict[str, Any] = CompressedDict(
+            storage_mode=CompressedDictStorageMode(storage_type="compressed_msgpack"),
+            properties_to_cache=[],
+        )
+        with cd.transaction():
+            cd["key1"] = "value1"
+            cd["key2"] = 42
+            cd["key3"] = {"nested": "dict"}
+
+        with cd.transaction():
+            assert cd["key1"] == "value1"
+            assert cd["key2"] == 42
+            assert cd["key3"] == {"nested": "dict"}
+
+    def test_delitem(self) -> None:
+        """Test deleting items"""
+        cd = CompressedDict(
+            initial_dict={"a": 1, "b": 2},
+            storage_mode=CompressedDictStorageMode(storage_type="compressed_msgpack"),
+            properties_to_cache=[],
+        )
+        with cd.transaction():
+            del cd["a"]
+
+        with cd.transaction():
+            assert len(cd) == 1
+
+        with cd.transaction():
+            assert not cd.__contains__("a")
+            assert "a" not in cd
+            assert "b" in cd
+
+    def test_contains(self) -> None:
+        """Test key existence checks"""
+        cd = CompressedDict(
+            initial_dict={"a": 1, "b": 2},
+            storage_mode=CompressedDictStorageMode(),
+            properties_to_cache=[],
+        )
+
+        with cd.transaction():
+            assert "a" in cd
+            assert "b" in cd
+            assert "c" not in cd
+
+    def test_keys_and_values(self) -> None:
+        """Test keys and values methods"""
+        initial_data = {"a": 1, "b": 2, "c": 3}
+        cd: CompressedDict[str, int] = CompressedDict(
+            initial_dict=initial_data,
+            storage_mode=CompressedDictStorageMode(),
+            properties_to_cache=[],
+        )
+
+        with cd.transaction():
+            assert set(cd.keys()) == {"a", "b", "c"}
+            assert set(cd.values()) == {1, 2, 3}
+
+    def test_items(self) -> None:
+        """Test items method"""
+        initial_data = {"a": 1, "b": 2, "c": 3}
+        cd = CompressedDict(
+            initial_dict=initial_data,
+            storage_mode=CompressedDictStorageMode(),
+            properties_to_cache=[],
+        )
+
+        with cd.transaction():
+            assert set(cd.items()) == {("a", 1), ("b", 2), ("c", 3)}
+
+    def test_get_method(self) -> None:
+        """Test get method with default"""
+        cd: CompressedDict[str, Any] = CompressedDict(
+            initial_dict={"a": 1},
+            storage_mode=CompressedDictStorageMode(),
+            properties_to_cache=[],
+        )
+        with cd.transaction():
+            assert cd.get("a") == 1
+            assert cd.get("b") is None
+            assert cd.get("b", "default") == "default"
+
+    def test_to_dict(self) -> None:
+        """Test conversion to standard dictionary"""
+        initial_data = {"a": 1, "b": 2}
+        cd = CompressedDict(
+            initial_dict=initial_data,
+            storage_mode=CompressedDictStorageMode(),
+            properties_to_cache=[],
+        )
+
+        with cd.transaction():
+            assert cd.dict() == initial_data
+
+    def test_complex_nested_structures(self) -> None:
+        """Test storage of complex nested structures"""
+        complex_data = {
+            "nested_dict": {"inner_key": "inner_value"},
+            "list": [1, 2, 3],
+            "mixed": [{"a": 1}, 2, "three"],
+        }
+
+        # Test each storage storage_type
+        for storage_type in ["raw", "msgpack", "compressed_msgpack"]:
+            cd = CompressedDict(
+                initial_dict=complex_data,
+                storage_mode=CompressedDictStorageMode(
+                    storage_type=cast(CompressedDictStorageType, storage_type)
+                ),
+                properties_to_cache=[],
+            )
+            with cd.transaction():
+                assert cd["nested_dict"] == {"inner_key": "inner_value"}
+                assert cd["list"] == [1, 2, 3]
+                assert cd["mixed"] == [{"a": 1}, 2, "three"]
+
+    def test_repr(self) -> None:
+        """Test string representation"""
+        cd = CompressedDict(
+            initial_dict={"a": 1, "b": 2},
+            storage_mode=CompressedDictStorageMode(),
+            properties_to_cache=[],
+        )
+        repr_str = repr(cd)
+
+        assert repr_str == "CompressedDict(storage_type='compressed', keys=2)"
+
+    def test_error_handling(self) -> None:
+        """Test error scenarios"""
+        cd: CompressedDict[str, Any] = CompressedDict(
+            storage_mode=CompressedDictStorageMode(), properties_to_cache=[]
+        )
+
+        # Test KeyError
+        with pytest.raises(KeyError):
+            with cd.transaction():
+                _ = cd["non_existent_key"]
+
+    @pytest.mark.parametrize("storage_type", ["raw", "msgpack", "compressed_msgpack"])
+    def test_large_data_handling(self, storage_type: CompressedDictStorageType) -> None:
+        """Test handling of large datasets"""
+        large_data = {f"key_{i}": f"value_{i}" for i in range(1000)}
+
+        cd = CompressedDict(
+            initial_dict=large_data,
+            storage_mode=CompressedDictStorageMode(storage_type=storage_type),
+            properties_to_cache=[],
+        )
+
+        assert len(cd) == 1000
+        with cd.transaction():
+            assert cd["key_500"] == "value_500"
+
+
+def test_transaction_basic_raw_storage() -> None:
+    """
+    Test basic transaction functionality with raw storage mode
+    """
+    storage_mode = CompressedDictStorageMode(storage_type="raw")
+    initial_dict = {"key1": "value1", "key2": "value2"}
+
+    compressed_dict = CompressedDict(
+        initial_dict=initial_dict, storage_mode=storage_mode, properties_to_cache=None
+    )
+
+    # Verify initial state
+    assert compressed_dict._transaction_depth == 0
+
+    # Use transaction context
+    with compressed_dict.transaction() as d:
+        assert compressed_dict._transaction_depth == 1
+        assert d._working_dict is not None
+        assert d._working_dict == initial_dict
+
+        # Modify the dictionary
+        d["key3"] = "value3"
+
+    # After transaction
+    assert compressed_dict._transaction_depth == 0
+    assert compressed_dict.dict() == {
+        "key1": "value1",
+        "key2": "value2",
+        "key3": "value3",
+    }
+
+
+def test_transaction_nested_context() -> None:
+    """
+    Test nested transaction contexts
+    """
+    storage_mode = CompressedDictStorageMode(storage_type="msgpack")
+    initial_dict = {"key1": "value1"}
+
+    compressed_dict = CompressedDict(
+        initial_dict=initial_dict, storage_mode=storage_mode, properties_to_cache=None
+    )
+
+    with compressed_dict.transaction():
+        assert compressed_dict._transaction_depth == 1
+
+        with compressed_dict.transaction():
+            assert compressed_dict._transaction_depth == 2
+            compressed_dict["key2"] = "value2"
+
+        assert compressed_dict._transaction_depth == 1
+
+    assert compressed_dict._transaction_depth == 0
+    assert compressed_dict.dict() == {"key1": "value1", "key2": "value2"}
+
+
+def test_transaction_access_error() -> None:
+    """
+    Test that accessing or modifying dictionary outside transaction raises an error
+    """
+    storage_mode = CompressedDictStorageMode(storage_type="compressed_msgpack")
+    compressed_dict = CompressedDict(
+        initial_dict={"key1": "value1"},
+        storage_mode=storage_mode,
+        properties_to_cache=None,
+    )
+
+    # Test getdict outside transaction
+    with pytest.raises(CompressedDictAccessError):
+        compressed_dict._get_dict()
+
+    # Test __getitem__ outside transaction
+    with pytest.raises(CompressedDictAccessError):
+        _ = compressed_dict["key1"]
+
+    # Test __setitem__ outside transaction
+    with pytest.raises(CompressedDictAccessError):
+        compressed_dict["key2"] = "value2"
+
+
+def test_transaction_different_storage_modes() -> None:
+    """
+    Test transaction with different storage modes
+    """
+    storage_modes = [
+        CompressedDictStorageMode(storage_type="raw"),
+        CompressedDictStorageMode(storage_type="msgpack"),
+        CompressedDictStorageMode(storage_type="compressed_msgpack"),
+    ]
+
+    for storage_mode in storage_modes:
+        initial_dict = {"key1": "value1"}
+
+        compressed_dict = CompressedDict(
+            initial_dict=initial_dict,
+            storage_mode=storage_mode,
+            properties_to_cache=None,
+        )
+
+        with compressed_dict.transaction() as d:
+            d["key2"] = "value2"
+
+        assert compressed_dict.dict() == {"key1": "value1", "key2": "value2"}
+
+
+def test_transaction_with_properties_to_cache() -> None:
+    """
+    Test transaction with properties to cache
+    """
+    storage_mode = CompressedDictStorageMode(storage_type="raw")
+    initial_dict = {"key1": "value1", "important_prop": "cached_value"}
+
+    compressed_dict = CompressedDict(
+        initial_dict=initial_dict,
+        storage_mode=storage_mode,
+        properties_to_cache=["important_prop"],
+    )
+
+    with compressed_dict.transaction() as d:
+        d["key2"] = "value2"
+
+    assert compressed_dict.dict() == {
+        "key1": "value1",
+        "important_prop": "cached_value",
+        "key2": "value2",
+    }
+    assert compressed_dict._cached_properties == {"important_prop": "cached_value"}
+
+
+def test_transaction_error_handling() -> None:
+    """
+    Test error handling during transaction
+    """
+    storage_mode = CompressedDictStorageMode(storage_type="compressed")
+    compressed_dict = CompressedDict(
+        initial_dict={"key1": "value1"},
+        storage_mode=storage_mode,
+        properties_to_cache=None,
+    )
+
+    try:
+        with compressed_dict.transaction():
+            compressed_dict["key2"] = "value2"
+            raise ValueError("Simulated error")
+    except ValueError:
+        # Ensure transaction depth is reset even after an error
+        assert compressed_dict._transaction_depth == 0
+
+        # Verify the dictionary state remains unchanged
+        with compressed_dict.transaction() as d:
+            assert d.dict() == {"key1": "value1", "key2": "value2"}

compressedfhir/utilities/fhir_json_encoder.py

@@ -0,0 +1,30 @@
+import dataclasses
+import json
+from datetime import datetime, date
+from decimal import Decimal
+from enum import Enum
+from typing import Any
+
+
+class FhirJSONEncoder(json.JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if dataclasses.is_dataclass(o):
+            return dataclasses.asdict(o)  # type:ignore
+        if isinstance(o, Enum):
+            return o.value
+        if isinstance(o, Decimal):
+            # Custom Decimal conversion
+            if o == o.to_integral_value():
+                # If Decimal is a whole number, return as int
+                return int(o)
+            else:
+                # If Decimal has a non-zero decimal part, return as float
+                return float(o)
+        if isinstance(o, bytes):
+            return o.decode("utf-8")
+        if isinstance(o, (datetime, date)):
+            return o.isoformat()
+        if hasattr(o, "to_dict"):
+            return o.dict()
+
+        return super().default(o)

compressedfhir/utilities/json_helpers.py

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

compressedfhir-0.0.1.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: compressedfhir
+Version: 0.0.1
+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
+
+# compressedfhir

compressedfhir-0.0.1.dist-info/RECORD

@@ -0,0 +1,41 @@
+compressedfhir/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/fhir/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/fhir/base_resource_list.py,sha256=hhlQLT_HFrLmVPuirTsiXQsiUadxpfSQTPS4CofthTM,4924
+compressedfhir/fhir/fhir_bundle.py,sha256=MG98a7TG0K71PSQz5CvMzHFXZBv81JZ7_m1bzOsZQsE,10103
+compressedfhir/fhir/fhir_bundle_entry.py,sha256=eQT-NSZvMbPbKubIKOFPo_70f4CVAfSwvnQVbC5Y3LI,8459
+compressedfhir/fhir/fhir_bundle_entry_list.py,sha256=tjZueiviQ4ucSDNGSR9CpN-Kwv3BIBcmal3_0J1HE_E,2655
+compressedfhir/fhir/fhir_bundle_entry_request.py,sha256=djoK7Izq8PxLVjUvG8Gy5o1bNXuNL7s6iaCRVx1CrVs,2607
+compressedfhir/fhir/fhir_bundle_entry_response.py,sha256=_Q5r3AlLcT4J_TSVzoSZDO1U_wtBBZM23_PPG7djbTc,2302
+compressedfhir/fhir/fhir_bundle_entry_search.py,sha256=uYVJxuNN3gt3Q6BZ5FhRs47x7l54Lo_H-7JdoOvkx94,2554
+compressedfhir/fhir/fhir_identifier.py,sha256=tA_nmhBaYHu5zjJdE0IWMFEF8lrIPV3_nu-yairiIKw,2711
+compressedfhir/fhir/fhir_link.py,sha256=jf2RrwmsPrKW3saP77y42xVqI0xwHFYXxm6YHQJk7gU,1922
+compressedfhir/fhir/fhir_meta.py,sha256=vNI4O6SoG4hJRHyd-bJ_QnYFTfBHyR3UA6h21ByQmWo,1669
+compressedfhir/fhir/fhir_resource.py,sha256=iHc7HGxiGTf8E2tSf4rXXAztc5NkY61rLTdzXq9iZIQ,5259
+compressedfhir/fhir/fhir_resource_list.py,sha256=YsGqLN7vE-qfrN0Yg_UpPHjBjfB5JSsliTbNllM69-w,4477
+compressedfhir/fhir/fhir_resource_map.py,sha256=6Zt_K8KVolS-lgT_Ztu_6YxNo8BXhweQfWO-QFriInA,6588
+compressedfhir/fhir/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/fhir/test/test_bundle_entry.py,sha256=Ki2sSu1V1WZkAM6UTCghtzjvjYYI8UcF6AXnx8FWlMI,5115
+compressedfhir/fhir/test/test_bundle_entry_list.py,sha256=KtMrbQYezdEw9FJbBzwSePdJK2R9P03mSRfo59T-6iM,6041
+compressedfhir/fhir/test/test_bundle_entry_request.py,sha256=9bN3Vt9BAXPLjH7FFt_MYSdanFJzWk9HbA0C9kZxPXY,2853
+compressedfhir/fhir/test/test_bundle_entry_response.py,sha256=jk5nUi07_q-yz-qz2YR86vU91e3DVxc2cptrS6tsCco,2539
+compressedfhir/fhir/test/test_fhir_bundle.py,sha256=Kt1IpxEnUuPOJBDWsdy4cC7kR3FR-uPOf7PB9ejJ7ZM,8700
+compressedfhir/fhir/test/test_fhir_resource.py,sha256=4Fl6QaqjW4CsYqkxVj2WRXITv_MeozUIrZgN4bMBGIw,8002
+compressedfhir/fhir/test/test_fhir_resource_list.py,sha256=SrSPJ1yWU4UgMUCht6JwgKh2Y5JeTS4-Wky0kWZOXH8,5664
+compressedfhir/fhir/test/test_fhir_resource_map.py,sha256=jtQ5fq_jhmFfhHGyK5mdiwIQiO-Sfp2eG9mco_Tr9Qk,10995
+compressedfhir/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/fhir_json_encoder.py,sha256=vUx0hdrdbo9mVgH7mpwKG1Th96QiDIoPkvL_0ba5SBM,954
+compressedfhir/utilities/json_helpers.py,sha256=lEiPapLN0p-kLu6PFm-h971ieXRxwPB2M-8FCZ2Buo8,5642
+compressedfhir/utilities/compressed_dict/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/compressed_dict/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/compressed_dict/v1/compressed_dict.py,sha256=tt1wCI1o4nLJwi_E-UXP5kZUT1-jo7rdOZzsZTKwiok,19970
+compressedfhir/utilities/compressed_dict/v1/compressed_dict_access_error.py,sha256=xuwED0KGZcQORIcZRfi--5CdXplHJ5vYLBUqpbDi344,132
+compressedfhir/utilities/compressed_dict/v1/compressed_dict_storage_mode.py,sha256=GmwvQX2e9DbdKq2oKnW-VaqbigeJfVqDEhnOBfcbpdA,1402
+compressedfhir/utilities/compressed_dict/v1/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py,sha256=7AsOX1Nw7Woo9C7OzdBXMXFQhgEBAZZ8py1aHfFh-4k,11970
+compressedfhir-0.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir-0.0.1.dist-info/METADATA,sha256=MkBZCtq_UoUJXwSQR7fv40dd70OSjGFnB_AZ___2p-E,828
+compressedfhir-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+compressedfhir-0.0.1.dist-info/top_level.txt,sha256=YMKdvBBdiCzFbpI9fG8BUDjaRd-f4R0qAvUoVETpoWw,21
+compressedfhir-0.0.1.dist-info/RECORD,,

compressedfhir-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+