compressedfhir 3.0.2__py3-none-any.whl

compressedfhir/utilities/test/test_fhir_json_encoder.py

@@ -0,0 +1,177 @@
+import dataclasses
+import json
+import uuid
+from datetime import datetime, date, time
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
+from typing import Optional, List
+
+import pytest
+
+from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
+
+# Optional: Import for additional type support
+try:
+    import ipaddress
+except ImportError:
+    ipaddress = None  # type:ignore[assignment]
+
+
+# Test support classes and enums
+class TestEnum(Enum):
+    OPTION1 = "value1"
+    OPTION2 = "value2"
+
+
+@dataclasses.dataclass
+class TestDataclass:
+    name: str
+    age: int
+    optional_field: Optional[str] = None
+
+
+class TestClassWithToDict:
+    # noinspection PyMethodMayBeStatic
+    def to_dict(self) -> dict[str, str]:
+        return {"key": "value"}
+
+
+def test_fhir_json_encoder_dataclass() -> None:
+    """Test serialization of dataclass"""
+    test_obj = TestDataclass(name="John", age=30)
+    encoded = json.dumps(test_obj, cls=FhirJSONEncoder)
+    decoded = json.loads(encoded)
+
+    assert decoded == {"name": "John", "age": 30, "optional_field": None}
+
+
+def test_fhir_json_encoder_enum() -> None:
+    """Test serialization of Enum"""
+    encoded = json.dumps(TestEnum.OPTION1, cls=FhirJSONEncoder)
+    assert encoded == '"value1"'
+
+
+def test_fhir_json_encoder_decimal() -> None:
+    """Test Decimal conversion"""
+    # Whole number Decimal
+    whole_decimal = Decimal("10")
+    encoded_whole = json.dumps(whole_decimal, cls=FhirJSONEncoder)
+    assert encoded_whole == "10"
+
+    # Decimal with fractional part
+    frac_decimal = Decimal("10.5")
+    encoded_frac = json.dumps(frac_decimal, cls=FhirJSONEncoder)
+    assert encoded_frac == "10.5"
+
+
+def test_fhir_json_encoder_bytes() -> None:
+    """Test bytes conversion"""
+    test_bytes = b"hello world"
+    encoded = json.dumps(test_bytes, cls=FhirJSONEncoder)
+    assert encoded == '"hello world"'
+
+
+def test_fhir_json_encoder_datetime() -> None:
+    """Test datetime serialization"""
+    test_datetime = datetime(2023, 1, 15, 12, 30, 45)
+    encoded = json.dumps(test_datetime, cls=FhirJSONEncoder)
+    assert encoded == '"2023-01-15T12:30:45"'
+
+
+def test_fhir_json_encoder_date() -> None:
+    """Test date serialization"""
+    test_date = date(2023, 1, 15)
+    encoded = json.dumps(test_date, cls=FhirJSONEncoder)
+    assert encoded == '"2023-01-15"'
+
+
+def test_fhir_json_encoder_time() -> None:
+    """Test time serialization"""
+    test_time = time(12, 30, 45)
+    encoded = json.dumps(test_time, cls=FhirJSONEncoder)
+    assert encoded == '"12:30:45"'
+
+
+def test_fhir_json_encoder_to_dict() -> None:
+    """Test objects with to_dict method"""
+    test_obj = TestClassWithToDict()
+    encoded = json.dumps(test_obj, cls=FhirJSONEncoder)
+    assert encoded == '{"key": "value"}'
+
+
+def test_fhir_json_encoder_unsupported_type() -> None:
+    """Test fallback for unsupported types"""
+
+    class UnsupportedType:
+        __slots__: List[str] = []
+
+    with pytest.raises(TypeError):
+        json.dumps(UnsupportedType(), cls=FhirJSONEncoder)
+
+
+def test_extended_json_encoder_uuid() -> None:
+    """Test UUID serialization"""
+    test_uuid = uuid.uuid4()
+    encoded = json.dumps(test_uuid, cls=FhirJSONEncoder)
+    assert isinstance(json.loads(encoded), str)
+    assert len(json.loads(encoded)) == 36  # Standard UUID string length
+
+
+def test_extended_json_encoder_set() -> None:
+    """Test set and frozenset serialization"""
+    test_set = {1, 2, 3}
+    test_frozenset = frozenset([4, 5, 6])
+
+    encoded_set = json.dumps(test_set, cls=FhirJSONEncoder)
+    encoded_frozenset = json.dumps(test_frozenset, cls=FhirJSONEncoder)
+
+    decoded_set = json.loads(encoded_set)
+    decoded_frozenset = json.loads(encoded_frozenset)
+
+    assert set(decoded_set) == test_set
+    assert set(decoded_frozenset) == test_frozenset
+
+
+def test_extended_json_encoder_complex() -> None:
+    """Test complex number serialization"""
+    test_complex = 3 + 4j
+    encoded = json.dumps(test_complex, cls=FhirJSONEncoder)
+    decoded = json.loads(encoded)
+
+    assert decoded == {"real": 3.0, "imag": 4.0}
+
+
+def test_extended_json_encoder_path() -> None:
+    """Test Path object serialization"""
+    test_path = Path("/test/path")
+    encoded = json.dumps(test_path, cls=FhirJSONEncoder)
+    assert json.loads(encoded) == str(test_path)
+
+
+def test_extended_json_encoder_ip_address() -> None:
+    """Test IP Address serialization (if ipaddress module is available)"""
+    if ipaddress:
+        ipv4 = ipaddress.IPv4Address("192.168.0.1")
+        ipv6 = ipaddress.IPv6Address("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+
+        encoded_ipv4 = json.dumps(ipv4, cls=FhirJSONEncoder)
+        encoded_ipv6 = json.dumps(ipv6, cls=FhirJSONEncoder)
+
+        assert json.loads(encoded_ipv4) == str(ipv4)
+        assert json.loads(encoded_ipv6) == str(ipv6)
+
+
+def test_extended_json_encoder_custom_object() -> None:
+    """Test custom object serialization"""
+
+    class CustomObject:
+        def __init__(self) -> None:
+            self.x = 1
+            self.y = 2
+
+    obj = CustomObject()
+    encoded = json.dumps(obj, cls=FhirJSONEncoder)
+    decoded = json.loads(encoded)
+
+    assert decoded == {"x": 1, "y": 2}

compressedfhir/utilities/test/test_json_helpers.py

@@ -0,0 +1,99 @@
+import json
+from datetime import datetime, date
+from typing import List, Dict, Any
+
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class TestFhirClientJsonHelpers:
+    def test_json_serial(self) -> None:
+        # Test datetime serialization
+        dt = datetime(2023, 1, 15, 12, 30)
+        assert FhirClientJsonHelpers.json_serial(dt) == "2023-01-15T12:30:00"
+
+        # Test date serialization
+        d = date(2023, 1, 15)
+        assert FhirClientJsonHelpers.json_serial(d) == "2023-01-15"
+
+        # Test other types
+        assert FhirClientJsonHelpers.json_serial(123) == "123"
+        assert FhirClientJsonHelpers.json_serial("test") == "test"
+
+    def test_remove_empty_elements(self) -> None:
+        # Test dictionary removal
+        input_dict = {"a": 1, "b": "", "c": None, "d": [], "e": {}, "f": [1, 2, 3]}
+        expected_dict = {"a": 1, "f": [1, 2, 3]}
+        assert FhirClientJsonHelpers.remove_empty_elements(input_dict) == expected_dict
+
+        # Test list of dictionaries
+        input_list: List[Dict[str, Any]] = [
+            {"a": 1, "b": None},
+            {"c": [], "d": "test"},
+            {"e": {}},
+        ]
+        expected_list: List[Dict[str, Any]] = [{"a": 1}, {"d": "test"}]
+        assert FhirClientJsonHelpers.remove_empty_elements(input_list) == expected_list
+
+    def test_remove_empty_elements_from_ordered_dict(self) -> None:
+        from collections import OrderedDict
+
+        # Test OrderedDict removal
+        input_dict = OrderedDict(
+            [("a", 1), ("b", ""), ("c", None), ("d", []), ("e", {}), ("f", [1, 2, 3])]
+        )
+        expected_dict = OrderedDict([("a", 1), ("f", [1, 2, 3])])
+        result: List[OrderedDict[str, Any]] | OrderedDict[str, Any] = (
+            FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(input_dict)
+        )
+        assert result == expected_dict
+
+        # Test list of OrderedDicts
+        input_list: List[OrderedDict[str, Any]] = [
+            OrderedDict([("a", 1), ("b", None)]),
+            OrderedDict([("c", []), ("d", "test")]),
+            OrderedDict([("e", {})]),
+        ]
+        expected_list: List[OrderedDict[str, Any]] = [
+            OrderedDict([("a", 1)]),
+            OrderedDict([("d", "test")]),
+        ]
+        result = FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(
+            input_list
+        )
+        assert result == expected_list
+
+    def test_convert_dict_to_fhir_json(self) -> None:
+        input_dict = {"name": "John Doe", "age": 30, "address": None, "hobbies": []}
+        result = FhirClientJsonHelpers.convert_dict_to_fhir_json(input_dict)
+        parsed_result = json.loads(result)
+        assert parsed_result == {"name": "John Doe", "age": 30}
+
+    def test_orjson_dumps(self) -> None:
+        # Test basic serialization
+        data = {"a": 1, "b": "test"}
+        result = FhirClientJsonHelpers.orjson_dumps(data)
+        assert json.loads(result) == data
+
+        # Test sorting keys
+        result_sorted = FhirClientJsonHelpers.orjson_dumps(data, sort_keys=True)
+        assert result_sorted == '{"a":1,"b":"test"}'
+
+        # Test indentation (limited support)
+        result_indent = FhirClientJsonHelpers.orjson_dumps(data, indent=2)
+        assert isinstance(result_indent, str)
+
+    def test_orjson_loads(self) -> None:
+        # Test string input
+        json_str = '{"a": 1, "b": "test"}'
+        result = FhirClientJsonHelpers.orjson_loads(json_str)
+        assert result == {"a": 1, "b": "test"}
+
+        # Test bytes input
+        json_bytes = b'{"a": 1, "b": "test"}'
+        result = FhirClientJsonHelpers.orjson_loads(json_bytes)
+        assert result == {"a": 1, "b": "test"}
+
+        # Test invalid JSON
+        invalid_json = "{invalid json}"
+        result = FhirClientJsonHelpers.orjson_loads(invalid_json)
+        assert result is None

compressedfhir-3.0.2.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: compressedfhir
+Version: 3.0.2
+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-3.0.2.dist-info/RECORD

@@ -0,0 +1,59 @@
+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=mxywnxlZQRli9sPcS6pVLmHXc3BB8VunQuqeYndTl7c,10312
+compressedfhir/fhir/fhir_bundle_entry.py,sha256=pTebTx9XujB2bOUKDxTIlH6aGASzRiuXrFhwhu1Tk94,8712
+compressedfhir/fhir/fhir_bundle_entry_list.py,sha256=ZsyIbVs0hp650pCX1VcVnC5RIGjhHQh0wFy9aS_CCEg,2902
+compressedfhir/fhir/fhir_bundle_entry_request.py,sha256=8UqJw388aDYgZCz1rvk2kmDa03vOEsmZOaJeb5CLqzw,2841
+compressedfhir/fhir/fhir_bundle_entry_response.py,sha256=5u-ycyWVdFyLhIUM4xf-5QioKWAc2kEOFeFcJRrR6_o,2512
+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=7LDcIlQr7PI72P2_Qd8xnEPcD9bPbH5jVLsT-m2e5vw,5484
+compressedfhir/fhir/fhir_resource_list.py,sha256=l0QQf1YEgfJorwjO2ojRWppWnk8BAdCDP6Gb7y2EfXw,4695
+compressedfhir/fhir/fhir_resource_map.py,sha256=XFJ0o5_kLUeHYKp1q_Bxsoyp2-rLX7P4c9FwQ7YfGWM,6571
+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=nsSLs-sKDaYpoTVyXuBNnKJ0-somxDNX368lpTf3HUw,3828
+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=hn-ZuDrTEdYZmILk_5_k4R72PQB_OHYXo_3eTKTO24c,1856
+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=R2-4AnVi2QeasRHWS0katxifOpWMx3iNMkif7n_V09Q,22472
+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=mEdtJjPX2I9DqP0Ly_VsZZWhEMNTI1psqQ8iJtUQ2oE,1412
+compressedfhir/utilities/compressed_dict/v1/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py,sha256=5yUnjkmP3A4dSPzDXY3u1YBQ8BxCANdtCF9uGF1T9i4,15840
+compressedfhir/utilities/json_serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/json_serializers/type_preservation_decoder.py,sha256=3s9oc_gMWCgBxV_PYkHMMknLWzpEYn09FaJw9s8E-A4,5388
+compressedfhir/utilities/json_serializers/type_preservation_encoder.py,sha256=tJ6HnrwxRqyqYBYxpfHXZ6EzKyTPgbWZE9QJZCYLYdM,1814
+compressedfhir/utilities/json_serializers/type_preservation_serializer.py,sha256=cE1ka2RxKy_8P0xhgqvPyWqJ3C0Br-aqIHP9BPkCg7A,1523
+compressedfhir/utilities/json_serializers/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/json_serializers/test/test_type_preservation_decoder.py,sha256=tmCOZUo6nmnzzxEY0m3-l5szSBRwXovH5z1JOx_AUiE,5199
+compressedfhir/utilities/json_serializers/test/test_type_preservation_encoder.py,sha256=Kr_DFRFm0FtOWMts6sT4r95q0XXeTggQTSgTpAl6p_s,2151
+compressedfhir/utilities/json_serializers/test/test_type_preservation_serializer.py,sha256=rRnd1K1cyIHA2101_ip5bE-s6syBhyiIyoVB_-FKs8c,7485
+compressedfhir/utilities/ordered_dict_to_dict_converter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/ordered_dict_to_dict_converter/ordered_dict_to_dict_converter.py,sha256=CMerJQD7O0vMyGtUp1rKSerZA1tDZeY5GTQT3AykL4w,831
+compressedfhir/utilities/string_compressor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/string_compressor/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/string_compressor/v1/string_compressor.py,sha256=28CvEJPQVKS56S9YPdVM1i-xWEuizYeyKiICWEYOV0k,3263
+compressedfhir/utilities/string_compressor/v1/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/string_compressor/v1/test/test_string_compressor.py,sha256=ydlJIpp-IDPcLlv4YvxMph19OndLEt3kuNQ9buNwy0Y,5473
+compressedfhir/utilities/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir/utilities/test/test_fhir_json_encoder.py,sha256=6pbNmZp5eBWY66bHjgjm_pZVhs5HDKP8hCGnwNFzpEw,5171
+compressedfhir/utilities/test/test_json_helpers.py,sha256=V0R9oHDQAs0m0012niEz50sHJxMSUQvA3km7kK8HgjE,3860
+compressedfhir-3.0.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compressedfhir-3.0.2.dist-info/METADATA,sha256=EiSwprNhB0joRLZoTZPhTHZVn3vKM7CPgRgnw_QN3YQ,3456
+compressedfhir-3.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+compressedfhir-3.0.2.dist-info/top_level.txt,sha256=YMKdvBBdiCzFbpI9fG8BUDjaRd-f4R0qAvUoVETpoWw,21
+compressedfhir-3.0.2.dist-info/RECORD,,

compressedfhir-3.0.2.dist-info/WHEEL

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