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

hubble_sdk/__init__.py

@@ -0,0 +1,43 @@
+"""Python client for the Hubble Patient Access API.
+
+Import the high-level client from here:
+
+    from hubble_sdk import Hubble
+
+    hub = Hubble(client_id="hbl_client_...", client_secret="hbl_prod_...")
+    link = hub.create_link(patient_ref="abc123")
+    print(link.verification_uri_complete)     # send the patient here
+    session = hub.wait_for_authorization(link)
+    bundle = session.everything()             # reads FHIR with the consent token
+
+The generated low-level client lives under ``hubble_sdk._generated``
+if you need direct access to raw operations and models.
+"""
+
+from ._generated.models import (
+    Consent,
+    ConsentStatus,
+    DeviceAuthorizationResponse,
+    TokenResponse,
+)
+from ._hubble import (
+    ConsentTimeout,
+    Hubble,
+    HubbleError,
+    PatientSession,
+    PdfExport,
+    TokenSet,
+)
+
+__all__ = [
+    "Hubble",
+    "PatientSession",
+    "HubbleError",
+    "ConsentTimeout",
+    "TokenSet",
+    "PdfExport",
+    "Consent",
+    "ConsentStatus",
+    "DeviceAuthorizationResponse",
+    "TokenResponse",
+]

hubble_sdk/_generated/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Hubble Patient Access API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

hubble_sdk/_generated/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

hubble_sdk/_generated/api/default/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

hubble_sdk/_generated/api/default/attach_client_authorization.py

@@ -0,0 +1,220 @@
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.api_error import ApiError
+from ...models.attach_client_authorization_body import AttachClientAuthorizationBody
+from ...models.attach_client_authorization_response_201 import (
+    AttachClientAuthorizationResponse201,
+)
+from ...types import Response
+
+
+def _get_kwargs(
+    id: str,
+    *,
+    body: AttachClientAuthorizationBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/consents/{id}/authorization".format(
+            id=quote(str(id), safe=""),
+        ),
+    }
+
+    _kwargs["files"] = body.to_multipart()
+
+    headers["Content-Type"] = "multipart/form-data; boundary=+++"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> ApiError | AttachClientAuthorizationResponse201 | None:
+    if response.status_code == 201:
+        response_201 = AttachClientAuthorizationResponse201.from_dict(response.json())
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = ApiError.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = ApiError.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 403:
+        response_403 = ApiError.from_dict(response.json())
+
+        return response_403
+
+    if response.status_code == 404:
+        response_404 = ApiError.from_dict(response.json())
+
+        return response_404
+
+    if response.status_code == 413:
+        response_413 = ApiError.from_dict(response.json())
+
+        return response_413
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[ApiError | AttachClientAuthorizationResponse201]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: str,
+    *,
+    client: AuthenticatedClient,
+    body: AttachClientAuthorizationBody,
+) -> Response[ApiError | AttachClientAuthorizationResponse201]:
+    """Attach a customer-supplied HIPAA authorization
+
+     Upload an already-signed HIPAA authorization for a consent and grant delegated retrieval from the
+    providers it names. The artifact IS the evidence, so the consent is granted at once with no patient
+    step. Requires the `byo_hipaa_authorization` entitlement on your organization.
+
+    Args:
+        id (str):
+        body (AttachClientAuthorizationBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiError | AttachClientAuthorizationResponse201]
+    """
+
+    kwargs = _get_kwargs(
+        id=id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    id: str,
+    *,
+    client: AuthenticatedClient,
+    body: AttachClientAuthorizationBody,
+) -> ApiError | AttachClientAuthorizationResponse201 | None:
+    """Attach a customer-supplied HIPAA authorization
+
+     Upload an already-signed HIPAA authorization for a consent and grant delegated retrieval from the
+    providers it names. The artifact IS the evidence, so the consent is granted at once with no patient
+    step. Requires the `byo_hipaa_authorization` entitlement on your organization.
+
+    Args:
+        id (str):
+        body (AttachClientAuthorizationBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiError | AttachClientAuthorizationResponse201
+    """
+
+    return sync_detailed(
+        id=id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    id: str,
+    *,
+    client: AuthenticatedClient,
+    body: AttachClientAuthorizationBody,
+) -> Response[ApiError | AttachClientAuthorizationResponse201]:
+    """Attach a customer-supplied HIPAA authorization
+
+     Upload an already-signed HIPAA authorization for a consent and grant delegated retrieval from the
+    providers it names. The artifact IS the evidence, so the consent is granted at once with no patient
+    step. Requires the `byo_hipaa_authorization` entitlement on your organization.
+
+    Args:
+        id (str):
+        body (AttachClientAuthorizationBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiError | AttachClientAuthorizationResponse201]
+    """
+
+    kwargs = _get_kwargs(
+        id=id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    id: str,
+    *,
+    client: AuthenticatedClient,
+    body: AttachClientAuthorizationBody,
+) -> ApiError | AttachClientAuthorizationResponse201 | None:
+    """Attach a customer-supplied HIPAA authorization
+
+     Upload an already-signed HIPAA authorization for a consent and grant delegated retrieval from the
+    providers it names. The artifact IS the evidence, so the consent is granted at once with no patient
+    step. Requires the `byo_hipaa_authorization` entitlement on your organization.
+
+    Args:
+        id (str):
+        body (AttachClientAuthorizationBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiError | AttachClientAuthorizationResponse201
+    """
+
+    return (
+        await asyncio_detailed(
+            id=id,
+            client=client,
+            body=body,
+        )
+    ).parsed

hubble_sdk/_generated/api/default/create_consent_link.py

@@ -0,0 +1,197 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.api_error import ApiError
+from ...models.consent_link_request import ConsentLinkRequest
+from ...models.device_authorization_request import DeviceAuthorizationRequest
+from ...models.device_authorization_response import DeviceAuthorizationResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    body: ConsentLinkRequest | DeviceAuthorizationRequest | Unset = UNSET,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/consents/oauth/device_authorization",
+    }
+
+    if isinstance(body, ConsentLinkRequest):
+        if not isinstance(body, Unset):
+            _kwargs["json"] = body.to_dict()
+
+        headers["Content-Type"] = "application/json"
+    if isinstance(body, DeviceAuthorizationRequest):
+        if not isinstance(body, Unset):
+            _kwargs["data"] = body.to_dict()
+        headers["Content-Type"] = "application/x-www-form-urlencoded"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> ApiError | DeviceAuthorizationResponse | None:
+    if response.status_code == 200:
+        response_200 = DeviceAuthorizationResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = ApiError.from_dict(response.json())
+
+        return response_401
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[ApiError | DeviceAuthorizationResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: ConsentLinkRequest | DeviceAuthorizationRequest | Unset = UNSET,
+) -> Response[ApiError | DeviceAuthorizationResponse]:
+    """Start the patient link flow
+
+     Mints a pending consent and a one-time patient link. Send the patient to
+    `verification_uri_complete`, then poll the token endpoint with `device_code` until they authorize.
+    Accepts a nested JSON body (recommended) or the flat RFC 8628 form encoding; both prefill the same
+    consent.
+
+    Args:
+        body (ConsentLinkRequest | Unset):
+        body (DeviceAuthorizationRequest | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiError | DeviceAuthorizationResponse]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: ConsentLinkRequest | DeviceAuthorizationRequest | Unset = UNSET,
+) -> ApiError | DeviceAuthorizationResponse | None:
+    """Start the patient link flow
+
+     Mints a pending consent and a one-time patient link. Send the patient to
+    `verification_uri_complete`, then poll the token endpoint with `device_code` until they authorize.
+    Accepts a nested JSON body (recommended) or the flat RFC 8628 form encoding; both prefill the same
+    consent.
+
+    Args:
+        body (ConsentLinkRequest | Unset):
+        body (DeviceAuthorizationRequest | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiError | DeviceAuthorizationResponse
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: ConsentLinkRequest | DeviceAuthorizationRequest | Unset = UNSET,
+) -> Response[ApiError | DeviceAuthorizationResponse]:
+    """Start the patient link flow
+
+     Mints a pending consent and a one-time patient link. Send the patient to
+    `verification_uri_complete`, then poll the token endpoint with `device_code` until they authorize.
+    Accepts a nested JSON body (recommended) or the flat RFC 8628 form encoding; both prefill the same
+    consent.
+
+    Args:
+        body (ConsentLinkRequest | Unset):
+        body (DeviceAuthorizationRequest | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiError | DeviceAuthorizationResponse]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: ConsentLinkRequest | DeviceAuthorizationRequest | Unset = UNSET,
+) -> ApiError | DeviceAuthorizationResponse | None:
+    """Start the patient link flow
+
+     Mints a pending consent and a one-time patient link. Send the patient to
+    `verification_uri_complete`, then poll the token endpoint with `device_code` until they authorize.
+    Accepts a nested JSON body (recommended) or the flat RFC 8628 form encoding; both prefill the same
+    consent.
+
+    Args:
+        body (ConsentLinkRequest | Unset):
+        body (DeviceAuthorizationRequest | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiError | DeviceAuthorizationResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

hubble_sdk/_generated/api/default/exchange_token.py

@@ -0,0 +1,186 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.o_auth_error import OAuthError
+from ...models.token_request import TokenRequest
+from ...models.token_response import TokenResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: TokenRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/consents/oauth/token",
+    }
+
+    _kwargs["data"] = body.to_dict()
+    headers["Content-Type"] = "application/x-www-form-urlencoded"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> OAuthError | TokenResponse | None:
+    if response.status_code == 200:
+        response_200 = TokenResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = OAuthError.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = OAuthError.from_dict(response.json())
+
+        return response_401
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[OAuthError | TokenResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TokenRequest,
+) -> Response[OAuthError | TokenResponse]:
+    """Token endpoint
+
+     The single OAuth token endpoint. Dispatches on `grant_type`: the device_code grant redeems a link
+    into consent tokens; the refresh_token grant rotates them. Client auth via HTTP Basic or
+    `client_id`/`client_secret` form fields. Errors use the OAuth dialect.
+
+    Args:
+        body (TokenRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[OAuthError | TokenResponse]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: TokenRequest,
+) -> OAuthError | TokenResponse | None:
+    """Token endpoint
+
+     The single OAuth token endpoint. Dispatches on `grant_type`: the device_code grant redeems a link
+    into consent tokens; the refresh_token grant rotates them. Client auth via HTTP Basic or
+    `client_id`/`client_secret` form fields. Errors use the OAuth dialect.
+
+    Args:
+        body (TokenRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        OAuthError | TokenResponse
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: TokenRequest,
+) -> Response[OAuthError | TokenResponse]:
+    """Token endpoint
+
+     The single OAuth token endpoint. Dispatches on `grant_type`: the device_code grant redeems a link
+    into consent tokens; the refresh_token grant rotates them. Client auth via HTTP Basic or
+    `client_id`/`client_secret` form fields. Errors use the OAuth dialect.
+
+    Args:
+        body (TokenRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[OAuthError | TokenResponse]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: TokenRequest,
+) -> OAuthError | TokenResponse | None:
+    """Token endpoint
+
+     The single OAuth token endpoint. Dispatches on `grant_type`: the device_code grant redeems a link
+    into consent tokens; the refresh_token grant rotates them. Client auth via HTTP Basic or
+    `client_id`/`client_secret` form fields. Errors use the OAuth dialect.
+
+    Args:
+        body (TokenRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        OAuthError | TokenResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed