compressedfhir 0.0.1__py3-none-any.whl

compressedfhir/fhir/fhir_resource_list.py

@@ -0,0 +1,143 @@
+from typing import (
+    List,
+    Set,
+    Optional,
+    AsyncGenerator,
+    cast,
+    Generator,
+    Dict,
+    override,
+    Iterable,
+)
+
+from compressedfhir.fhir.base_resource_list import BaseResourceList
+from compressedfhir.fhir.fhir_resource import FhirResource
+
+
+class FhirResourceList(BaseResourceList[FhirResource]):
+    """
+    Represents a list of FHIR resources.
+    """
+
+    __slots__: List[str] = BaseResourceList.__slots__
+
+    def get_resource_type_and_ids(self) -> List[str]:
+        """
+        Get the resource type and IDs of the resources in the list.
+
+        :return: A list of strings representing the resource type and IDs.
+        """
+        resource_type_and_ids: List[str] = []
+        for resource in self:
+            resource_type_and_ids.append(f"{resource.resource_type}/{resource.id}")
+        return resource_type_and_ids
+
+    def get_operation_outcomes(self) -> "FhirResourceList":
+        """
+        Gets the operation outcomes from the response
+
+        :return: list of operation outcomes
+        """
+        return FhirResourceList(
+            [r for r in self if r.resource_type == "OperationOutcome"]
+        )
+
+    def get_resources_except_operation_outcomes(self) -> "FhirResourceList":
+        """
+        Gets the normal FHIR resources by skipping any OperationOutcome resources
+
+        :return: list of valid resources
+        """
+        return FhirResourceList(
+            [r for r in self if r.resource_type != "OperationOutcome"]
+        )
+
+    def remove_duplicates(self) -> None:
+        """
+        removes duplicate resources from the response i.e., resources with same resourceType and id
+
+        """
+
+        # remove duplicates from the list if they have the same resourceType and id
+        seen: Set[str] = set()
+        i = 0
+        while i < len(self):
+            # Create a tuple of values for specified keys
+            comparison_key = self[i].resource_type_and_id
+
+            if not comparison_key:
+                # Skip if resourceType or id is None
+                i += 1
+                continue
+
+            if comparison_key in seen or self[i].id is None:
+                # Remove duplicate entry
+                self.remove(self[i])
+            else:
+                seen.add(comparison_key)
+                i += 1
+
+    async def consume_resource_batch_async(
+        self,
+        *,
+        batch_size: Optional[int],
+    ) -> AsyncGenerator["FhirResourceList", None]:
+        async for r in super().consume_resource_batch_async(batch_size=batch_size):
+            yield cast(FhirResourceList, r)
+
+    def consume_resource_batch(
+        self,
+        *,
+        batch_size: Optional[int],
+    ) -> Generator["FhirResourceList", None, None]:
+        for r in super().consume_resource_batch(batch_size=batch_size):
+            yield cast(FhirResourceList, r)
+
+    def get_count_by_resource_type(self) -> Dict[str, int]:
+        """
+        Gets the count of resources by resource type.
+
+        :return: The count of resources by resource type
+        """
+        resources_by_type: Dict[str, int] = dict()
+        if len(self) == 0:
+            return resources_by_type
+
+        entry: 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:
+                resources_by_type[resource_type] = 0
+            resources_by_type[resource_type] += 1
+        return resources_by_type
+
+    @override
+    def append(self, x: FhirResource, /) -> None:
+        """
+        Append an entry to the FhirBundleEntryList.
+
+        :param x: The entry to append.
+        """
+        if not isinstance(x, FhirResource):
+            raise TypeError("Only FhirBundleEntry instances can be appended.")
+
+        # check that we don't have a duplicate entry
+        key: Optional[str] = x.resource_type_and_id
+        if key is None:
+            super().append(x)
+        else:
+            for entry in self:
+                if entry.resource_type_and_id == key:
+                    # we have a duplicate entry
+                    return
+            super().append(x)
+
+    @override
+    def extend(self, iterable: Iterable[FhirResource], /) -> None:
+        """
+        Extend the FhirBundleEntryList with entries from an iterable.
+
+        :param iterable: The iterable containing entries to extend.
+        """
+        for entry in iterable:
+            self.append(entry)

compressedfhir/fhir/fhir_resource_map.py

@@ -0,0 +1,193 @@
+import json
+from typing import (
+    Any,
+    Optional,
+    Dict,
+    Deque,
+    AsyncGenerator,
+    Generator,
+    List,
+    Tuple,
+    OrderedDict,
+)
+
+from compressedfhir.fhir.fhir_resource_list import FhirResourceList
+
+
+class FhirResourceMap:
+    """
+    FhirResourceMap is a class that represents a map of FHIR resources.
+    Each key is a string representing the resource type, and the value is a deque of FhirResource objects.
+    """
+
+    __slots__ = [
+        "_resource_map",
+    ]
+
+    def __init__(
+        self,
+        initial_dict: Dict[str, FhirResourceList] | None = None,
+    ) -> None:
+        """
+        This class represents a map of FHIR resources, where each key is a string
+        and the value is a deque of FhirResource objects.
+
+        :param initial_dict: A dictionary where the keys are strings and the values
+        """
+        self._resource_map: Dict[str, FhirResourceList] = initial_dict or {}
+
+    def dict(self) -> OrderedDict[str, Any]:
+        """
+        Convert the FhirResourceMap to a dictionary representation.
+
+        """
+        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]
+        return result
+
+    def get(self, *, resource_type: str) -> Optional[FhirResourceList]:
+        """
+        Get the FHIR resources for a specific resource type.
+
+        :param resource_type: The resource type to retrieve.
+        :return: A deque of FhirResource objects or None if not found.
+        """
+        return self._resource_map.get(resource_type, None)
+
+    async def consume_resource_async(
+        self,
+    ) -> AsyncGenerator[Dict[str, FhirResourceList], None]:
+        while self._resource_map:
+            # Get the first key
+            resource_type: str = next(iter(self._resource_map))
+            # Pop and process the item
+            resources_for_resource_type: FhirResourceList = self._resource_map.pop(
+                resource_type
+            )
+            yield {
+                resource_type: resources_for_resource_type,
+            }
+
+    def consume_resource(self) -> Generator[Dict[str, FhirResourceList], None, None]:
+        while self._resource_map:
+            # Get the first key
+            resource_type: str = next(iter(self._resource_map))
+            # Pop and process the item
+            resources_for_resource_type: FhirResourceList = self._resource_map.pop(
+                resource_type
+            )
+            yield {
+                resource_type: resources_for_resource_type,
+            }
+
+    def get_resources(self) -> FhirResourceList:
+        """
+        Get all resources in the map.
+
+        :return: A deque of FhirResource objects.
+        """
+        resources: FhirResourceList = FhirResourceList()
+        for resource_type, resource_list in self._resource_map.items():
+            resources.extend(resource_list)
+        return resources
+
+    def __setitem__(self, key: str, value: FhirResourceList) -> None:
+        """Set the value for a specific key in the resource map."""
+        if not isinstance(value, Deque):
+            raise TypeError("Value must be a deque of FhirResource objects.")
+        self._resource_map[key] = value
+
+    def __getitem__(self, key: str) -> FhirResourceList:
+        """Get the value for a specific key in the resource map."""
+        return self._resource_map[key]
+
+    def __delitem__(self, key: str) -> None:
+        """Delete a key-value pair from the resource map."""
+        if key in self._resource_map:
+            del self._resource_map[key]
+        else:
+            raise KeyError(f"Key '{key}' not found in resource map.")
+
+    def __contains__(self, key: str) -> bool:
+        """Check if a key exists in the resource map."""
+        return key in self._resource_map
+
+    def items(self) -> List[Tuple[str, FhirResourceList]]:
+        """Get all items in the resource map."""
+        return [(k, v) for k, v in self._resource_map.items()]
+
+    def get_resource_count(self) -> int:
+        return sum(len(resources) for resources in self._resource_map.values())
+
+    def clear(self) -> None:
+        """Clear the resource map."""
+        self._resource_map.clear()
+
+    def get_resource_type_and_ids(self) -> List[str]:
+        """
+        Get the resource type and IDs of the resources in the map.
+
+        :return: A list of strings representing the resource type and IDs.
+        """
+        resource_type_and_ids: List[str] = []
+        for resource_type, resources in self._resource_map.items():
+            for resource in resources:
+                resource_type_and_ids.append(f"{resource_type}/{resource['id']}")
+        return resource_type_and_ids
+
+    def get_operation_outcomes(self) -> FhirResourceList:
+        """
+        Gets the operation outcomes from the response
+
+        :return: list of operation outcomes
+        """
+        return (
+            self._resource_map["OperationOutcome"]
+            if "OperationOutcome" in self._resource_map
+            else FhirResourceList()
+        )
+
+    def get_resources_except_operation_outcomes(self) -> FhirResourceList:
+        """
+        Gets the normal FHIR resources by skipping any OperationOutcome resources
+
+        :return: list of valid resources
+        """
+        combined_resources: FhirResourceList = FhirResourceList()
+        for resource_type, resources in self._resource_map.items():
+            if resource_type != "OperationOutcome":
+                combined_resources.extend(resources)
+        return combined_resources
+
+    def json(self) -> str:
+        """
+        Convert the list of FhirResource objects to a JSON string.
+
+        :return: JSON string representation of the list.
+        """
+        return json.dumps(self.dict())
+
+    def get_count_of_resource_types(self) -> int:
+        """
+        Get the count of unique resource types in the map.
+
+        :return: The count of unique resource types.
+        """
+        return len(self._resource_map)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirResourceMap":
+        """
+        Create a copy of the FhirResourceMap.
+
+        :return: A new FhirResourceMap object with the same attributes.
+        """
+        return FhirResourceMap(initial_dict=self._resource_map.copy())
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the FhirResourceMap.
+
+        :return: String representation of the FhirResourceMap.
+        """
+        return f"FhirResourceMap(keys: {len(self._resource_map.keys())})"

compressedfhir/fhir/test/test_bundle_entry.py

@@ -0,0 +1,129 @@
+from datetime import datetime, timezone
+
+from compressedfhir.fhir.fhir_bundle_entry import FhirBundleEntry
+from compressedfhir.fhir.fhir_bundle_entry_request import FhirBundleEntryRequest
+from compressedfhir.fhir.fhir_bundle_entry_response import (
+    FhirBundleEntryResponse,
+)
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+
+
+class TestBundleEntry:
+    def test_init_minimal(self) -> None:
+        """Test initialization with minimal parameters."""
+        entry = FhirBundleEntry(
+            resource={"resourceType": "Patient"},
+            request=None,
+            response=None,
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert entry.resource is not None
+        with entry.resource.transaction():
+            assert entry.resource.dict() == {"resourceType": "Patient"}
+            assert entry.request is None
+            assert entry.response is None
+            assert entry.fullUrl is None
+
+    def test_init_full(self) -> None:
+        """Test initialization with all parameters."""
+        resource = {"resourceType": "Patient", "id": "123"}
+        request = FhirBundleEntryRequest(url="https://example.com")
+        response = FhirBundleEntryResponse(status="200", etag=None, lastModified=None)
+
+        entry = FhirBundleEntry(
+            resource=resource,
+            request=request,
+            response=response,
+            fullUrl="https://example.com/Patient/123",
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert entry.resource is not None
+        with entry.resource.transaction():
+            assert entry.resource.dict() == resource
+            assert entry.request == request
+            assert entry.response == response
+            assert entry.fullUrl == "https://example.com/Patient/123"
+
+    def test_to_dict_minimal(self) -> None:
+        """Test converting to dictionary with minimal parameters."""
+        entry = FhirBundleEntry(
+            resource={"resourceType": "Patient"},
+            request=None,
+            response=None,
+            storage_mode=CompressedDictStorageMode(),
+        )
+        result = entry.dict()
+        assert result == {"resource": {"resourceType": "Patient"}}
+
+    def test_to_dict_full(self) -> None:
+        """Test converting to dictionary with all parameters."""
+        resource = {"resourceType": "Patient", "id": "123"}
+        request = FhirBundleEntryRequest(url="https://example.com")
+        response = FhirBundleEntryResponse(status="200", etag=None, lastModified=None)
+
+        entry = FhirBundleEntry(
+            resource=resource,
+            request=request,
+            response=response,
+            fullUrl="https://example.com/Patient/123",
+            storage_mode=CompressedDictStorageMode(),
+        )
+        result = entry.dict()
+        assert result == {
+            "fullUrl": "https://example.com/Patient/123",
+            "resource": resource,
+            "request": request.dict(),
+            "response": response.dict(),
+        }
+
+    def test_from_dict_minimal(self) -> None:
+        """Test creating from dictionary with minimal parameters."""
+        data = {"resource": {"resourceType": "Patient"}}
+        entry = FhirBundleEntry.from_dict(
+            data, storage_mode=CompressedDictStorageMode()
+        )
+
+        assert entry.resource is not None
+        with entry.resource.transaction():
+            assert entry.resource.dict() == {"resourceType": "Patient"}
+            assert entry.request is None
+            assert entry.response is None
+            assert entry.fullUrl is None
+
+    def test_from_dict_full(self) -> None:
+        """Test creating from dictionary with all parameters."""
+        now = datetime.now(timezone.utc)
+        data = {
+            "fullUrl": "https://example.com/Patient/123",
+            "resource": {"resourceType": "Patient", "id": "123"},
+            "request": {"url": "https://example.com", "method": "GET"},
+            "response": {
+                "status": "200",
+                "lastModified": now.isoformat(),
+                "etag": 'W/"abc"',
+            },
+        }
+        entry = FhirBundleEntry.from_dict(
+            data, storage_mode=CompressedDictStorageMode()
+        )
+        assert entry.resource is not None
+        with entry.resource.transaction():
+            assert entry.fullUrl == "https://example.com/Patient/123"
+            assert entry.resource.dict() == {"resourceType": "Patient", "id": "123"}
+            assert entry.request is not None
+            assert entry.request.url == "https://example.com"
+            assert entry.response is not None
+            assert entry.response.status == "200"
+
+    def test_repr(self) -> None:
+        """Test string representation of BundleEntry."""
+        resource = {"resourceType": "Patient", "id": "123"}
+        entry = FhirBundleEntry(
+            resource=resource,
+            request=None,
+            response=None,
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert repr(entry) == "BundleEntry(Patient/123)"

compressedfhir/fhir/test/test_bundle_entry_list.py

@@ -0,0 +1,187 @@
+import pytest
+from compressedfhir.fhir.fhir_bundle_entry import FhirBundleEntry
+from compressedfhir.fhir.fhir_bundle_entry_list import FhirBundleEntryList
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+
+
+@pytest.mark.asyncio
+class TestFhirBundleEntryList:
+    async def test_consume_resource_async_with_none_batch_size(self) -> None:
+        """
+        Test consuming bundle entries when batch_size is None.
+        Each call should yield a single entry.
+        """
+        # Arrange
+        entries = [
+            FhirBundleEntry(
+                resource={"id": "1"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+            FhirBundleEntry(
+                resource={"id": "2"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+            FhirBundleEntry(
+                resource={"id": "3"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+        ]
+        bundle_list = FhirBundleEntryList(entries)
+
+        # Act
+        batches = []
+        async for batch in bundle_list.consume_resource_async(batch_size=None):
+            batches.append(batch)
+
+        # Assert
+        assert len(batches) == 3
+        assert all(len(batch) == 1 for batch in batches)
+        assert len(bundle_list) == 0  # All entries should be consumed
+
+    @pytest.mark.parametrize("batch_size", [1, 2, 3, 5])
+    async def test_consume_resource_async_with_valid_batch_sizes(
+        self, batch_size: int
+    ) -> None:
+        """
+        Test consuming bundle entries with various valid batch sizes.
+        """
+        # Arrange
+        entries = [
+            FhirBundleEntry(
+                resource={"id": "1"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+            FhirBundleEntry(
+                resource={"id": "2"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+            FhirBundleEntry(
+                resource={"id": "3"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+            FhirBundleEntry(
+                resource={"id": "4"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+            FhirBundleEntry(
+                resource={"id": "5"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+        ]
+        bundle_list = FhirBundleEntryList(entries)
+
+        # Act
+        batches = []
+        async for batch in bundle_list.consume_resource_async(batch_size=batch_size):
+            batches.append(batch)
+
+        # Assert
+        expected_batch_count = (len(entries) + batch_size - 1) // batch_size
+        assert len(batches) == expected_batch_count
+        assert all(len(batch) <= batch_size for batch in batches)
+        assert sum(len(batch) for batch in batches) == len(entries)
+        assert len(bundle_list) == 0  # All entries should be consumed
+
+    async def test_consume_resource_async_with_zero_batch_size(self) -> None:
+        """
+        Test that consuming with batch_size <= 0 raises a ValueError.
+        """
+        # Arrange
+        entries = [
+            FhirBundleEntry(
+                resource={"id": "1"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            )
+        ]
+        bundle_list = FhirBundleEntryList(entries)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="Batch size must be greater than 0."):
+            async for _ in bundle_list.consume_resource_async(batch_size=0):
+                pass
+
+    async def test_consume_resource_async_with_empty_list(self) -> None:
+        """
+        Test consuming an empty list.
+        """
+        # Arrange
+        bundle_list = FhirBundleEntryList()
+
+        # Act
+        batches = []
+        async for batch in bundle_list.consume_resource_async(batch_size=2):
+            batches.append(batch)
+
+        # Assert
+        assert len(batches) == 0
+
+    def test_class_inheritance(self) -> None:
+        """
+        Verify that FhirBundleEntryList inherits from collections.deque
+        and supports deque operations.
+        """
+        # Arrange
+        entries = [
+            FhirBundleEntry(
+                resource={"id": "1"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+            FhirBundleEntry(
+                resource={"id": "2"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            ),
+        ]
+
+        # Act
+        bundle_list = FhirBundleEntryList(entries)
+
+        # Assert
+        assert len(bundle_list) == 2
+        bundle_list.append(
+            FhirBundleEntry(
+                resource={"id": "3"},
+                request=None,
+                response=None,
+                fullUrl=None,
+                storage_mode=CompressedDictStorageMode(),
+            )
+        )
+        assert len(bundle_list) == 3
+        resource = bundle_list.popleft().resource
+        assert resource is not None
+        assert resource.dict() == {"id": "1"}