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

phenostore/gen/models/bundle_link.py

@@ -0,0 +1,69 @@
+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
+
+T = TypeVar("T", bound="BundleLink")
+
+
+@_attrs_define
+class BundleLink:
+    """
+    Attributes:
+        relation (str):
+        url (str):
+    """
+
+    relation: str
+    url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        relation = self.relation
+
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "relation": relation,
+                "url": url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        relation = d.pop("relation")
+
+        url = d.pop("url")
+
+        bundle_link = cls(
+            relation=relation,
+            url=url,
+        )
+
+        bundle_link.additional_properties = d
+        return bundle_link
+
+    @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/bundle_resource_type.py

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

phenostore/gen/models/bundle_type.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class BundleType(StrEnum):
+    BATCH_RESPONSE = "batch-response"
+    HISTORY = "history"
+    SEARCHSET = "searchset"
+    TRANSACTION_RESPONSE = "transaction-response"
+
+    def __str__(self) -> str:
+        return str(self.value)

phenostore/gen/models/fhir_resource.py

@@ -0,0 +1,47 @@
+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
+
+T = TypeVar("T", bound="FhirResource")
+
+
+@_attrs_define
+class FhirResource:
+    """An arbitrary FHIR resource stored as raw JSON."""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        fhir_resource = cls()
+
+        fhir_resource.additional_properties = d
+        return fhir_resource
+
+    @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/health_response.py

@@ -0,0 +1,63 @@
+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.health_response_status import HealthResponseStatus
+
+T = TypeVar("T", bound="HealthResponse")
+
+
+@_attrs_define
+class HealthResponse:
+    """
+    Attributes:
+        status (HealthResponseStatus):
+    """
+
+    status: HealthResponseStatus
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = HealthResponseStatus(d.pop("status"))
+
+        health_response = cls(
+            status=status,
+        )
+
+        health_response.additional_properties = d
+        return health_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/health_response_status.py

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

phenostore/gen/models/issue_severity.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class IssueSeverity(StrEnum):
+    ERROR = "error"
+    FATAL = "fatal"
+    INFORMATION = "information"
+    WARNING = "warning"
+
+    def __str__(self) -> str:
+        return str(self.value)

phenostore/gen/models/issue_token_body.py

@@ -0,0 +1,91 @@
+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.issue_token_body_grant_type import IssueTokenBodyGrantType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="IssueTokenBody")
+
+
+@_attrs_define
+class IssueTokenBody:
+    """
+    Attributes:
+        grant_type (IssueTokenBodyGrantType):
+        client_id (str | Unset): Required when credentials are not sent via HTTP Basic auth.
+        client_secret (str | Unset): Required when credentials are not sent via HTTP Basic auth.
+        scope (str | Unset): Space-delimited list of requested scopes (subset of granted permissions)
+    """
+
+    grant_type: IssueTokenBodyGrantType
+    client_id: str | Unset = UNSET
+    client_secret: str | Unset = UNSET
+    scope: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        grant_type = self.grant_type.value
+
+        client_id = self.client_id
+
+        client_secret = self.client_secret
+
+        scope = self.scope
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "grant_type": grant_type,
+            }
+        )
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if client_secret is not UNSET:
+            field_dict["client_secret"] = client_secret
+        if scope is not UNSET:
+            field_dict["scope"] = scope
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        grant_type = IssueTokenBodyGrantType(d.pop("grant_type"))
+
+        client_id = d.pop("client_id", UNSET)
+
+        client_secret = d.pop("client_secret", UNSET)
+
+        scope = d.pop("scope", UNSET)
+
+        issue_token_body = cls(
+            grant_type=grant_type,
+            client_id=client_id,
+            client_secret=client_secret,
+            scope=scope,
+        )
+
+        issue_token_body.additional_properties = d
+        return issue_token_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/issue_token_body_grant_type.py

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

phenostore/gen/models/json_patch_item.py

@@ -0,0 +1,90 @@
+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.json_patch_op import JsonPatchOp
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="JsonPatchItem")
+
+
+@_attrs_define
+class JsonPatchItem:
+    """
+    Attributes:
+        op (JsonPatchOp): JSON Patch operation type (RFC 6902)
+        path (str):
+        value (Any | Unset):
+        from_ (str | Unset):
+    """
+
+    op: JsonPatchOp
+    path: str
+    value: Any | Unset = UNSET
+    from_: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        op = self.op.value
+
+        path = self.path
+
+        value = self.value
+
+        from_ = self.from_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "op": op,
+                "path": path,
+            }
+        )
+        if value is not UNSET:
+            field_dict["value"] = value
+        if from_ is not UNSET:
+            field_dict["from"] = from_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        op = JsonPatchOp(d.pop("op"))
+
+        path = d.pop("path")
+
+        value = d.pop("value", UNSET)
+
+        from_ = d.pop("from", UNSET)
+
+        json_patch_item = cls(
+            op=op,
+            path=path,
+            value=value,
+            from_=from_,
+        )
+
+        json_patch_item.additional_properties = d
+        return json_patch_item
+
+    @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/json_patch_op.py

@@ -0,0 +1,13 @@
+from enum import StrEnum
+
+
+class JsonPatchOp(StrEnum):
+    ADD = "add"
+    COPY = "copy"
+    MOVE = "move"
+    REMOVE = "remove"
+    REPLACE = "replace"
+    TEST = "test"
+
+    def __str__(self) -> str:
+        return str(self.value)

phenostore/gen/models/o_auth_error.py

@@ -0,0 +1,69 @@
+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
+
+T = TypeVar("T", bound="OAuthError")
+
+
+@_attrs_define
+class OAuthError:
+    """
+    Attributes:
+        error (str): OAuth2 error code (RFC 6749)
+        error_description (str):
+    """
+
+    error: str
+    error_description: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error
+
+        error_description = self.error_description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+                "error_description": error_description,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = d.pop("error")
+
+        error_description = d.pop("error_description")
+
+        o_auth_error = cls(
+            error=error,
+            error_description=error_description,
+        )
+
+        o_auth_error.additional_properties = d
+        return o_auth_error
+
+    @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/operation_outcome.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.operation_outcome_resource_type import OperationOutcomeResourceType
+
+if TYPE_CHECKING:
+    from ..models.operation_outcome_issue import OperationOutcomeIssue
+
+
+T = TypeVar("T", bound="OperationOutcome")
+
+
+@_attrs_define
+class OperationOutcome:
+    """
+    Attributes:
+        resource_type (OperationOutcomeResourceType):
+        issue (list[OperationOutcomeIssue]):
+    """
+
+    resource_type: OperationOutcomeResourceType
+    issue: list[OperationOutcomeIssue]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        resource_type = self.resource_type.value
+
+        issue = []
+        for issue_item_data in self.issue:
+            issue_item = issue_item_data.to_dict()
+            issue.append(issue_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "resourceType": resource_type,
+                "issue": issue,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.operation_outcome_issue import OperationOutcomeIssue  # noqa: PLC0415
+
+        d = dict(src_dict)
+        resource_type = OperationOutcomeResourceType(d.pop("resourceType"))
+
+        issue = []
+        _issue = d.pop("issue")
+        for issue_item_data in _issue:
+            issue_item = OperationOutcomeIssue.from_dict(issue_item_data)
+
+            issue.append(issue_item)
+
+        operation_outcome = cls(
+            resource_type=resource_type,
+            issue=issue,
+        )
+
+        operation_outcome.additional_properties = d
+        return operation_outcome
+
+    @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/operation_outcome_issue.py

@@ -0,0 +1,92 @@
+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.issue_severity import IssueSeverity
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OperationOutcomeIssue")
+
+
+@_attrs_define
+class OperationOutcomeIssue:
+    """
+    Attributes:
+        severity (IssueSeverity): FHIR OperationOutcome issue severity
+        code (str): FHIR issue type code
+        diagnostics (str | Unset):
+        expression (list[str] | Unset):
+    """
+
+    severity: IssueSeverity
+    code: str
+    diagnostics: str | Unset = UNSET
+    expression: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        severity = self.severity.value
+
+        code = self.code
+
+        diagnostics = self.diagnostics
+
+        expression: list[str] | Unset = UNSET
+        if not isinstance(self.expression, Unset):
+            expression = self.expression
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "severity": severity,
+                "code": code,
+            }
+        )
+        if diagnostics is not UNSET:
+            field_dict["diagnostics"] = diagnostics
+        if expression is not UNSET:
+            field_dict["expression"] = expression
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        severity = IssueSeverity(d.pop("severity"))
+
+        code = d.pop("code")
+
+        diagnostics = d.pop("diagnostics", UNSET)
+
+        expression = cast(list[str], d.pop("expression", UNSET))
+
+        operation_outcome_issue = cls(
+            severity=severity,
+            code=code,
+            diagnostics=diagnostics,
+            expression=expression,
+        )
+
+        operation_outcome_issue.additional_properties = d
+        return operation_outcome_issue
+
+    @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/operation_outcome_resource_type.py

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