phenostore-sdk-python 0.1.1__py3-none-any.whl

phenostore/gen/models/post_docref_body.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.search_total_mode import SearchTotalMode
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PostDocrefBody")
+
+
+@_attrs_define
+class PostDocrefBody:
+    """
+    Attributes:
+        patient (str): Patient reference
+        start (datetime.date | Unset): Period start date
+        end (datetime.date | Unset): Period end date
+        type_ (str | Unset): Document type (CodeableConcept token)
+        field_total (SearchTotalMode | Unset): FHIR `_total` mode controlling whether a result total is returned. These
+            are the three values defined by FHIR R4. `estimate` is accepted but currently behaves like `none` (no total is
+            emitted).
+    """
+
+    patient: str
+    start: datetime.date | Unset = UNSET
+    end: datetime.date | Unset = UNSET
+    type_: str | Unset = UNSET
+    field_total: SearchTotalMode | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        patient = self.patient
+
+        start: str | Unset = UNSET
+        if not isinstance(self.start, Unset):
+            start = self.start.isoformat()
+
+        end: str | Unset = UNSET
+        if not isinstance(self.end, Unset):
+            end = self.end.isoformat()
+
+        type_ = self.type_
+
+        field_total: str | Unset = UNSET
+        if not isinstance(self.field_total, Unset):
+            field_total = self.field_total.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "patient": patient,
+            }
+        )
+        if start is not UNSET:
+            field_dict["start"] = start
+        if end is not UNSET:
+            field_dict["end"] = end
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if field_total is not UNSET:
+            field_dict["_total"] = field_total
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        patient = d.pop("patient")
+
+        _start = d.pop("start", UNSET)
+        start: datetime.date | Unset
+        if isinstance(_start, Unset):
+            start = UNSET
+        else:
+            start = datetime.date.fromisoformat(_start)
+
+        _end = d.pop("end", UNSET)
+        end: datetime.date | Unset
+        if isinstance(_end, Unset):
+            end = UNSET
+        else:
+            end = datetime.date.fromisoformat(_end)
+
+        type_ = d.pop("type", UNSET)
+
+        _field_total = d.pop("_total", UNSET)
+        field_total: SearchTotalMode | Unset
+        if isinstance(_field_total, Unset):
+            field_total = UNSET
+        else:
+            field_total = SearchTotalMode(_field_total)
+
+        post_docref_body = cls(
+            patient=patient,
+            start=start,
+            end=end,
+            type_=type_,
+            field_total=field_total,
+        )
+
+        post_docref_body.additional_properties = d
+        return post_docref_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

phenostore/gen/models/resource_type.py

@@ -0,0 +1,47 @@
+from enum import StrEnum
+
+
+class ResourceType(StrEnum):
+    ALLERGYINTOLERANCE = "AllergyIntolerance"
+    APPOINTMENT = "Appointment"
+    CAREPLAN = "CarePlan"
+    CARETEAM = "CareTeam"
+    CLAIM = "Claim"
+    COMMUNICATION = "Communication"
+    CONDITION = "Condition"
+    CONSENT = "Consent"
+    COVERAGE = "Coverage"
+    DEVICE = "Device"
+    DIAGNOSTICREPORT = "DiagnosticReport"
+    DOCUMENTREFERENCE = "DocumentReference"
+    ENCOUNTER = "Encounter"
+    EXPLANATIONOFBENEFIT = "ExplanationOfBenefit"
+    FAMILYMEMBERHISTORY = "FamilyMemberHistory"
+    GOAL = "Goal"
+    HEALTHCARESERVICE = "HealthcareService"
+    IMMUNIZATION = "Immunization"
+    LOCATION = "Location"
+    MEDICATION = "Medication"
+    MEDICATIONADMINISTRATION = "MedicationAdministration"
+    MEDICATIONDISPENSE = "MedicationDispense"
+    MEDICATIONREQUEST = "MedicationRequest"
+    MEDICATIONSTATEMENT = "MedicationStatement"
+    OBSERVATION = "Observation"
+    ORGANIZATION = "Organization"
+    PATIENT = "Patient"
+    PRACTITIONER = "Practitioner"
+    PRACTITIONERROLE = "PractitionerRole"
+    PROCEDURE = "Procedure"
+    PROVENANCE = "Provenance"
+    QUESTIONNAIRE = "Questionnaire"
+    QUESTIONNAIRERESPONSE = "QuestionnaireResponse"
+    RELATEDPERSON = "RelatedPerson"
+    SCHEDULE = "Schedule"
+    SERVICEREQUEST = "ServiceRequest"
+    SLOT = "Slot"
+    SPECIMEN = "Specimen"
+    SUBSCRIPTION = "Subscription"
+    TASK = "Task"
+
+    def __str__(self) -> str:
+        return str(self.value)

phenostore/gen/models/search_resources_post_body.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.search_summary_mode import SearchSummaryMode
+from ..models.search_total_mode import SearchTotalMode
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SearchResourcesPostBody")
+
+
+@_attrs_define
+class SearchResourcesPostBody:
+    """
+    Attributes:
+        field_count (int | Unset):
+        field_offset (int | Unset):
+        field_cursor (str | Unset):
+        field_total (SearchTotalMode | Unset): FHIR `_total` mode controlling whether a result total is returned. These
+            are the three values defined by FHIR R4. `estimate` is accepted but currently behaves like `none` (no total is
+            emitted).
+        field_summary (SearchSummaryMode | Unset): Search response summary mode
+        field_elements (str | Unset):
+        field_sort (str | Unset):
+        field_include (list[str] | Unset):
+        field_revinclude (list[str] | Unset):
+    """
+
+    field_count: int | Unset = UNSET
+    field_offset: int | Unset = UNSET
+    field_cursor: str | Unset = UNSET
+    field_total: SearchTotalMode | Unset = UNSET
+    field_summary: SearchSummaryMode | Unset = UNSET
+    field_elements: str | Unset = UNSET
+    field_sort: str | Unset = UNSET
+    field_include: list[str] | Unset = UNSET
+    field_revinclude: list[str] | Unset = UNSET
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_count = self.field_count
+
+        field_offset = self.field_offset
+
+        field_cursor = self.field_cursor
+
+        field_total: str | Unset = UNSET
+        if not isinstance(self.field_total, Unset):
+            field_total = self.field_total.value
+
+        field_summary: str | Unset = UNSET
+        if not isinstance(self.field_summary, Unset):
+            field_summary = self.field_summary.value
+
+        field_elements = self.field_elements
+
+        field_sort = self.field_sort
+
+        field_include: list[str] | Unset = UNSET
+        if not isinstance(self.field_include, Unset):
+            field_include = self.field_include
+
+        field_revinclude: list[str] | Unset = UNSET
+        if not isinstance(self.field_revinclude, Unset):
+            field_revinclude = self.field_revinclude
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if field_count is not UNSET:
+            field_dict["_count"] = field_count
+        if field_offset is not UNSET:
+            field_dict["_offset"] = field_offset
+        if field_cursor is not UNSET:
+            field_dict["_cursor"] = field_cursor
+        if field_total is not UNSET:
+            field_dict["_total"] = field_total
+        if field_summary is not UNSET:
+            field_dict["_summary"] = field_summary
+        if field_elements is not UNSET:
+            field_dict["_elements"] = field_elements
+        if field_sort is not UNSET:
+            field_dict["_sort"] = field_sort
+        if field_include is not UNSET:
+            field_dict["_include"] = field_include
+        if field_revinclude is not UNSET:
+            field_dict["_revinclude"] = field_revinclude
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        field_count = d.pop("_count", UNSET)
+
+        field_offset = d.pop("_offset", UNSET)
+
+        field_cursor = d.pop("_cursor", UNSET)
+
+        _field_total = d.pop("_total", UNSET)
+        field_total: SearchTotalMode | Unset
+        if isinstance(_field_total, Unset):
+            field_total = UNSET
+        else:
+            field_total = SearchTotalMode(_field_total)
+
+        _field_summary = d.pop("_summary", UNSET)
+        field_summary: SearchSummaryMode | Unset
+        if isinstance(_field_summary, Unset):
+            field_summary = UNSET
+        else:
+            field_summary = SearchSummaryMode(_field_summary)
+
+        field_elements = d.pop("_elements", UNSET)
+
+        field_sort = d.pop("_sort", UNSET)
+
+        field_include = cast(list[str], d.pop("_include", UNSET))
+
+        field_revinclude = cast(list[str], d.pop("_revinclude", UNSET))
+
+        search_resources_post_body = cls(
+            field_count=field_count,
+            field_offset=field_offset,
+            field_cursor=field_cursor,
+            field_total=field_total,
+            field_summary=field_summary,
+            field_elements=field_elements,
+            field_sort=field_sort,
+            field_include=field_include,
+            field_revinclude=field_revinclude,
+        )
+
+        search_resources_post_body.additional_properties = d
+        return search_resources_post_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

phenostore/gen/models/search_summary_mode.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class SearchSummaryMode(StrEnum):
+    COUNT = "count"
+    DATA = "data"
+    FALSE = "false"
+    TEXT = "text"
+    TRUE = "true"
+
+    def __str__(self) -> str:
+        return str(self.value)

phenostore/gen/models/search_total_mode.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class SearchTotalMode(StrEnum):
+    ACCURATE = "accurate"
+    ESTIMATE = "estimate"
+    NONE = "none"
+
+    def __str__(self) -> str:
+        return str(self.value)

phenostore/gen/models/smart_configuration.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SmartConfiguration")
+
+
+@_attrs_define
+class SmartConfiguration:
+    """
+    Attributes:
+        token_endpoint (str | Unset):
+        grant_types_supported (list[str] | Unset):
+        token_endpoint_auth_methods_supported (list[str] | Unset):
+        scopes_supported (list[str] | Unset):
+        capabilities (list[str] | Unset):
+    """
+
+    token_endpoint: str | Unset = UNSET
+    grant_types_supported: list[str] | Unset = UNSET
+    token_endpoint_auth_methods_supported: list[str] | Unset = UNSET
+    scopes_supported: list[str] | Unset = UNSET
+    capabilities: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        token_endpoint = self.token_endpoint
+
+        grant_types_supported: list[str] | Unset = UNSET
+        if not isinstance(self.grant_types_supported, Unset):
+            grant_types_supported = self.grant_types_supported
+
+        token_endpoint_auth_methods_supported: list[str] | Unset = UNSET
+        if not isinstance(self.token_endpoint_auth_methods_supported, Unset):
+            token_endpoint_auth_methods_supported = (
+                self.token_endpoint_auth_methods_supported
+            )
+
+        scopes_supported: list[str] | Unset = UNSET
+        if not isinstance(self.scopes_supported, Unset):
+            scopes_supported = self.scopes_supported
+
+        capabilities: list[str] | Unset = UNSET
+        if not isinstance(self.capabilities, Unset):
+            capabilities = self.capabilities
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if token_endpoint is not UNSET:
+            field_dict["token_endpoint"] = token_endpoint
+        if grant_types_supported is not UNSET:
+            field_dict["grant_types_supported"] = grant_types_supported
+        if token_endpoint_auth_methods_supported is not UNSET:
+            field_dict["token_endpoint_auth_methods_supported"] = (
+                token_endpoint_auth_methods_supported
+            )
+        if scopes_supported is not UNSET:
+            field_dict["scopes_supported"] = scopes_supported
+        if capabilities is not UNSET:
+            field_dict["capabilities"] = capabilities
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        token_endpoint = d.pop("token_endpoint", UNSET)
+
+        grant_types_supported = cast(list[str], d.pop("grant_types_supported", UNSET))
+
+        token_endpoint_auth_methods_supported = cast(
+            list[str], d.pop("token_endpoint_auth_methods_supported", UNSET)
+        )
+
+        scopes_supported = cast(list[str], d.pop("scopes_supported", UNSET))
+
+        capabilities = cast(list[str], d.pop("capabilities", UNSET))
+
+        smart_configuration = cls(
+            token_endpoint=token_endpoint,
+            grant_types_supported=grant_types_supported,
+            token_endpoint_auth_methods_supported=token_endpoint_auth_methods_supported,
+            scopes_supported=scopes_supported,
+            capabilities=capabilities,
+        )
+
+        smart_configuration.additional_properties = d
+        return smart_configuration
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

phenostore/gen/models/token_response.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.token_response_token_type import TokenResponseTokenType
+
+T = TypeVar("T", bound="TokenResponse")
+
+
+@_attrs_define
+class TokenResponse:
+    """
+    Attributes:
+        access_token (str):
+        token_type (TokenResponseTokenType):
+        expires_in (int): Token lifetime in seconds
+        scope (str): Space-delimited list of granted scopes
+    """
+
+    access_token: str
+    token_type: TokenResponseTokenType
+    expires_in: int
+    scope: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        access_token = self.access_token
+
+        token_type = self.token_type.value
+
+        expires_in = self.expires_in
+
+        scope = self.scope
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "access_token": access_token,
+                "token_type": token_type,
+                "expires_in": expires_in,
+                "scope": scope,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        access_token = d.pop("access_token")
+
+        token_type = TokenResponseTokenType(d.pop("token_type"))
+
+        expires_in = d.pop("expires_in")
+
+        scope = d.pop("scope")
+
+        token_response = cls(
+            access_token=access_token,
+            token_type=token_type,
+            expires_in=expires_in,
+            scope=scope,
+        )
+
+        token_response.additional_properties = d
+        return token_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

phenostore/gen/models/token_response_token_type.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class TokenResponseTokenType(StrEnum):
+    BEARER = "Bearer"
+
+    def __str__(self) -> str:
+        return str(self.value)

phenostore/gen/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, TypeVar
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
+    # (filename, file (or bytes), content_type)
+    tuple[str | None, FileContent, str | None]
+    # (filename, file (or bytes), content_type, headers)
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: str | None = None
+    mime_type: str | None = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T | None
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]