hubble-sdk-python 0.0.2__tar.gz

hubble_sdk_python-0.0.2/.gitignore

@@ -0,0 +1,18 @@
+# Node
+node_modules/
+packages/typescript/dist/
+
+# Python
+.venv/
+__pycache__/
+*.egg-info/
+.ruff_cache/
+.pytest_cache/
+packages/python/dist/
+
+# Generated API reference (synced into the docs site, not committed)
+docs/
+
+# misc
+.DS_Store
+.env

hubble_sdk_python-0.0.2/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+## [0.0.2](https://github.com/hubble-dot-ai/hubble-sdks/compare/hubble-sdk-python-v0.0.1...hubble-sdk-python-v0.0.2) (2026-08-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* PatientSession no longer exposes `patient`; Consent no longer has `patient`/`scope`/`vendor` and TokenResponse no longer has `patient`/`scope`.
+
+### Features
+
+* sync spec — add Patient/$pdf export, drop patient from token/consent ([#20](https://github.com/hubble-dot-ai/hubble-sdks/issues/20)) ([c9bd44e](https://github.com/hubble-dot-ai/hubble-sdks/commit/c9bd44eac38914ff85b1c243a6ec59f496136b5d))
+
+
+### Bug Fixes
+
+* **ci:** bump pypi-publish action for Metadata-Version 2.5; re-cut python 0.0.2 ([#26](https://github.com/hubble-dot-ai/hubble-sdks/issues/26)) ([f784753](https://github.com/hubble-dot-ai/hubble-sdks/commit/f78475349bb48a4b8e86e8a062038af758b5a474))
+* **ci:** pin pypi-publish action to the v1.14.2 commit SHA ([#28](https://github.com/hubble-dot-ai/hubble-sdks/issues/28)) ([003b145](https://github.com/hubble-dot-ai/hubble-sdks/commit/003b14573ba660c9ff7ac14ab2249b344b78f890))
+* repair release-please manifest and re-cut python 0.0.2 ([#24](https://github.com/hubble-dot-ai/hubble-sdks/issues/24)) ([2cd613b](https://github.com/hubble-dot-ai/hubble-sdks/commit/2cd613b40c0c3aede191d122d891a1fbcbc60bed))
+
+## 0.0.1 (2026-08-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* published package names and the Python import path change.
+
+### Features
+
+* notify callers when a session rotates its tokens ([#13](https://github.com/hubble-dot-ai/hubble-sdks/issues/13)) ([8cb478c](https://github.com/hubble-dot-ai/hubble-sdks/commit/8cb478ce6a21430b928df824d5eaf47679d1477b))
+* rename packages to @hubbleai/hubble-sdk + hubble-sdk-python, sync spec ([#17](https://github.com/hubble-dot-ai/hubble-sdks/issues/17)) ([20be457](https://github.com/hubble-dot-ai/hubble-sdks/commit/20be457c16a544418bf7a0c5ec8e1cc785c7d4d4))
+* type FHIR responses in both SDKs ([99e8f2a](https://github.com/hubble-dot-ai/hubble-sdks/commit/99e8f2aecff16daf65c6ad4d062bd907cbcb510a))
+
+
+### Documentation
+
+* add Markdown API-reference generators for both SDKs ([#12](https://github.com/hubble-dot-ai/hubble-sdks/issues/12)) ([2e48919](https://github.com/hubble-dot-ai/hubble-sdks/commit/2e48919cde7db06c899d35a6656973778774fbcf))
+* cleaner generated SDK reference ([#16](https://github.com/hubble-dot-ai/hubble-sdks/issues/16)) ([4061a6a](https://github.com/hubble-dot-ai/hubble-sdks/commit/4061a6a8dff6e99981ae9c8999e7e3214b067e64))
+* use Markdown, not Sphinx roles, in Python docstrings ([#15](https://github.com/hubble-dot-ai/hubble-sdks/issues/15)) ([a625723](https://github.com/hubble-dot-ai/hubble-sdks/commit/a625723349de3d389c07082ae3265c6aae644aba))

hubble_sdk_python-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hubble
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hubble_sdk_python-0.0.2/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.5
+Name: hubble-sdk-python
+Version: 0.0.2
+Summary: Python client for the Hubble Patient Access API.
+Project-URL: Homepage, https://github.com/hubble-dot-ai/hubble-sdks
+Project-URL: Repository, https://github.com/hubble-dot-ai/hubble-sdks
+Project-URL: Issues, https://github.com/hubble-dot-ai/hubble-sdks/issues
+Author: Hubble
+License-Expression: MIT
+License-File: LICENSE
+Keywords: health records,hubble,medical records,patient
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: attrs>=22.2.0
+Requires-Dist: httpx<0.29.0,>=0.23.1
+Requires-Dist: python-dateutil>=2.8.0
+Provides-Extra: docs
+Requires-Dist: pydoc-markdown<5,>=4.8; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == 'test'
+Requires-Dist: respx>=0.21; extra == 'test'
+Description-Content-Type: text/markdown
+
+# hubble-sdk-python
+
+Python client for the Hubble Patient Access API: create patient authorization
+links, exchange them for consent-scoped access tokens, and read FHIR R4 data.
+
+```bash
+pip install hubble-sdk-python
+```
+
+```python
+from hubble_sdk import Hubble
+
+hub = Hubble(client_id="hbl_client_prod_...", client_secret="hbl_prod_...")
+
+# 1. Create a patient link and send the patient to it. Optionally prefill with
+#    patient={"first_name": ...} demographics and providers=[{"name": ...}].
+link = hub.create_link(patient_ref="abc123")
+print(link.verification_uri_complete)
+
+# 2. Wait for the patient to authorize (polls the token endpoint for you).
+session = hub.wait_for_authorization(link)
+
+# 3. Read the patient's FHIR data (Bearer token + auto-refresh handled for you).
+bundle = session.everything()
+observations = session.fhir("Observation", params={"category": "vital-signs"})
+export = session.export_pdf()   # export.content bytes; export.sources_failed counts failed sources
+
+# Consent management
+for consent in hub.list_consents(status="active"):
+    print(consent.id, consent.patient_ref)
+hub.revoke_consent(session.consent_id)
+```
+
+## What the client handles for you
+
+- **Auth per plane** — HTTP Basic (your app credentials) for consent management
+  and the token endpoint; Bearer (the consent token) for FHIR reads. You never
+  wire the schemes yourself.
+- **Default base URL** — `https://api.hubble.ai`. Override only with a trusted
+  value; your access token is sent to it.
+- **Device-flow polling** — `wait_for_authorization` honors the server's
+  `interval` and `slow_down`.
+- **Correct FHIR paths** — operation and sub-resource paths like
+  `Patient/$everything` are sent unencoded.
+- **Transparent refresh** — FHIR reads refresh and retry once on a 401.
+- **FHIR responses** — reads return the raw FHIR R4 resource as a dict. For typed
+  models, parse with the optional [`fhir.resources`](https://pypi.org/project/fhir.resources/)
+  package: `from fhir.resources.bundle import Bundle; Bundle.model_validate(session.everything())`.
+
+## Layout
+
+`Hubble` / `PatientSession` are hand-written. The low-level client generated
+from the OpenAPI contract with
+[openapi-python-client](https://github.com/openapi-generators/openapi-python-client)
+lives under `hubble_sdk._generated` (regenerated on every spec change;
+never edited by hand). Reach into it only if you need raw operations. See the
+repo root README for how to regenerate.

hubble_sdk_python-0.0.2/README.md

@@ -0,0 +1,57 @@
+# hubble-sdk-python
+
+Python client for the Hubble Patient Access API: create patient authorization
+links, exchange them for consent-scoped access tokens, and read FHIR R4 data.
+
+```bash
+pip install hubble-sdk-python
+```
+
+```python
+from hubble_sdk import Hubble
+
+hub = Hubble(client_id="hbl_client_prod_...", client_secret="hbl_prod_...")
+
+# 1. Create a patient link and send the patient to it. Optionally prefill with
+#    patient={"first_name": ...} demographics and providers=[{"name": ...}].
+link = hub.create_link(patient_ref="abc123")
+print(link.verification_uri_complete)
+
+# 2. Wait for the patient to authorize (polls the token endpoint for you).
+session = hub.wait_for_authorization(link)
+
+# 3. Read the patient's FHIR data (Bearer token + auto-refresh handled for you).
+bundle = session.everything()
+observations = session.fhir("Observation", params={"category": "vital-signs"})
+export = session.export_pdf()   # export.content bytes; export.sources_failed counts failed sources
+
+# Consent management
+for consent in hub.list_consents(status="active"):
+    print(consent.id, consent.patient_ref)
+hub.revoke_consent(session.consent_id)
+```
+
+## What the client handles for you
+
+- **Auth per plane** — HTTP Basic (your app credentials) for consent management
+  and the token endpoint; Bearer (the consent token) for FHIR reads. You never
+  wire the schemes yourself.
+- **Default base URL** — `https://api.hubble.ai`. Override only with a trusted
+  value; your access token is sent to it.
+- **Device-flow polling** — `wait_for_authorization` honors the server's
+  `interval` and `slow_down`.
+- **Correct FHIR paths** — operation and sub-resource paths like
+  `Patient/$everything` are sent unencoded.
+- **Transparent refresh** — FHIR reads refresh and retry once on a 401.
+- **FHIR responses** — reads return the raw FHIR R4 resource as a dict. For typed
+  models, parse with the optional [`fhir.resources`](https://pypi.org/project/fhir.resources/)
+  package: `from fhir.resources.bundle import Bundle; Bundle.model_validate(session.everything())`.
+
+## Layout
+
+`Hubble` / `PatientSession` are hand-written. The low-level client generated
+from the OpenAPI contract with
+[openapi-python-client](https://github.com/openapi-generators/openapi-python-client)
+lives under `hubble_sdk._generated` (regenerated on every spec change;
+never edited by hand). Reach into it only if you need raw operations. See the
+repo root README for how to regenerate.

hubble_sdk_python-0.0.2/config.yaml

@@ -0,0 +1,4 @@
+# openapi-python-client generation config. Regenerate with the command in the
+# repo README whenever openapi.json changes.
+package_name_override: hubble_sdk
+project_name_override: hubble-sdk-python

hubble_sdk_python-0.0.2/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_python-0.0.2/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_python-0.0.2/hubble_sdk/_generated/api/__init__.py

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

hubble_sdk_python-0.0.2/hubble_sdk/_generated/api/default/__init__.py

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

hubble_sdk_python-0.0.2/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