compressedfhir 1.0.4__tar.gz → 1.0.5__tar.gz

{compressedfhir-1.0.4 → compressedfhir-1.0.5}/Makefile

@@ -73,3 +73,21 @@ help: ## Show this help.
 pipenv-setup:devdocker ## Run pipenv-setup to update setup.py with latest dependencies
 	docker compose run --rm dev sh -c "pipenv run pipenv install --skip-lock --categories \"pipenvsetup\" && pipenv run pipenv-setup sync --pipfile" && \
 	make run-pre-commit
+
+.PHONY: coverage
+coverage: up ## Run code coverage and generate reports
+	mkdir -p reports
+	docker compose run --rm \
+        -v $(PWD)/reports:/reports \
+        --name compressedfhir_coverage \
+        dev pytest \
+        --cov=. \
+        --cov-report=term-missing \
+        --cov-report=xml:/reports/coverage.xml \
+        --cov-report=html:/reports/htmlcov \
+        --cov-fail-under=80 \
+        tests compressedfhir
+
+.PHONY: clean-coverage
+clean-coverage: ## Remove coverage reports
+	rm -rf reports/coverage.xml reports/htmlcov .coverage

{compressedfhir-1.0.4/compressedfhir.egg-info → compressedfhir-1.0.5}/PKG-INFO

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

compressedfhir-1.0.5/VERSION

@@ -0,0 +1 @@
+1.0.5

{compressedfhir-1.0.4 → compressedfhir-1.0.5}/compressedfhir/fhir/fhir_resource.py

@@ -61,14 +61,10 @@ class FhirResource(CompressedDict[str, Any]):
             else None
         )
 
-    def json(self) -> str:
-        """Convert the resource to a JSON string."""
-        return json.dumps(obj=self.dict(), cls=FhirJSONEncoder)
-
     def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirResource":
         """Create a copy of the resource."""
         return FhirResource(
-            initial_dict=super().dict(),
+            initial_dict=super().raw_dict(),
             storage_mode=self._storage_mode,
         )
 
@@ -84,29 +80,6 @@ class FhirResource(CompressedDict[str, Any]):
         """
         return copy.deepcopy(self)
 
-    @override
-    def dict(self, *, remove_nulls: bool = True) -> OrderedDict[str, Any]:
-        """
-        Converts the FhirResource object to a dictionary.
-
-        :param remove_nulls: If True, removes None values from the dictionary.
-        :return: A dictionary representation of the FhirResource object.
-        """
-        ordered_dict = super().dict()
-        result: OrderedDict[str, Any] = copy.deepcopy(ordered_dict)
-        if remove_nulls:
-            result = FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(
-                result
-            )
-
-        return result
-
-    def remove_nulls(self) -> None:
-        """
-        Removes None values from the resource dictionary.
-        """
-        self.replace(value=self.dict(remove_nulls=True))
-
     @property
     def id(self) -> Optional[str]:
         """Get the ID from the resource dictionary."""
@@ -171,3 +144,15 @@ class FhirResource(CompressedDict[str, Any]):
                 properties_to_cache=properties_to_cache,
             ),
         )
+
+    @override
+    def json(self) -> str:
+        """Convert the resource to a JSON string."""
+
+        # working_dict preserves the python types so create a fhir friendly version
+        raw_dict: OrderedDict[str, Any] = self.raw_dict()
+
+        raw_dict = FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(
+            raw_dict
+        )
+        return json.dumps(obj=raw_dict, cls=FhirJSONEncoder)

{compressedfhir-1.0.4 → compressedfhir-1.0.5}/compressedfhir/fhir/fhir_resource_map.py

@@ -43,7 +43,7 @@ class FhirResourceMap:
         """
         result: OrderedDict[str, Any] = OrderedDict[str, Any]()
         for key, value in self._resource_map.items():
-            result[key] = [resource.dict(remove_nulls=True) for resource in value]
+            result[key] = [resource.dict() for resource in value]
         return result
 
     def get(self, *, resource_type: str) -> Optional[FhirResourceList]:

compressedfhir-1.0.5/compressedfhir/fhir/test/test_fhir_resource.py

@@ -0,0 +1,104 @@
+import json
+from typing import Dict, Any
+
+from compressedfhir.fhir.fhir_resource import FhirResource
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+
+
+class TestFhirResource:
+    def test_init_empty(self) -> None:
+        """Test initializing FhirResource with no initial dictionary."""
+        resource = FhirResource(storage_mode=CompressedDictStorageMode())
+        assert len(resource) == 0
+        assert resource.resource_type is None
+        assert resource.id is None
+        assert resource.resource_type_and_id is None
+
+    def test_init_with_data(self) -> None:
+        """Test initializing FhirResource with a dictionary."""
+        initial_data: Dict[str, Any] = {
+            "resourceType": "Patient",
+            "id": "123",
+            "name": [{"given": ["John"]}],
+        }
+        resource = FhirResource(
+            initial_dict=initial_data, storage_mode=CompressedDictStorageMode()
+        )
+
+        with resource.transaction():
+            assert resource.resource_type == "Patient"
+            assert resource.id == "123"
+            assert resource.resource_type_and_id == "Patient/123"
+            assert resource["name"][0]["given"][0] == "John"
+
+    def test_resource_type_and_id_property(self) -> None:
+        """Test resource_type_and_id property with various scenarios."""
+        # Scenario 1: Both resource type and id present
+        resource1 = FhirResource(
+            initial_dict={"resourceType": "Observation", "id": "456"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1.resource_type_and_id == "Observation/456"
+
+        # Scenario 2: Missing resource type
+        resource2 = FhirResource(
+            initial_dict={"id": "789"}, storage_mode=CompressedDictStorageMode()
+        )
+        assert resource2.resource_type_and_id is None
+
+        # Scenario 3: Missing id
+        resource3 = FhirResource(
+            initial_dict={"resourceType": "Patient"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource3.resource_type_and_id is None
+
+    def test_equality(self) -> None:
+        """Test equality comparison between FhirResource instances."""
+        # Scenario 1: Equal resources
+        resource1 = FhirResource(
+            initial_dict={"resourceType": "Patient", "id": "123"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        resource2 = FhirResource(
+            initial_dict={"resourceType": "Patient", "id": "123"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1 == resource2
+
+        # Scenario 2: Different resource types
+        resource3 = FhirResource(
+            initial_dict={"resourceType": "Observation", "id": "123"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1 != resource3
+
+        # Scenario 3: Different ids
+        resource4 = FhirResource(
+            initial_dict={"resourceType": "Patient", "id": "456"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1 != resource4
+
+        # Scenario 4: Comparing with non-FhirResource
+        assert resource1 != "Not a FhirResource"
+
+    def test_to_json(self) -> None:
+        """Test JSON serialization of FhirResource."""
+        initial_data: Dict[str, Any] = {
+            "resourceType": "Patient",
+            "id": "123",
+            "name": [{"given": ["John"]}],
+        }
+        resource = FhirResource(
+            initial_dict=initial_data, storage_mode=CompressedDictStorageMode()
+        )
+
+        json_str = resource.json()
+        parsed_json = json.loads(json_str)
+
+        assert parsed_json == initial_data
+        assert "resourceType" in parsed_json
+        assert "id" in parsed_json

{compressedfhir-1.0.4 → compressedfhir-1.0.5}/compressedfhir/utilities/compressed_dict/v1/compressed_dict.py

@@ -1,4 +1,5 @@
 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
@@ -13,6 +14,7 @@ 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,
 )
@@ -423,19 +425,43 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         """
         return self._get_dict().items()
 
-    def dict(self, *, remove_nulls: bool = True) -> OrderedDict[K, V]:
+    def raw_dict(self) -> OrderedDict[K, V]:
         """
-        Convert to a standard dictionary
+        Returns the raw dictionary.  Deserializes if necessary.
+        Note that this dictionary preserves the python types so it is not FHIR friendly.
+        Use dict() if you want a FHIR friendly version.
 
         Returns:
-            Standard dictionary with all values
+            raw dictionary
         """
         if self._working_dict:
             return self._working_dict
         else:
-            # if the working dict is None, return it but don't store it in the self._working_dict to keep memory low
+            # if the working dict is not None, return it but don't store it in the self._working_dict to keep memory low
             return self.create_working_dict()
 
+    def dict(self) -> OrderedDict[K, V]:
+        """
+        Convert to a FHIR friendly dictionary where the python types like datetime are converted to string versions
+
+        Returns:
+            FHIR friendly dictionary
+        """
+        return cast(
+            OrderedDict[K, V],
+            json.loads(
+                self.json(),
+                object_pairs_hook=lambda pairs: OrderedDict(pairs),
+            ),
+        )
+
+    def json(self) -> str:
+        """Convert the resource to a JSON string."""
+
+        raw_dict: OrderedDict[K, V] = self.raw_dict()
+
+        return json.dumps(obj=raw_dict, cls=FhirJSONEncoder)
+
     def __repr__(self) -> str:
         """
         String representation of the dictionary
@@ -559,7 +585,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         """
         # Create a new instance with the same storage mode
         new_instance = CompressedDict(
-            initial_dict=copy.deepcopy(self.dict()),
+            initial_dict=copy.deepcopy(self.raw_dict()),
             storage_mode=self._storage_mode,
             properties_to_cache=self._properties_to_cache,
         )
@@ -633,7 +659,7 @@ class CompressedDict[K, V](MutableMapping[K, V]):
         Returns:
             Plain dictionary
         """
-        return OrderedDictToDictConverter.convert(self.dict())
+        return OrderedDictToDictConverter.convert(self.raw_dict())
 
     @classmethod
     def from_json(cls, json_str: str) -> "CompressedDict[K, V]":

{compressedfhir-1.0.4 → compressedfhir-1.0.5}/compressedfhir/utilities/compressed_dict/v1/test/test_compressed_dict.py

@@ -234,7 +234,7 @@ def test_transaction_basic_raw_storage() -> None:
 
     # After transaction
     assert compressed_dict._transaction_depth == 0
-    assert compressed_dict.dict() == {
+    assert compressed_dict.raw_dict() == {
         "key1": "value1",
         "key2": "value2",
         "key3": "value3",
@@ -262,7 +262,7 @@ def test_transaction_nested_context() -> None:
         assert compressed_dict._transaction_depth == 1
 
     assert compressed_dict._transaction_depth == 0
-    assert compressed_dict.dict() == {"key1": "value1", "key2": "value2"}
+    assert compressed_dict.raw_dict() == {"key1": "value1", "key2": "value2"}
 
 
 def test_transaction_access_error() -> None:
@@ -311,7 +311,7 @@ def test_transaction_different_storage_modes() -> None:
         with compressed_dict.transaction() as d:
             d["key2"] = "value2"
 
-        assert compressed_dict.dict() == {"key1": "value1", "key2": "value2"}
+        assert compressed_dict.raw_dict() == {"key1": "value1", "key2": "value2"}
 
 
 def test_transaction_with_properties_to_cache() -> None:
@@ -330,7 +330,7 @@ def test_transaction_with_properties_to_cache() -> None:
     with compressed_dict.transaction() as d:
         d["key2"] = "value2"
 
-    assert compressed_dict.dict() == {
+    assert compressed_dict.raw_dict() == {
         "key1": "value1",
         "important_prop": "cached_value",
         "key2": "value2",

{compressedfhir-1.0.4 → compressedfhir-1.0.5/compressedfhir.egg-info}/PKG-INFO

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

compressedfhir-1.0.4/VERSION

@@ -1 +0,0 @@
-1.0.4

compressedfhir-1.0.4/compressedfhir/fhir/test/test_fhir_resource.py

@@ -1,225 +0,0 @@
-import json
-from typing import Dict, Any
-
-from compressedfhir.fhir.fhir_resource import FhirResource
-from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
-    CompressedDictStorageMode,
-)
-
-
-class TestFhirResource:
-    def test_init_empty(self) -> None:
-        """Test initializing FhirResource with no initial dictionary."""
-        resource = FhirResource(storage_mode=CompressedDictStorageMode())
-        assert len(resource) == 0
-        assert resource.resource_type is None
-        assert resource.id is None
-        assert resource.resource_type_and_id is None
-
-    def test_init_with_data(self) -> None:
-        """Test initializing FhirResource with a dictionary."""
-        initial_data: Dict[str, Any] = {
-            "resourceType": "Patient",
-            "id": "123",
-            "name": [{"given": ["John"]}],
-        }
-        resource = FhirResource(
-            initial_dict=initial_data, storage_mode=CompressedDictStorageMode()
-        )
-
-        with resource.transaction():
-            assert resource.resource_type == "Patient"
-            assert resource.id == "123"
-            assert resource.resource_type_and_id == "Patient/123"
-            assert resource["name"][0]["given"][0] == "John"
-
-    def test_resource_type_and_id_property(self) -> None:
-        """Test resource_type_and_id property with various scenarios."""
-        # Scenario 1: Both resource type and id present
-        resource1 = FhirResource(
-            initial_dict={"resourceType": "Observation", "id": "456"},
-            storage_mode=CompressedDictStorageMode(),
-        )
-        assert resource1.resource_type_and_id == "Observation/456"
-
-        # Scenario 2: Missing resource type
-        resource2 = FhirResource(
-            initial_dict={"id": "789"}, storage_mode=CompressedDictStorageMode()
-        )
-        assert resource2.resource_type_and_id is None
-
-        # Scenario 3: Missing id
-        resource3 = FhirResource(
-            initial_dict={"resourceType": "Patient"},
-            storage_mode=CompressedDictStorageMode(),
-        )
-        assert resource3.resource_type_and_id is None
-
-    def test_equality(self) -> None:
-        """Test equality comparison between FhirResource instances."""
-        # Scenario 1: Equal resources
-        resource1 = FhirResource(
-            initial_dict={"resourceType": "Patient", "id": "123"},
-            storage_mode=CompressedDictStorageMode(),
-        )
-        resource2 = FhirResource(
-            initial_dict={"resourceType": "Patient", "id": "123"},
-            storage_mode=CompressedDictStorageMode(),
-        )
-        assert resource1 == resource2
-
-        # Scenario 2: Different resource types
-        resource3 = FhirResource(
-            initial_dict={"resourceType": "Observation", "id": "123"},
-            storage_mode=CompressedDictStorageMode(),
-        )
-        assert resource1 != resource3
-
-        # Scenario 3: Different ids
-        resource4 = FhirResource(
-            initial_dict={"resourceType": "Patient", "id": "456"},
-            storage_mode=CompressedDictStorageMode(),
-        )
-        assert resource1 != resource4
-
-        # Scenario 4: Comparing with non-FhirResource
-        assert resource1 != "Not a FhirResource"
-
-    def test_to_json(self) -> None:
-        """Test JSON serialization of FhirResource."""
-        initial_data: Dict[str, Any] = {
-            "resourceType": "Patient",
-            "id": "123",
-            "name": [{"given": ["John"]}],
-        }
-        resource = FhirResource(
-            initial_dict=initial_data, storage_mode=CompressedDictStorageMode()
-        )
-
-        json_str = resource.json()
-        parsed_json = json.loads(json_str)
-
-        assert parsed_json == initial_data
-        assert "resourceType" in parsed_json
-        assert "id" in parsed_json
-
-
-class TestFhirResourceRemoveNulls:
-    def test_remove_nulls_simple_dict(self) -> None:
-        """
-        Test removing None values from a simple dictionary
-        """
-        initial_dict: Dict[str, Any] = {
-            "name": "John Doe",
-            "age": None,
-            "active": True,
-            "email": None,
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            # Check that None values are removed
-            assert "age" not in resource
-            assert "email" not in resource
-            assert resource.get("name") == "John Doe"
-            assert resource.get("active") is True
-
-    def test_remove_nulls_nested_dict(self) -> None:
-        """
-        Test removing None values from a nested dictionary
-        """
-        initial_dict: Dict[str, Any] = {
-            "patient": {
-                "name": "Jane Smith",
-                "contact": None,
-                "address": {"street": None, "city": "New York"},
-            },
-            "status": None,
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert "status" not in resource
-            assert "contact" not in resource.get("patient", {})
-            assert resource.get("patient", {}).get("address", {}).get("street") is None
-            assert (
-                resource.get("patient", {}).get("address", {}).get("city") == "New York"
-            )
-
-    def test_remove_nulls_list_of_dicts(self) -> None:
-        """
-        Test removing None values from a list of dictionaries
-        """
-        initial_dict: Dict[str, Any] = {
-            "patients": [
-                {"name": "Alice", "age": None},
-                {"name": "Bob", "age": 30},
-                {"name": None, "active": False},
-            ]
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert len(resource.get("patients", [])) == 3
-            assert resource.get("patients", [])[0].get("name") == "Alice"
-            assert resource.get("patients", [])[1].get("name") == "Bob"
-            assert resource.get("patients", [])[1].get("age") == 30
-
-    def test_remove_nulls_empty_dict(self) -> None:
-        """
-        Test removing None values from an empty dictionary
-        """
-        resource = FhirResource(initial_dict={})
-        resource.remove_nulls()
-
-        assert len(resource) == 0
-
-    def test_remove_nulls_no_changes(self) -> None:
-        """
-        Test removing None values when no None values exist
-        """
-        initial_dict: Dict[str, Any] = {
-            "name": "Test User",
-            "active": True,
-            "score": 100,
-        }
-        resource = FhirResource(initial_dict=initial_dict)
-        original_dict = resource.copy()
-        resource.remove_nulls()
-
-        assert resource == original_dict
-
-    def test_remove_nulls_with_custom_storage_mode(self) -> None:
-        """
-        Test removing None values with a custom storage mode
-        """
-        initial_dict: Dict[str, Any] = {
-            "name": "Custom Mode User",
-            "email": None,
-            "active": True,
-        }
-        resource = FhirResource(
-            initial_dict=initial_dict, storage_mode=CompressedDictStorageMode.default()
-        )
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert "email" not in resource
-            assert resource.get("name") == "Custom Mode User"
-            assert resource.get("active") is True
-
-    def test_remove_nulls_preserves_false_and_zero_values(self) -> None:
-        """
-        Test that False and 0 values are not removed
-        """
-        initial_dict: Dict[str, Any] = {"active": False, "score": 0, "name": None}
-        resource = FhirResource(initial_dict=initial_dict)
-        resource.remove_nulls()
-
-        with resource.transaction():
-            assert resource.get("active") is False
-            assert resource.get("score") == 0
-            assert "name" not in resource