hubble-sdk-python 0.0.2__py3-none-any.whl

hubble_sdk/_generated/models/patient_demographics.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.patient_address import PatientAddress
+
+
+T = TypeVar("T", bound="PatientDemographics")
+
+
+@_attrs_define
+class PatientDemographics:
+    """
+    Attributes:
+        first_name (str | Unset): Patient's legal first name.
+        last_name (str | Unset): Patient's legal last name.
+        birth_date (str | Unset): Patient's date of birth, ISO YYYY-MM-DD.
+        sex (str | Unset): Patient's sex.
+        phone (str | Unset): Patient's phone number.
+        email (str | Unset): Patient's email, used as the signer identity.
+        address (PatientAddress | Unset):
+    """
+
+    first_name: str | Unset = UNSET
+    last_name: str | Unset = UNSET
+    birth_date: str | Unset = UNSET
+    sex: str | Unset = UNSET
+    phone: str | Unset = UNSET
+    email: str | Unset = UNSET
+    address: PatientAddress | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        first_name = self.first_name
+
+        last_name = self.last_name
+
+        birth_date = self.birth_date
+
+        sex = self.sex
+
+        phone = self.phone
+
+        email = self.email
+
+        address: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.address, Unset):
+            address = self.address.to_dict()
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({})
+        if first_name is not UNSET:
+            field_dict["first_name"] = first_name
+        if last_name is not UNSET:
+            field_dict["last_name"] = last_name
+        if birth_date is not UNSET:
+            field_dict["birth_date"] = birth_date
+        if sex is not UNSET:
+            field_dict["sex"] = sex
+        if phone is not UNSET:
+            field_dict["phone"] = phone
+        if email is not UNSET:
+            field_dict["email"] = email
+        if address is not UNSET:
+            field_dict["address"] = address
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.patient_address import PatientAddress
+
+        d = dict(src_dict)
+        first_name = d.pop("first_name", UNSET)
+
+        last_name = d.pop("last_name", UNSET)
+
+        birth_date = d.pop("birth_date", UNSET)
+
+        sex = d.pop("sex", UNSET)
+
+        phone = d.pop("phone", UNSET)
+
+        email = d.pop("email", UNSET)
+
+        _address = d.pop("address", UNSET)
+        address: PatientAddress | Unset
+        if isinstance(_address, Unset):
+            address = UNSET
+        else:
+            address = PatientAddress.from_dict(_address)
+
+        patient_demographics = cls(
+            first_name=first_name,
+            last_name=last_name,
+            birth_date=birth_date,
+            sex=sex,
+            phone=phone,
+            email=email,
+            address=address,
+        )
+
+        return patient_demographics

hubble_sdk/_generated/models/provider_seed.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ProviderSeed")
+
+
+@_attrs_define
+class ProviderSeed:
+    """
+    Attributes:
+        name (str): Provider name, as the patient would recognize it.
+        phone (str | Unset): Optional contact, for a provider that isn't reachable electronically.
+    """
+
+    name: str
+    phone: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        phone = self.phone
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if phone is not UNSET:
+            field_dict["phone"] = phone
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        phone = d.pop("phone", UNSET)
+
+        provider_seed = cls(
+            name=name,
+            phone=phone,
+        )
+
+        return provider_seed

hubble_sdk/_generated/models/token_request.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+from ..models.token_request_grant_type import TokenRequestGrantType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TokenRequest")
+
+
+@_attrs_define
+class TokenRequest:
+    """
+    Attributes:
+        grant_type (TokenRequestGrantType): The OAuth grant. authorization_code (redirect flow) is not yet available.
+        device_code (str | Unset): Required for the device_code grant.
+        refresh_token (str | Unset): Required for the refresh_token grant.
+        client_id (str | Unset): Client id, if not sent via HTTP Basic.
+        client_secret (str | Unset): Client secret, if not sent via HTTP Basic.
+    """
+
+    grant_type: TokenRequestGrantType
+    device_code: str | Unset = UNSET
+    refresh_token: str | Unset = UNSET
+    client_id: str | Unset = UNSET
+    client_secret: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        grant_type = self.grant_type.value
+
+        device_code = self.device_code
+
+        refresh_token = self.refresh_token
+
+        client_id = self.client_id
+
+        client_secret = self.client_secret
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "grant_type": grant_type,
+            }
+        )
+        if device_code is not UNSET:
+            field_dict["device_code"] = device_code
+        if refresh_token is not UNSET:
+            field_dict["refresh_token"] = refresh_token
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if client_secret is not UNSET:
+            field_dict["client_secret"] = client_secret
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        grant_type = TokenRequestGrantType(d.pop("grant_type"))
+
+        device_code = d.pop("device_code", UNSET)
+
+        refresh_token = d.pop("refresh_token", UNSET)
+
+        client_id = d.pop("client_id", UNSET)
+
+        client_secret = d.pop("client_secret", UNSET)
+
+        token_request = cls(
+            grant_type=grant_type,
+            device_code=device_code,
+            refresh_token=refresh_token,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+
+        return token_request

hubble_sdk/_generated/models/token_request_grant_type.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class TokenRequestGrantType(str, Enum):
+    AUTHORIZATION_CODE = "authorization_code"
+    REFRESH_TOKEN = "refresh_token"
+    URNIETFPARAMSOAUTHGRANT_TYPEDEVICE_CODE = (
+        "urn:ietf:params:oauth:grant-type:device_code"
+    )
+
+    def __str__(self) -> str:
+        return str(self.value)

hubble_sdk/_generated/models/token_response.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import (
+    Any,
+    Literal,
+    Self,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="TokenResponse")
+
+
+@_attrs_define
+class TokenResponse:
+    """
+    Attributes:
+        access_token (str): Consent-scoped access token for the /fhir data plane.
+        token_type (Literal['Bearer']):
+        expires_in (int): Seconds until the access token expires.
+        refresh_token (str): Rotating refresh token. The previous one is invalidated.
+        consent_id (str): The consent these tokens are scoped to.
+    """
+
+    access_token: str
+    token_type: Literal["Bearer"]
+    expires_in: int
+    refresh_token: str
+    consent_id: str
+
+    def to_dict(self) -> dict[str, Any]:
+        access_token = self.access_token
+
+        token_type = self.token_type
+
+        expires_in = self.expires_in
+
+        refresh_token = self.refresh_token
+
+        consent_id = self.consent_id
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "access_token": access_token,
+                "token_type": token_type,
+                "expires_in": expires_in,
+                "refresh_token": refresh_token,
+                "consent_id": consent_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        access_token = d.pop("access_token")
+
+        token_type = cast(Literal["Bearer"], d.pop("token_type"))
+        if token_type != "Bearer":
+            raise ValueError(
+                f"token_type must match const 'Bearer', got '{token_type}'"
+            )
+
+        expires_in = d.pop("expires_in")
+
+        refresh_token = d.pop("refresh_token")
+
+        consent_id = d.pop("consent_id")
+
+        token_response = cls(
+            access_token=access_token,
+            token_type=token_type,
+            expires_in=expires_in,
+            refresh_token=refresh_token,
+            consent_id=consent_id,
+        )
+
+        return token_response

hubble_sdk/_generated/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"]