compressedfhir 0.0.1__py3-none-any.whl

compressedfhir/fhir/base_resource_list.py

@@ -0,0 +1,165 @@
+import copy
+import json
+from contextlib import contextmanager
+from typing import (
+    Deque,
+    List,
+    AsyncGenerator,
+    Optional,
+    Any,
+    Dict,
+    Iterator,
+    override,
+    Iterable,
+    Generator,
+)
+
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict import (
+    CompressedDict,
+)
+from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
+
+
+class BaseResourceList[T: CompressedDict[str, Any]](Deque[T]):
+    """
+    Represents a list of FHIR resources.
+    """
+
+    __slots__: List[str] = []
+
+    def __init__(
+        self,
+        iterable: Iterable[T] | None = None,
+        maxlen: Optional[int] = None,
+    ) -> None:
+        # if iterable is not None:
+        # assert all([isinstance(r, CompressedDict) for r in iterable]), f"type {type(next(iter(iterable)))}"
+        super().__init__(iterable, maxlen=maxlen) if iterable else super().__init__()
+
+    @override
+    def append(self, x: T, /) -> None:
+        super().append(x)
+        # assert isinstance(x, CompressedDict), f"{type(x)} is not a CompressedDict"
+
+    def json(self) -> str:
+        """
+        Convert the list of FhirResource objects to a JSON string.
+
+        :return: JSON string representation of the list.
+        """
+        return json.dumps([r.dict() for r in self], cls=FhirJSONEncoder)
+
+    def get_resources(self) -> "BaseResourceList[T]":
+        """
+        Get all resources in the list.
+
+        :return: A list of FhirResource objects.
+        """
+        # this is here to keep compatibility with FhirResourceMap
+        return self
+
+    async def consume_resource_batch_async(
+        self,
+        *,
+        batch_size: Optional[int],
+    ) -> AsyncGenerator["BaseResourceList[T]", None]:
+        """
+        Consume resources in batches asynchronously.
+
+        :param batch_size: The size of each batch.
+        :return: An async generator yielding batches of FhirResourceList.
+        """
+        batch: BaseResourceList[T]
+        if batch_size is None:
+            batch = BaseResourceList[T]()
+            while self:
+                batch.append(self.popleft())
+            yield batch
+        elif batch_size <= 0:
+            raise ValueError("Batch size must be greater than 0.")
+        else:
+            while self:
+                batch = BaseResourceList[T]()
+                for _ in range(min(batch_size, len(self))):
+                    batch.append(self.popleft())
+                yield batch
+
+    def consume_resource_batch(
+        self,
+        *,
+        batch_size: Optional[int],
+    ) -> Generator["BaseResourceList[T]", None, None]:
+        """
+        Consume resources in batches asynchronously.
+
+        :param batch_size: The size of each batch.
+        :return: An async generator yielding batches of FhirResourceList.
+        """
+        batch: BaseResourceList[T]
+        if batch_size is None:
+            batch = BaseResourceList[T]()
+            while self:
+                batch.append(self.popleft())
+            yield batch
+        elif batch_size <= 0:
+            raise ValueError("Batch size must be greater than 0.")
+        else:
+            while self:
+                batch = BaseResourceList[T]()
+                for _ in range(min(batch_size, len(self))):
+                    batch.append(self.popleft())
+                yield batch
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "BaseResourceList[T]":
+        """
+        Create a copy of the FhirResourceList.
+
+        :return: A new FhirResourceList object with the same resources.
+        """
+        return BaseResourceList[T]([copy.deepcopy(r) for r in self])
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the FhirResourceList.
+
+        :return: A string representation of the FhirResourceList.
+        """
+        return f"FhirResourceList(resources: {len(self)})"
+
+    @contextmanager
+    def transaction(self) -> Iterator["BaseResourceList[T]"]:
+        """
+        Opens a transaction for all resources in the list.
+
+        Deserializes the dictionary before entering the context
+        Serializes the dictionary after exiting the context
+
+        Raises:
+            CompressedDictAccessError: If methods are called outside the context
+
+        """
+        try:
+            self.start_transaction()
+
+            yield self
+
+        finally:
+            self.end_transaction()
+
+    def start_transaction(self) -> "BaseResourceList[T]":
+        """
+        Starts a transaction for each resource in the list.  Use transaction() for a contextmanager for simpler usage.
+        """
+
+        for resource in self:
+            resource.start_transaction()
+        return self
+
+    def end_transaction(self) -> "BaseResourceList[T]":
+        """
+        Ends a transaction.  Use transaction() for a context_manager for simpler usage.
+
+        """
+        for resource in self:
+            resource.end_transaction()
+        return self

compressedfhir/fhir/fhir_bundle.py

@@ -0,0 +1,291 @@
+import copy
+import json
+from typing import Any, Dict, List, Optional, cast, OrderedDict
+
+from compressedfhir.fhir.fhir_bundle_entry import FhirBundleEntry
+from compressedfhir.fhir.fhir_bundle_entry_list import FhirBundleEntryList
+from compressedfhir.fhir.fhir_identifier import FhirIdentifier
+from compressedfhir.fhir.fhir_link import FhirLink
+from compressedfhir.fhir.fhir_meta import FhirMeta
+from compressedfhir.fhir.fhir_resource import FhirResource
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class FhirBundle:
+    """
+    FhirBundle represents a FHIR Bundle resource.
+    """
+
+    __slots__ = [
+        "entry",
+        "total",
+        "id_",
+        "identifier",
+        "timestamp",
+        "type_",
+        "link",
+        "meta",
+    ]
+
+    def __init__(
+        self,
+        *,
+        id_: Optional[str] = None,
+        identifier: Optional[FhirIdentifier] = None,
+        timestamp: Optional[str] = None,
+        type_: str,
+        entry: Optional[FhirBundleEntryList] = None,
+        total: Optional[int] = None,
+        link: Optional[List[FhirLink]] = None,
+        meta: Optional[FhirMeta] = None,
+    ) -> None:
+        """
+        Initializes a FhirBundle object.
+
+
+        :param id_: The ID of the Bundle.
+        :param identifier: The identifier of the Bundle.
+        :param timestamp: The timestamp of the Bundle.
+        :param type_: The type of the Bundle (e.g., "searchset").
+        :param entry: The entries in the Bundle.
+        :param total: The total number of entries in the Bundle.
+        :param link: The links associated with the Bundle.
+        :param meta: The metadata associated with the Bundle.
+        """
+        self.entry: FhirBundleEntryList = entry or FhirBundleEntryList()
+        self.total: Optional[int] = total
+        self.id_: Optional[str] = id_
+        self.identifier: Optional[FhirIdentifier] = identifier
+        self.timestamp: Optional[str] = timestamp
+        self.type_: str = type_
+        self.link: Optional[List[FhirLink]] = link
+        self.meta: Optional[FhirMeta] = meta
+
+    def dict(self) -> OrderedDict[str, Any]:
+        entries: List[Dict[str, Any]] | None = (
+            [entry.dict() for entry in self.entry] if self.entry else None
+        )
+        result: OrderedDict[str, Any] = OrderedDict[str, Any](
+            {"type": self.type_, "resourceType": "Bundle"}
+        )
+
+        if self.id_ is not None:
+            result["id"] = self.id_
+        if self.identifier is not None:
+            result["identifier"] = self.identifier.dict()
+        if self.timestamp is not None:
+            result["timestamp"] = self.timestamp
+        if self.total is not None:
+            result["total"] = self.total
+        if entries and len(entries) > 0:
+            result["entry"] = entries
+        if self.link:
+            result["link"] = [link.dict() for link in self.link]
+        if self.meta:
+            result["meta"] = self.meta.dict()
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    @classmethod
+    def construct(
+        cls,
+        *,
+        id_: Optional[str] = None,
+        identifier: Optional[FhirIdentifier] = None,
+        timestamp: Optional[str] = None,
+        type_: str,
+        entry: Optional[FhirBundleEntryList] = None,
+        total: Optional[int] = None,
+        link: Optional[List[FhirLink]] = None,
+        meta: Optional[FhirMeta] = None,
+    ) -> "FhirBundle":
+        """
+        Constructs a FhirBundle object from keyword arguments.
+
+        :param id_: The ID of the Bundle.
+        :param identifier: The identifier of the Bundle.
+        :param timestamp: The timestamp of the Bundle.
+        :param type_: The type of the Bundle (e.g., "searchset").
+        :param entry: The entries in the Bundle.
+        :param total: The total number of entries in the Bundle.
+        :param link: The links associated with the Bundle.
+        :param meta: The metadata associated with the Bundle.
+        """
+        return cls(
+            id_=id_,
+            identifier=identifier,
+            timestamp=timestamp,
+            type_=type_,
+            entry=entry,
+            total=total,
+            link=link,
+            meta=meta,
+        )
+
+    @classmethod
+    def from_dict(
+        cls,
+        data: OrderedDict[str, Any] | Dict[str, Any],
+        storage_mode: CompressedDictStorageMode,
+    ) -> "FhirBundle":
+        """
+        Creates a FhirBundle object from a dictionary.
+
+        :param data: A dictionary containing the Bundle data.
+        :param storage_mode: The storage mode for the Bundle.
+        :return: A FhirBundle object.
+        """
+        bundle = cls(
+            id_=data.get("id") if isinstance(data.get("id"), str) else None,
+            identifier=(
+                FhirIdentifier.from_dict(data["identifier"])
+                if "identifier" in data
+                else None
+            ),
+            timestamp=(
+                data.get("timestamp")
+                if isinstance(data.get("timestamp"), str)
+                else None
+            ),
+            type_=(
+                cast(str, data.get("type"))
+                if isinstance(data.get("type"), str)
+                else "collection"
+            ),
+            total=data.get("total") if isinstance(data.get("total"), int) else None,
+            entry=(
+                FhirBundleEntryList(
+                    [
+                        FhirBundleEntry.from_dict(entry, storage_mode=storage_mode)
+                        for entry in data.get("entry", [])
+                    ]
+                )
+                if "entry" in data
+                else FhirBundleEntryList()
+            ),
+            link=[FhirLink.from_dict(link) for link in data.get("link", [])],
+            meta=data.get("meta"),
+        )
+        return bundle
+
+    @staticmethod
+    def add_diagnostics_to_operation_outcomes(
+        *, resource: FhirResource, diagnostics_coding: List[Dict[str, Any]]
+    ) -> FhirResource:
+        """
+        Adds diagnostic coding to OperationOutcome resources to identify which call resulted in that OperationOutcome
+        being returned by the server
+
+
+        :param resource: The resource to add the diagnostics to
+        :param diagnostics_coding: The diagnostics coding to add
+        :return: The resource with the diagnostics added
+        """
+        with resource.transaction():
+            if resource.resource_type == "OperationOutcome":
+                issues = resource.get("issue")
+                if issues:
+                    for issue in issues:
+                        coding: List[Dict[str, Any]] = issue.setdefault(
+                            "details", {}
+                        ).setdefault("coding", [])
+                        coding.extend(diagnostics_coding)
+        return resource
+
+    def json(self) -> str:
+        """
+        Converts the Bundle to a JSON string.
+
+        :return: JSON string representation of the Bundle
+        """
+        bundle_dict = self.dict()
+        return json.dumps(bundle_dict, cls=FhirJSONEncoder)
+
+    def copy(self) -> "FhirBundle":
+        return copy.deepcopy(self)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirBundle":
+        """
+        Creates a copy of the Bundle.
+
+        :return: A new FhirBundle object with the same attributes
+        """
+        return FhirBundle(
+            entry=copy.deepcopy(self.entry) if self.entry else None,
+            total=self.total,
+            id_=self.id_,
+            identifier=copy.deepcopy(self.identifier) if self.identifier else None,
+            timestamp=self.timestamp,
+            type_=self.type_,
+            link=[copy.deepcopy(link) for link in self.link] if self.link else None,
+        )
+
+    def __repr__(self) -> str:
+        """
+        Returns a string representation of the Bundle.
+
+        :return: String representation of the Bundle
+        """
+        properties: List[str] = []
+        if self.id_:
+            properties.append(f"id_={self.id_}")
+        if self.type_:
+            properties.append(f"type_={self.type_}")
+        if self.timestamp:
+            properties.append(f"timestamp={self.timestamp}")
+        if self.total:
+            properties.append(f"total={self.total}")
+        if self.entry:
+            properties.append(f"entry={len(self.entry)}")
+        if self.link:
+            properties.append(f"link={len(self.link)}")
+
+        return f"FhirBundle({', '.join(properties)})"
+
+    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 self.entry is None:
+            return resources_by_type
+
+        entry: FhirBundleEntry
+        for entry in [e for e in self.entry if e is not None]:
+            if entry.resource is not None:
+                resource = entry.resource
+                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
+
+    @property
+    def id(self) -> Optional[str]:
+        """Get the ID of the Bundle."""
+        return self.id_
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        """Set the ID of the Bundle."""
+        self.id_ = value
+
+    @property
+    def resource_type(self) -> str:
+        """Get the resource type of the Bundle."""
+        return "Bundle"
+
+    def to_plain_dict(self) -> Dict[str, Any]:
+        """
+        Converts the Bundle to a plain dictionary.
+
+        :return: Plain dictionary representation of the Bundle
+        """
+        return cast(
+            Dict[str, Any], json.loads(json.dumps(self.dict(), cls=FhirJSONEncoder))
+        )

compressedfhir/fhir/fhir_bundle_entry.py

@@ -0,0 +1,234 @@
+import copy
+import json
+from typing import Any, Dict, Optional, List, OrderedDict
+
+from compressedfhir.fhir.fhir_bundle_entry_search import FhirBundleEntrySearch
+from compressedfhir.fhir.fhir_link import FhirLink
+from compressedfhir.fhir.fhir_bundle_entry_request import FhirBundleEntryRequest
+from compressedfhir.fhir.fhir_bundle_entry_response import (
+    FhirBundleEntryResponse,
+)
+from compressedfhir.fhir.fhir_resource import FhirResource
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict import (
+    CompressedDict,
+)
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class FhirBundleEntry:
+    """
+    Represents a single entry in a FHIR Bundle.
+    """
+
+    __slots__ = [
+        "_resource",
+        "request",
+        "response",
+        "fullUrl",
+        "link",
+        "search",
+        "storage_mode",
+    ]
+
+    # noinspection PyPep8Naming
+    def __init__(
+        self,
+        *,
+        fullUrl: Optional[str] = None,
+        resource: Dict[str, Any] | FhirResource | OrderedDict[str, Any] | None,
+        request: Optional[FhirBundleEntryRequest] = None,
+        response: Optional[FhirBundleEntryResponse] = None,
+        link: Optional[List[FhirLink]] = None,
+        search: Optional[FhirBundleEntrySearch] = None,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
+    ) -> None:
+        """
+        Initializes a BundleEntry object.
+
+        :param fullUrl: The full URL of the entry.
+        :param resource: The FHIR resource associated with the entry.
+        :param request: The request information associated with the entry.
+        :param response: The response information associated with the entry.
+        :param storage_mode: The storage mode for the resource.
+        """
+        self._resource: Optional[FhirResource] = (
+            resource
+            if isinstance(resource, CompressedDict)
+            else (
+                FhirResource(initial_dict=resource, storage_mode=storage_mode)
+                if resource is not None
+                else None
+            )
+        )
+        self.request: Optional[FhirBundleEntryRequest] = request
+        self.response: Optional[FhirBundleEntryResponse] = response
+        self.fullUrl: Optional[str] = fullUrl
+        self.link: Optional[List[FhirLink]] = link
+        self.search: Optional[FhirBundleEntrySearch] = search
+        self.storage_mode: CompressedDictStorageMode = storage_mode
+
+    # noinspection PyPep8Naming
+    @classmethod
+    def construct(
+        cls,
+        *,
+        fullUrl: Optional[str] = None,
+        resource: Dict[str, Any] | FhirResource | OrderedDict[str, Any] | None,
+        request: Optional[FhirBundleEntryRequest] = None,
+        response: Optional[FhirBundleEntryResponse] = None,
+        link: Optional[List[FhirLink]] = None,
+        search: Optional[FhirBundleEntrySearch] = None,
+        storage_mode: CompressedDictStorageMode = CompressedDictStorageMode.default(),
+    ) -> "FhirBundleEntry":
+        """
+        Constructs a BundleEntry object with the given parameters.
+
+        :param fullUrl: The full URL of the entry.
+        :param resource: The FHIR resource associated with the entry.
+        :param request: The request information associated with the entry.
+        :param response: The response information associated with the entry.
+        :param link: The links associated with the entry.
+        :param search: The search information associated with the entry.
+        :param storage_mode: The storage mode for the resource.
+        """
+        return cls(
+            fullUrl=fullUrl,
+            resource=resource,
+            request=request,
+            response=response,
+            link=link,
+            search=search,
+            storage_mode=storage_mode,
+        )
+
+    @property
+    def resource(self) -> Optional[FhirResource]:
+        """
+        Returns the FHIR resource associated with the entry.
+
+        :return: The FHIR resource.
+        """
+        return self._resource
+
+    @resource.setter
+    def resource(self, value: Dict[str, Any] | FhirResource | None) -> None:
+        """
+        Sets the FHIR resource associated with the entry.
+
+        :param value: The FHIR resource to set.
+        """
+        if value is not None:
+            if isinstance(value, CompressedDict):
+                self._resource = value
+            else:
+                if self._resource is None:
+                    self._resource = FhirResource(
+                        initial_dict=value, storage_mode=self.storage_mode
+                    )
+                else:
+                    self._resource.replace(value=value)
+        else:
+            self._resource = None
+
+    def dict(self) -> OrderedDict[str, Any]:
+        result: OrderedDict[str, Any] = OrderedDict[str, Any]()
+        if self.fullUrl is not None:
+            result["fullUrl"] = self.fullUrl
+        if self.resource is not None:
+            result["resource"] = self.resource.dict()
+        if self.request is not None:
+            result["request"] = self.request.dict()
+        if self.response is not None:
+            result["response"] = self.response.dict()
+        if self.link is not None:
+            result["link"] = [link.dict() for link in self.link]
+        if self.search is not None:
+            result["search"] = self.search.dict()
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    @classmethod
+    def from_dict(
+        cls,
+        d: OrderedDict[str, Any] | Dict[str, Any],
+        storage_mode: CompressedDictStorageMode,
+    ) -> "FhirBundleEntry":
+        return cls(
+            fullUrl=d["fullUrl"] if "fullUrl" in d else None,
+            resource=(
+                FhirResource(initial_dict=d["resource"], storage_mode=storage_mode)
+                if "resource" in d
+                else None
+            ),
+            request=(
+                FhirBundleEntryRequest.from_dict(d["request"])
+                if "request" in d
+                else None
+            ),
+            response=(
+                FhirBundleEntryResponse.from_dict(d["response"])
+                if "response" in d
+                else None
+            ),
+            link=(
+                [FhirLink.from_dict(link) for link in d["link"]]
+                if "link" in d
+                else None
+            ),
+            search=(
+                FhirBundleEntrySearch.from_dict(d["search"]) if "search" in d else None
+            ),
+            storage_mode=storage_mode,
+        )
+
+    def json(self) -> str:
+        """
+        Converts the BundleEntry object to a JSON string.
+
+        :return: A JSON string representation of the BundleEntry.
+        """
+        return json.dumps(obj=self.dict(), cls=FhirJSONEncoder)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirBundleEntry":
+        """
+        Creates a copy of the BundleEntry object.
+
+        :return: A new BundleEntry object with the same attributes.
+        """
+        return FhirBundleEntry(
+            fullUrl=self.fullUrl,
+            resource=copy.deepcopy(self.resource) if self.resource else None,
+            request=copy.deepcopy(self.request) if self.request else None,
+            response=copy.deepcopy(self.response) if self.response else None,
+            link=[copy.deepcopy(link) for link in self.link] if self.link else None,
+            search=copy.deepcopy(self.search) if self.search else None,
+            storage_mode=self.storage_mode,
+        )
+
+    def __repr__(self) -> str:
+        """
+        Returns a string representation of the BundleEntry object.
+
+        :return: A string representation of the BundleEntry.
+        """
+        return (
+            f"BundleEntry({self.resource.resource_type}/{self.resource.id})"
+            if self.resource
+            else f"BundleEntry(Empty)"
+        )
+
+    def copy(self) -> "FhirBundleEntry":
+        """
+        Creates a copy of the BundleEntry object.
+
+        :return: A new BundleEntry object with the same attributes.
+        """
+        return copy.deepcopy(self)
+
+    @property
+    def resource_type_and_id(self) -> Optional[str]:
+        """Get the key from the resource."""
+        return self.resource.resource_type_and_id if self.resource else None