compressedfhir 3.0.2__py3-none-any.whl

compressedfhir/fhir/fhir_bundle_entry_list.py

@@ -0,0 +1,97 @@
+import copy
+from typing import (
+    Deque,
+    Optional,
+    AsyncGenerator,
+    List,
+    Any,
+    Dict,
+    Set,
+    override,
+    Iterable,
+)
+
+from compressedfhir.fhir.fhir_bundle_entry import FhirBundleEntry
+
+
+class FhirBundleEntryList(Deque[FhirBundleEntry]):
+    """
+    Represents a list of FHIR Bundle entries.
+    """
+
+    __slots__: List[str] = ["_keys"]
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._keys: Set[str] = set()
+        for entry in self:
+            key = getattr(entry, "resource_type_and_id", None)
+            if key is not None:
+                self._keys.add(key)
+
+    async def consume_resource_async(
+        self,
+        *,
+        batch_size: Optional[int],
+    ) -> AsyncGenerator["FhirBundleEntryList", None]:
+        """
+        Consume bundle entries in batches asynchronously.
+
+        :param batch_size: The size of each batch.
+        :return: An async generator yielding batches of FhirResourceList.
+        """
+        if batch_size is None:
+            while self:
+                yield FhirBundleEntryList([self.popleft()])
+        elif batch_size <= 0:
+            raise ValueError("Batch size must be greater than 0.")
+        else:
+            while self:
+                batch = FhirBundleEntryList()
+                for _ in range(min(batch_size, len(self))):
+                    batch.append(self.popleft())
+                yield batch
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirBundleEntryList":
+        """
+        Create a shallow copy of the FhirBundleEntryList.
+
+        :return: A new FhirBundleEntryList instance with the same entries.
+        """
+        return FhirBundleEntryList([copy.deepcopy(entry) for entry in self])
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the FhirBundleEntryList.
+
+        :return: A string representation of the FhirBundleEntryList.
+        """
+        return f"FhirBundleEntryList(entries: {len(self)})"
+
+    @override
+    def append(self, x: FhirBundleEntry, /) -> None:
+        """
+        Append an entry to the FhirBundleEntryList.
+
+        :param x: The entry to append.
+        """
+        if not isinstance(x, FhirBundleEntry):
+            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 not None and key in self._keys:
+            return
+        if key is not None:
+            self._keys.add(key)
+        super().append(x)
+
+    @override
+    def extend(self, iterable: Iterable[FhirBundleEntry], /) -> 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_bundle_entry_request.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+from typing import Any, Dict, Optional, OrderedDict
+
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class FhirBundleEntryRequest:
+    """
+    FHIR Bundle Entry Request class for encapsulating the request to be sent to FHIR server
+    """
+
+    __slots__ = ["url", "method", "ifModifiedSince", "ifNoneMatch", "ifNoneExist"]
+
+    # noinspection PyPep8Naming
+    def __init__(
+        self,
+        *,
+        url: str,
+        method: str = "GET",
+        ifNoneMatch: Optional[str] = None,
+        ifModifiedSince: Optional[datetime] = None,
+        ifNoneExist: Optional[str] = None,
+    ) -> None:
+        self.url: str = url or "https://example.com"
+        self.method: str = method or "GET"
+        self.ifModifiedSince: Optional[datetime] = ifModifiedSince
+        self.ifNoneMatch: Optional[str] = ifNoneMatch
+        self.ifNoneExist: Optional[str] = ifNoneExist
+
+    def dict(self) -> OrderedDict[str, Any]:
+        result: OrderedDict[str, Any] = OrderedDict[str, Any](
+            {"url": self.url, "method": self.method}
+        )
+        if self.ifModifiedSince is not None:
+            result["ifModifiedSince"] = self.ifModifiedSince.isoformat()
+        if self.ifNoneMatch is not None:
+            result["ifNoneMatch"] = self.ifNoneMatch
+        if self.ifNoneExist is not None:
+            result["ifNoneExist"] = self.ifNoneExist
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    @classmethod
+    def from_dict(
+        cls, d: Dict[str, Any] | OrderedDict[str, Any]
+    ) -> "FhirBundleEntryRequest":
+        date_if_modified_since: Optional[datetime] = None
+        if "ifModifiedSince" in d:
+            if isinstance(d["ifModifiedSince"], datetime):
+                date_if_modified_since = d["ifModifiedSince"]
+            elif isinstance(d["ifModifiedSince"], str):
+                date_if_modified_since = datetime.fromisoformat(d["ifModifiedSince"])
+        return cls(
+            url=d.get("url", "https://example.com"),
+            method=d.get("method", "GET"),
+            ifModifiedSince=date_if_modified_since,
+            ifNoneMatch=d["ifNoneMatch"] if "ifNoneMatch" in d else None,
+            ifNoneExist=d["ifNoneExist"] if "ifNoneExist" in d else None,
+        )
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirBundleEntryRequest":
+        return FhirBundleEntryRequest(
+            url=self.url,
+            method=self.method,
+            ifModifiedSince=self.ifModifiedSince,
+            ifNoneMatch=self.ifNoneMatch,
+            ifNoneExist=self.ifNoneExist,
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f"FhirBundleEntryRequest(url={self.url}, method={self.method}, "
+            f"ifModifiedSince={self.ifModifiedSince}, ifNoneMatch={self.ifNoneMatch})"
+        )

compressedfhir/fhir/fhir_bundle_entry_response.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+from typing import Any, Dict, Optional, OrderedDict
+
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class FhirBundleEntryResponse:
+    """
+    FHIR Bundle Entry Response class for encapsulating the response from FHIR server when processing bundle entries
+    """
+
+    __slots__ = ["status", "lastModified", "etag", "location"]
+
+    # noinspection PyPep8Naming
+    def __init__(
+        self,
+        *,
+        status: str = "200",
+        etag: Optional[str] = None,
+        lastModified: Optional[datetime] = None,
+        location: Optional[str] = None,
+    ) -> None:
+        self.status: str = status or "200"
+        if isinstance(status, int):
+            self.status = str(status)
+        self.lastModified: Optional[datetime] = lastModified
+        self.etag: Optional[str] = etag
+        self.location: Optional[str] = location
+
+    def dict(self) -> OrderedDict[str, Any]:
+        result: OrderedDict[str, Any] = OrderedDict[str, Any]({"status": self.status})
+        if self.lastModified is not None:
+            result["lastModified"] = self.lastModified.isoformat()
+        if self.etag is not None:
+            result["etag"] = self.etag
+        if self.location is not None:
+            result["location"] = self.location
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    @classmethod
+    def from_dict(
+        cls, d: Dict[str, Any] | OrderedDict[str, Any]
+    ) -> "FhirBundleEntryResponse":
+        date_last_modified: Optional[datetime] = None
+        if "lastModified" in d:
+            if isinstance(d["lastModified"], datetime):
+                date_last_modified = d["lastModified"]
+            elif isinstance(d["lastModified"], str):
+                date_last_modified = datetime.fromisoformat(d["lastModified"])
+
+        return cls(
+            status=d["status"] if "status" in d else "200",
+            lastModified=date_last_modified,
+            etag=d["etag"] if "etag" in d else None,
+            location=d["location"] if "location" in d else None,
+        )
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirBundleEntryResponse":
+        return FhirBundleEntryResponse(
+            status=self.status,
+            lastModified=self.lastModified,
+            etag=self.etag,
+            location=self.location,
+        )
+
+    def __repr__(self) -> str:
+        return f"FhirBundleEntryResponse(status: {self.status}, lastModified: {self.lastModified}, etag: {self.etag})"

compressedfhir/fhir/fhir_bundle_entry_search.py

@@ -0,0 +1,75 @@
+import json
+from typing import Optional, Dict, Any, OrderedDict
+
+from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class FhirBundleEntrySearch:
+    """
+    FhirBundleEntrySearch is a class that represents a search entry in a FHIR Bundle.
+    It contains the resource, search mode, and search parameters.
+    """
+
+    __slots__ = ["mode", "score"]
+
+    def __init__(self, *, mode: Optional[str], score: Optional[float]) -> None:
+        """
+        Initializes the FhirBundleEntrySearch with the given parameters.
+
+        """
+        self.mode: Optional[str] = mode
+        self.score: Optional[float] = score
+
+    def dict(self) -> OrderedDict[str, Any]:
+        """
+        Converts the FhirBundleEntrySearch instance to a dictionary.
+
+        :return: A dictionary representation of the FhirBundleEntrySearch instance.
+        """
+        result: OrderedDict[str, Any] = OrderedDict[str, Any]()
+        if self.mode is not None:
+            result["mode"] = self.mode
+        if self.score is not None:
+            result["score"] = self.score
+
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    @classmethod
+    def from_dict(
+        cls, data: Dict[str, Any] | OrderedDict[str, Any]
+    ) -> "FhirBundleEntrySearch":
+        """
+        Creates a FhirBundleEntrySearch object from a dictionary.
+
+        :param data: A dictionary containing the search entry data.
+        :return: An instance of FhirBundleEntrySearch.
+        """
+        return cls(
+            mode=data.get("mode"),
+            score=data.get("score"),
+        )
+
+    def to_json(self) -> str:
+        """
+        Converts the FhirBundleEntrySearch instance to a JSON string.
+
+        :return: A JSON string representation of the FhirBundleEntrySearch instance.
+        """
+        return json.dumps(self.dict(), cls=FhirJSONEncoder)
+
+    def __repr__(self) -> str:
+        """
+        Returns a string representation of the FhirBundleEntrySearch instance.
+
+        :return: A string representation of the FhirBundleEntrySearch instance.
+        """
+        return f"FhirBundleEntrySearch(mode={self.mode}, score={self.score})"
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirBundleEntrySearch":
+        """
+        Creates a copy of the FhirBundleEntrySearch instance.
+
+        :return: A new FhirBundleEntrySearch instance with the same attributes.
+        """
+        return FhirBundleEntrySearch(mode=self.mode, score=self.score)

compressedfhir/fhir/fhir_identifier.py

@@ -0,0 +1,84 @@
+import json
+from typing import Optional, Dict, Any, OrderedDict
+
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class FhirIdentifier:
+    """
+    FHIR Identifier class for representing identifiers in FHIR resources.
+    """
+
+    __slots__ = ["use", "system", "value"]
+
+    def __init__(
+        self,
+        use: Optional[str] = None,
+        system: Optional[str] = None,
+        value: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize the FhirIdentifier object.
+
+        :param use: The purpose of the identifier (e.g., official, secondary).
+        :param system: The namespace for the identifier.
+        :param value: The actual identifier value.
+        """
+        self.use: Optional[str] = use
+        self.system: Optional[str] = system
+        self.value: Optional[str] = value
+
+    def dict(self) -> OrderedDict[str, Any]:
+        """
+        Convert the FhirIdentifier object to a dictionary.
+
+        :return: A dictionary representation of the FhirIdentifier object.
+        """
+        result: OrderedDict[str, Any] = OrderedDict[str, Any]()
+        if self.use is not None:
+            result["use"] = self.use
+        if self.system is not None:
+            result["system"] = self.system
+        if self.value is not None:
+            result["value"] = self.value
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    @classmethod
+    def from_dict(
+        cls, data: Dict[str, Any] | OrderedDict[str, Any]
+    ) -> "FhirIdentifier":
+        """
+        Create a FhirIdentifier object from a dictionary.
+
+        :param data: A dictionary containing the identifier data.
+        :return: An instance of FhirIdentifier.
+        """
+        return cls(
+            use=data.get("use"),
+            system=data.get("system"),
+            value=data.get("value"),
+        )
+
+    def json(self) -> str:
+        """
+        Convert the FhirIdentifier object to a JSON string.
+        :return: A JSON string representation of the FhirIdentifier object.
+        """
+        return json.dumps(self.dict())
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the FhirIdentifier object.
+        :return: A string representation of the FhirIdentifier object.
+        """
+        return (
+            f"FhirIdentifier(use={self.use}, system={self.system}, value={self.value})"
+        )
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirIdentifier":
+        """
+        Create a copy of the FhirIdentifier object.
+
+        :return: A new FhirIdentifier object with the same attributes.
+        """
+        return FhirIdentifier(use=self.use, system=self.system, value=self.value)

compressedfhir/fhir/fhir_link.py

@@ -0,0 +1,63 @@
+import json
+from typing import Any, Dict, OrderedDict
+
+from compressedfhir.utilities.fhir_json_encoder import FhirJSONEncoder
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+class FhirLink:
+    """
+    Represents a link in a FHIR
+    """
+
+    __slots__ = ["url", "relation"]
+
+    def __init__(self, *, url: str, relation: str) -> None:
+        """
+        Initializes a FhirLink instance.
+
+        :param url: The URL of the link.
+        :param relation: The relation type of the link.
+        """
+        self.url: str = url
+        self.relation: str = relation
+
+    def dict(self) -> OrderedDict[str, Any]:
+        """
+        Converts the FhirLink instance to a dictionary.
+
+        :return: A dictionary representation of the link.
+        """
+        result = OrderedDict[str, Any]({"url": self.url, "relation": self.relation})
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    def json(self) -> str:
+        """
+        Converts the FhirLink instance to a JSON string.
+
+        :return: A JSON string representation of the link.
+        """
+        return json.dumps(self.dict(), cls=FhirJSONEncoder)
+
+    def __repr__(self) -> str:
+        return f"FhirLink(url={self.url}, relation={self.relation})"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any] | OrderedDict[str, Any]) -> "FhirLink":
+        """
+        Populates the FhirLink instance from a dictionary.
+
+        :param data: A dictionary containing the link data.
+        """
+        return cls(
+            url=data.get("url") or "unknown",
+            relation=data.get("relation") or "unknown",
+        )
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirLink":
+        """
+        Creates a copy of the FhirLink instance.
+
+        :return: A new FhirLink instance with the same attributes.
+        """
+        return FhirLink(url=self.url, relation=self.relation)

compressedfhir/fhir/fhir_meta.py

@@ -0,0 +1,47 @@
+import dataclasses
+from typing import Any, Dict, OrderedDict
+
+from compressedfhir.utilities.json_helpers import FhirClientJsonHelpers
+
+
+@dataclasses.dataclass(slots=True)
+class FhirMeta:
+    """
+    FhirMeta represents the meta information of a FHIR resource.
+    """
+
+    version_id: str | None = None
+    last_updated: str | None = None
+    source: str | None = None
+    profile: list[str] | None = None
+    security: list[Dict[str, Any]] | None = None
+    tag: list[str] | None = None
+
+    def dict(self) -> OrderedDict[str, Any]:
+        result: OrderedDict[str, Any] = OrderedDict[str, Any]()
+        if self.version_id is not None:
+            result["versionId"] = self.version_id
+        if self.last_updated is not None:
+            result["lastUpdated"] = self.last_updated
+        if self.source is not None:
+            result["source"] = self.source
+        if self.profile is not None:
+            result["profile"] = [p for p in self.profile if p]
+        if self.security is not None:
+            result["security"] = [
+                FhirClientJsonHelpers.remove_empty_elements(s) for s in self.security
+            ]
+        if self.tag is not None:
+            result["tag"] = [t for t in self.tag if t]
+        return FhirClientJsonHelpers.remove_empty_elements_from_ordered_dict(result)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FhirMeta":
+        return cls(
+            version_id=data.get("versionId"),
+            last_updated=data.get("lastUpdated"),
+            source=data.get("source"),
+            profile=data.get("profile"),
+            security=data.get("security"),
+            tag=data.get("tag"),
+        )

compressedfhir/fhir/fhir_resource.py

@@ -0,0 +1,170 @@
+import copy
+import json
+from typing import Any, Optional, Dict, List, cast, OrderedDict, override
+
+from compressedfhir.fhir.fhir_meta import FhirMeta
+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 FhirResource(CompressedDict[str, Any]):
+    """
+    FhirResource is a class that represents a FHIR resource.
+    """
+
+    __slots__ = CompressedDict.__slots__
+
+    def __init__(
+        self,
+        initial_dict: Dict[str, Any] | OrderedDict[str, Any] | None = None,
+        *,
+        meta: Optional[FhirMeta] = None,
+        storage_mode: CompressedDictStorageMode | None = None,
+        properties_to_cache: Optional[List[str]] = None,
+    ) -> None:
+        if storage_mode is None:
+            storage_mode = CompressedDictStorageMode.default()
+        if meta is not None:
+            initial_dict = initial_dict or {}
+            initial_dict["meta"] = meta.dict()
+        super().__init__(
+            initial_dict=initial_dict,
+            storage_mode=storage_mode,
+            properties_to_cache=properties_to_cache or ["resourceType", "id", "meta"],
+        )
+
+    @classmethod
+    def construct(cls, **kwargs: Any) -> "FhirResource":
+        """
+        Constructs a FhirResource object from keyword arguments.
+
+        :param kwargs: Keyword arguments to initialize the resource.
+        :return: A FhirResource object.
+        """
+        return cls(initial_dict=kwargs)
+
+    @property
+    def resource_type(self) -> Optional[str]:
+        """Get the resource type from the resource dictionary."""
+        return self.get("resourceType")
+
+    @property
+    def resource_type_and_id(self) -> Optional[str]:
+        """Get the resource type and ID from the resource dictionary."""
+        return (
+            f"{self.resource_type}/{self.id}"
+            if self.resource_type and self.id
+            else None
+        )
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "FhirResource":
+        """Create a copy of the resource."""
+        return FhirResource(
+            initial_dict=super().raw_dict(),
+            storage_mode=self._storage_mode,
+        )
+
+    def __repr__(self) -> str:
+        """Custom string representation for debugging."""
+        return f"FhirResource({self.resource_type}/{self.id})"
+
+    def copy(self) -> "FhirResource":
+        """
+        Creates a copy of the BundleEntry object.
+
+        :return: A new BundleEntry object with the same attributes.
+        """
+        return copy.deepcopy(self)
+
+    @property
+    def id(self) -> Optional[str]:
+        """Get the ID from the resource dictionary."""
+        return self.get("id")
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        """Set the ID of the Bundle."""
+        self["id"] = value
+
+    @property
+    def meta(self) -> FhirMeta | None:
+        """Get the meta information from the resource dictionary."""
+        return (
+            FhirMeta.from_dict(cast(Dict[str, Any], self.get("meta")))
+            if "meta" in self
+            else None
+        )
+
+    @meta.setter
+    def meta(self, value: FhirMeta | None) -> None:
+        """Set the meta information of the resource."""
+        if value is None:
+            self.pop("meta", None)
+        else:
+            assert isinstance(value, FhirMeta)
+            self["meta"] = value.dict()
+
+    @classmethod
+    @override
+    def from_json(cls, json_str: str) -> "FhirResource":
+        """
+        Creates a FhirResource object from a JSON string.
+
+        :param json_str: JSON string representing the resource.
+        :return: A FhirResource object.
+        """
+        return cast(FhirResource, super().from_json(json_str=json_str))
+
+    @classmethod
+    @override
+    def from_dict(
+        cls,
+        d: Dict[str, Any],
+        *,
+        storage_mode: CompressedDictStorageMode | None = None,
+        properties_to_cache: List[str] | None = None,
+    ) -> "FhirResource":
+        """
+        Creates a FhirResource object from a dictionary.
+
+        :param d: Dictionary representing the resource.
+        :param storage_mode: Storage mode for the CompressedDict.
+        :param properties_to_cache: List of properties to cache.
+        :return: A FhirResource object.
+        """
+        if storage_mode is None:
+            storage_mode = CompressedDictStorageMode.default()
+        return cast(
+            FhirResource,
+            super().from_dict(
+                d=d,
+                storage_mode=storage_mode,
+                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)
+
+    def to_fhir_dict(self) -> Dict[str, Any]:
+        """
+        Convert the resource to a FHIR-compliant dictionary.
+
+        :return: A dictionary representation of the resource.
+        """
+        return cast(Dict[str, Any], json.loads(self.json()))