hubble-sdk-python 0.3.0__tar.gz → 0.3.1__tar.gz

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.3.1](https://github.com/hubble-dot-ai/hubble-sdks/compare/hubble-sdk-python-v0.3.0...hubble-sdk-python-v0.3.1) (2026-11-05)
+
+
+### Features
+
+* Support `Hubble-Version` through the `version` option on `export_pdf`, including waiting for background generation and downloading the completed records archive. ([#82](https://github.com/hubble-dot-ai/hubble-sdks/issues/82)) ([8f295db](https://github.com/hubble-dot-ai/hubble-sdks/commit/8f295db3f67c8606a29db0f7dfd99752e963c99e))
+* Request a single PDF containing a source's summary and documents with `combined=true` in the generated client. ([#84](https://github.com/hubble-dot-ai/hubble-sdks/issues/84)) ([3a70d41](https://github.com/hubble-dot-ai/hubble-sdks/commit/3a70d417c9cc27700679b3e957a748dd251fcd71))
+* Limit FHIR reads and exports to one connected source with the generated client's `connection` parameter. ([#81](https://github.com/hubble-dot-ai/hubble-sdks/issues/81)) ([0f812d0](https://github.com/hubble-dot-ai/hubble-sdks/commit/0f812d06ac59e23285fd72238529eb21afcbc80a))
+
+
+### Documentation
+
+* Document records archives and 30-day export availability after completion, with download links valid for at most 60 seconds. ([#81](https://github.com/hubble-dot-ai/hubble-sdks/issues/81)) ([0f812d0](https://github.com/hubble-dot-ai/hubble-sdks/commit/0f812d06ac59e23285fd72238529eb21afcbc80a))
+* Clarify that `consent.completed` means the patient finished adding sources; their records may still be processing. ([#78](https://github.com/hubble-dot-ai/hubble-sdks/issues/78)) ([b16e458](https://github.com/hubble-dot-ai/hubble-sdks/commit/b16e45869dd7a5f531318e58c182022b12e3139b))
+
 ## [0.3.0](https://github.com/hubble-dot-ai/hubble-sdks/compare/hubble-sdk-python-v0.2.1...hubble-sdk-python-v0.3.0) (2026-10-27)
 
 

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hubble-sdk-python
-Version: 0.3.0
+Version: 0.3.1
 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

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_generated/api/default/export_patient_fhir.py

@@ -16,6 +16,7 @@ from ...types import UNSET, Response, Unset
 def _get_kwargs(
     *,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
     field_count: int | Unset = UNSET,
     field_offset: int | Unset = UNSET,
     prefer: ExportPatientFhirPrefer | Unset = UNSET,
@@ -31,6 +32,11 @@ def _get_kwargs(
         json_consent = str(consent)
     params["consent"] = json_consent
 
+    json_connection: str | Unset = UNSET
+    if not isinstance(connection, Unset):
+        json_connection = str(connection)
+    params["connection"] = json_connection
+
     params["_count"] = field_count
 
     params["_offset"] = field_offset
@@ -111,6 +117,7 @@ def sync_detailed(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
     field_count: int | Unset = UNSET,
     field_offset: int | Unset = UNSET,
     prefer: ExportPatientFhirPrefer | Unset = UNSET,
@@ -127,6 +134,7 @@ def sync_detailed(
 
     Args:
         consent (UUID | Unset):
+        connection (UUID | Unset):
         field_count (int | Unset):
         field_offset (int | Unset):
         prefer (ExportPatientFhirPrefer | Unset):
@@ -141,6 +149,7 @@ def sync_detailed(
 
     kwargs = _get_kwargs(
         consent=consent,
+        connection=connection,
         field_count=field_count,
         field_offset=field_offset,
         prefer=prefer,
@@ -157,6 +166,7 @@ def sync(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
     field_count: int | Unset = UNSET,
     field_offset: int | Unset = UNSET,
     prefer: ExportPatientFhirPrefer | Unset = UNSET,
@@ -173,6 +183,7 @@ def sync(
 
     Args:
         consent (UUID | Unset):
+        connection (UUID | Unset):
         field_count (int | Unset):
         field_offset (int | Unset):
         prefer (ExportPatientFhirPrefer | Unset):
@@ -188,6 +199,7 @@ def sync(
     return sync_detailed(
         client=client,
         consent=consent,
+        connection=connection,
         field_count=field_count,
         field_offset=field_offset,
         prefer=prefer,
@@ -198,6 +210,7 @@ async def asyncio_detailed(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
     field_count: int | Unset = UNSET,
     field_offset: int | Unset = UNSET,
     prefer: ExportPatientFhirPrefer | Unset = UNSET,
@@ -214,6 +227,7 @@ async def asyncio_detailed(
 
     Args:
         consent (UUID | Unset):
+        connection (UUID | Unset):
         field_count (int | Unset):
         field_offset (int | Unset):
         prefer (ExportPatientFhirPrefer | Unset):
@@ -228,6 +242,7 @@ async def asyncio_detailed(
 
     kwargs = _get_kwargs(
         consent=consent,
+        connection=connection,
         field_count=field_count,
         field_offset=field_offset,
         prefer=prefer,
@@ -242,6 +257,7 @@ async def asyncio(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
     field_count: int | Unset = UNSET,
     field_offset: int | Unset = UNSET,
     prefer: ExportPatientFhirPrefer | Unset = UNSET,
@@ -258,6 +274,7 @@ async def asyncio(
 
     Args:
         consent (UUID | Unset):
+        connection (UUID | Unset):
         field_count (int | Unset):
         field_offset (int | Unset):
         prefer (ExportPatientFhirPrefer | Unset):
@@ -274,6 +291,7 @@ async def asyncio(
         await asyncio_detailed(
             client=client,
             consent=consent,
+            connection=connection,
             field_count=field_count,
             field_offset=field_offset,
             prefer=prefer,

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_generated/api/default/export_patient_pdf.py

@@ -6,6 +6,8 @@ import httpx
 
 from ... import errors
 from ...client import AuthenticatedClient, Client
+from ...models.export_patient_pdf_combined import ExportPatientPdfCombined
+from ...models.export_patient_pdf_hubble_version import ExportPatientPdfHubbleVersion
 from ...models.export_patient_pdf_prefer import ExportPatientPdfPrefer
 from ...models.export_patient_pdf_response_202 import ExportPatientPdfResponse202
 from ...models.operation_outcome import OperationOutcome
@@ -16,9 +18,14 @@ def _get_kwargs(
     *,
     consent: UUID | Unset = UNSET,
     connection: str | Unset = UNSET,
+    combined: ExportPatientPdfCombined | Unset = UNSET,
+    hubble_version: ExportPatientPdfHubbleVersion | Unset = UNSET,
     prefer: ExportPatientPdfPrefer | Unset = UNSET,
 ) -> dict[str, Any]:
     headers: dict[str, Any] = {}
+    if not isinstance(hubble_version, Unset):
+        headers["Hubble-Version"] = str(hubble_version)
+
     if not isinstance(prefer, Unset):
         headers["Prefer"] = str(prefer)
 
@@ -31,6 +38,12 @@ def _get_kwargs(
 
     params["connection"] = connection
 
+    json_combined: str | Unset = UNSET
+    if not isinstance(combined, Unset):
+        json_combined = combined.value
+
+    params["combined"] = json_combined
+
     params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     _kwargs: dict[str, Any] = {
@@ -103,6 +116,8 @@ def sync_detailed(
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
     connection: str | Unset = UNSET,
+    combined: ExportPatientPdfCombined | Unset = UNSET,
+    hubble_version: ExportPatientPdfHubbleVersion | Unset = UNSET,
     prefer: ExportPatientPdfPrefer | Unset = UNSET,
 ) -> Response[ExportPatientPdfResponse202 | OperationOutcome]:
     """Export records as PDF (one per source)
@@ -115,11 +130,18 @@ def sync_detailed(
     Prefer: respond-async to prepare the export in a background worker. Poll Content-Location with the
     same token no sooner than Retry-After until it returns a 303 redirect to a short-lived download URL.
     An organization can hold 20 exports in flight at once; a repeat request for one already running
-    reuses it. Without Prefer, the synchronous response is unchanged.
+    reuses it. Without Prefer, the synchronous response is unchanged. Send `Hubble-Version: 2026-11-01`
+    with Prefer: respond-async for the records archive (preview) instead: always a zip, with or without
+    `connection`, holding a folder per source and a `manifest.json` that lists every file. It is only
+    built asynchronously. Find files through the manifest rather than by path; new files may appear. Add
+    `combined=true` with `connection` for one PDF of that source instead of the zip: its summary
+    followed by its documents, in no guaranteed order.
 
     Args:
         consent (UUID | Unset):
         connection (str | Unset):
+        combined (ExportPatientPdfCombined | Unset):
+        hubble_version (ExportPatientPdfHubbleVersion | Unset):
         prefer (ExportPatientPdfPrefer | Unset):
 
     Raises:
@@ -133,6 +155,8 @@ def sync_detailed(
     kwargs = _get_kwargs(
         consent=consent,
         connection=connection,
+        combined=combined,
+        hubble_version=hubble_version,
         prefer=prefer,
     )
 
@@ -148,6 +172,8 @@ def sync(
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
     connection: str | Unset = UNSET,
+    combined: ExportPatientPdfCombined | Unset = UNSET,
+    hubble_version: ExportPatientPdfHubbleVersion | Unset = UNSET,
     prefer: ExportPatientPdfPrefer | Unset = UNSET,
 ) -> ExportPatientPdfResponse202 | OperationOutcome | None:
     """Export records as PDF (one per source)
@@ -160,11 +186,18 @@ def sync(
     Prefer: respond-async to prepare the export in a background worker. Poll Content-Location with the
     same token no sooner than Retry-After until it returns a 303 redirect to a short-lived download URL.
     An organization can hold 20 exports in flight at once; a repeat request for one already running
-    reuses it. Without Prefer, the synchronous response is unchanged.
+    reuses it. Without Prefer, the synchronous response is unchanged. Send `Hubble-Version: 2026-11-01`
+    with Prefer: respond-async for the records archive (preview) instead: always a zip, with or without
+    `connection`, holding a folder per source and a `manifest.json` that lists every file. It is only
+    built asynchronously. Find files through the manifest rather than by path; new files may appear. Add
+    `combined=true` with `connection` for one PDF of that source instead of the zip: its summary
+    followed by its documents, in no guaranteed order.
 
     Args:
         consent (UUID | Unset):
         connection (str | Unset):
+        combined (ExportPatientPdfCombined | Unset):
+        hubble_version (ExportPatientPdfHubbleVersion | Unset):
         prefer (ExportPatientPdfPrefer | Unset):
 
     Raises:
@@ -179,6 +212,8 @@ def sync(
         client=client,
         consent=consent,
         connection=connection,
+        combined=combined,
+        hubble_version=hubble_version,
         prefer=prefer,
     ).parsed
 
@@ -188,6 +223,8 @@ async def asyncio_detailed(
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
     connection: str | Unset = UNSET,
+    combined: ExportPatientPdfCombined | Unset = UNSET,
+    hubble_version: ExportPatientPdfHubbleVersion | Unset = UNSET,
     prefer: ExportPatientPdfPrefer | Unset = UNSET,
 ) -> Response[ExportPatientPdfResponse202 | OperationOutcome]:
     """Export records as PDF (one per source)
@@ -200,11 +237,18 @@ async def asyncio_detailed(
     Prefer: respond-async to prepare the export in a background worker. Poll Content-Location with the
     same token no sooner than Retry-After until it returns a 303 redirect to a short-lived download URL.
     An organization can hold 20 exports in flight at once; a repeat request for one already running
-    reuses it. Without Prefer, the synchronous response is unchanged.
+    reuses it. Without Prefer, the synchronous response is unchanged. Send `Hubble-Version: 2026-11-01`
+    with Prefer: respond-async for the records archive (preview) instead: always a zip, with or without
+    `connection`, holding a folder per source and a `manifest.json` that lists every file. It is only
+    built asynchronously. Find files through the manifest rather than by path; new files may appear. Add
+    `combined=true` with `connection` for one PDF of that source instead of the zip: its summary
+    followed by its documents, in no guaranteed order.
 
     Args:
         consent (UUID | Unset):
         connection (str | Unset):
+        combined (ExportPatientPdfCombined | Unset):
+        hubble_version (ExportPatientPdfHubbleVersion | Unset):
         prefer (ExportPatientPdfPrefer | Unset):
 
     Raises:
@@ -218,6 +262,8 @@ async def asyncio_detailed(
     kwargs = _get_kwargs(
         consent=consent,
         connection=connection,
+        combined=combined,
+        hubble_version=hubble_version,
         prefer=prefer,
     )
 
@@ -231,6 +277,8 @@ async def asyncio(
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
     connection: str | Unset = UNSET,
+    combined: ExportPatientPdfCombined | Unset = UNSET,
+    hubble_version: ExportPatientPdfHubbleVersion | Unset = UNSET,
     prefer: ExportPatientPdfPrefer | Unset = UNSET,
 ) -> ExportPatientPdfResponse202 | OperationOutcome | None:
     """Export records as PDF (one per source)
@@ -243,11 +291,18 @@ async def asyncio(
     Prefer: respond-async to prepare the export in a background worker. Poll Content-Location with the
     same token no sooner than Retry-After until it returns a 303 redirect to a short-lived download URL.
     An organization can hold 20 exports in flight at once; a repeat request for one already running
-    reuses it. Without Prefer, the synchronous response is unchanged.
+    reuses it. Without Prefer, the synchronous response is unchanged. Send `Hubble-Version: 2026-11-01`
+    with Prefer: respond-async for the records archive (preview) instead: always a zip, with or without
+    `connection`, holding a folder per source and a `manifest.json` that lists every file. It is only
+    built asynchronously. Find files through the manifest rather than by path; new files may appear. Add
+    `combined=true` with `connection` for one PDF of that source instead of the zip: its summary
+    followed by its documents, in no guaranteed order.
 
     Args:
         consent (UUID | Unset):
         connection (str | Unset):
+        combined (ExportPatientPdfCombined | Unset):
+        hubble_version (ExportPatientPdfHubbleVersion | Unset):
         prefer (ExportPatientPdfPrefer | Unset):
 
     Raises:
@@ -263,6 +318,8 @@ async def asyncio(
             client=client,
             consent=consent,
             connection=connection,
+            combined=combined,
+            hubble_version=hubble_version,
             prefer=prefer,
         )
     ).parsed

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_generated/api/default/get_patient_pdf_export.py

@@ -129,8 +129,10 @@ def sync_detailed(
     when the export started already includes it. Pending work returns 202. Ready work returns 303 to a
     download URL valid for at most 60 seconds. Do not forward the Hubble Bearer token to the storage
     host. Accept: application/json returns a ready status and same-origin downloadUrl instead; navigate
-    to that URL for the redirect. Exports expire two hours after creation. Revoked or expired source
-    authorization invalidates the artifact.
+    to that URL for the redirect. Preparation must finish within two hours of creation. On completion,
+    expiresAt becomes the download deadline, 30 days later. Revoked or expired source authorization
+    invalidates the artifact. An export started with `Hubble-Version` carries that version in a `Hubble-
+    Version` response header.
 
     Args:
         id (UUID):
@@ -175,8 +177,10 @@ def sync(
     when the export started already includes it. Pending work returns 202. Ready work returns 303 to a
     download URL valid for at most 60 seconds. Do not forward the Hubble Bearer token to the storage
     host. Accept: application/json returns a ready status and same-origin downloadUrl instead; navigate
-    to that URL for the redirect. Exports expire two hours after creation. Revoked or expired source
-    authorization invalidates the artifact.
+    to that URL for the redirect. Preparation must finish within two hours of creation. On completion,
+    expiresAt becomes the download deadline, 30 days later. Revoked or expired source authorization
+    invalidates the artifact. An export started with `Hubble-Version` carries that version in a `Hubble-
+    Version` response header.
 
     Args:
         id (UUID):
@@ -216,8 +220,10 @@ async def asyncio_detailed(
     when the export started already includes it. Pending work returns 202. Ready work returns 303 to a
     download URL valid for at most 60 seconds. Do not forward the Hubble Bearer token to the storage
     host. Accept: application/json returns a ready status and same-origin downloadUrl instead; navigate
-    to that URL for the redirect. Exports expire two hours after creation. Revoked or expired source
-    authorization invalidates the artifact.
+    to that URL for the redirect. Preparation must finish within two hours of creation. On completion,
+    expiresAt becomes the download deadline, 30 days later. Revoked or expired source authorization
+    invalidates the artifact. An export started with `Hubble-Version` carries that version in a `Hubble-
+    Version` response header.
 
     Args:
         id (UUID):
@@ -260,8 +266,10 @@ async def asyncio(
     when the export started already includes it. Pending work returns 202. Ready work returns 303 to a
     download URL valid for at most 60 seconds. Do not forward the Hubble Bearer token to the storage
     host. Accept: application/json returns a ready status and same-origin downloadUrl instead; navigate
-    to that URL for the redirect. Exports expire two hours after creation. Revoked or expired source
-    authorization invalidates the artifact.
+    to that URL for the redirect. Preparation must finish within two hours of creation. On completion,
+    expiresAt becomes the download deadline, 30 days later. Revoked or expired source authorization
+    invalidates the artifact. An export started with `Hubble-Version` carries that version in a `Hubble-
+    Version` response header.
 
     Args:
         id (UUID):

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_generated/api/default/read_fhir.py

@@ -16,6 +16,7 @@ def _get_kwargs(
     path: str,
     *,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
 ) -> dict[str, Any]:
 
     params: dict[str, Any] = {}
@@ -25,6 +26,11 @@ def _get_kwargs(
         json_consent = str(consent)
     params["consent"] = json_consent
 
+    json_connection: str | Unset = UNSET
+    if not isinstance(connection, Unset):
+        json_connection = str(connection)
+    params["connection"] = json_connection
+
     params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     _kwargs: dict[str, Any] = {
@@ -88,16 +94,19 @@ def sync_detailed(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
 ) -> Response[FhirResource | OperationOutcome]:
     """Read FHIR data
 
      The FHIR R4 data plane. Authenticated by a consent token, which determines the consent, or an
     application token with `consent=<id>` naming it. Returns arbitrary FHIR resources; type responses
-    against @types/fhir (TS) or fhir.resources (Python) rather than this spec.
+    against @types/fhir (TS) or fhir.resources (Python) rather than this spec. Reads merge every source
+    on the consent unless `connection` names one.
 
     Args:
         path (str):
         consent (UUID | Unset):
+        connection (UUID | Unset):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -110,6 +119,7 @@ def sync_detailed(
     kwargs = _get_kwargs(
         path=path,
         consent=consent,
+        connection=connection,
     )
 
     response = client.get_httpx_client().request(
@@ -124,16 +134,19 @@ def sync(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
 ) -> FhirResource | OperationOutcome | None:
     """Read FHIR data
 
      The FHIR R4 data plane. Authenticated by a consent token, which determines the consent, or an
     application token with `consent=<id>` naming it. Returns arbitrary FHIR resources; type responses
-    against @types/fhir (TS) or fhir.resources (Python) rather than this spec.
+    against @types/fhir (TS) or fhir.resources (Python) rather than this spec. Reads merge every source
+    on the consent unless `connection` names one.
 
     Args:
         path (str):
         consent (UUID | Unset):
+        connection (UUID | Unset):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -147,6 +160,7 @@ def sync(
         path=path,
         client=client,
         consent=consent,
+        connection=connection,
     ).parsed
 
 
@@ -155,16 +169,19 @@ async def asyncio_detailed(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
 ) -> Response[FhirResource | OperationOutcome]:
     """Read FHIR data
 
      The FHIR R4 data plane. Authenticated by a consent token, which determines the consent, or an
     application token with `consent=<id>` naming it. Returns arbitrary FHIR resources; type responses
-    against @types/fhir (TS) or fhir.resources (Python) rather than this spec.
+    against @types/fhir (TS) or fhir.resources (Python) rather than this spec. Reads merge every source
+    on the consent unless `connection` names one.
 
     Args:
         path (str):
         consent (UUID | Unset):
+        connection (UUID | Unset):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -177,6 +194,7 @@ async def asyncio_detailed(
     kwargs = _get_kwargs(
         path=path,
         consent=consent,
+        connection=connection,
     )
 
     response = await client.get_async_httpx_client().request(**kwargs)
@@ -189,16 +207,19 @@ async def asyncio(
     *,
     client: AuthenticatedClient,
     consent: UUID | Unset = UNSET,
+    connection: UUID | Unset = UNSET,
 ) -> FhirResource | OperationOutcome | None:
     """Read FHIR data
 
      The FHIR R4 data plane. Authenticated by a consent token, which determines the consent, or an
     application token with `consent=<id>` naming it. Returns arbitrary FHIR resources; type responses
-    against @types/fhir (TS) or fhir.resources (Python) rather than this spec.
+    against @types/fhir (TS) or fhir.resources (Python) rather than this spec. Reads merge every source
+    on the consent unless `connection` names one.
 
     Args:
         path (str):
         consent (UUID | Unset):
+        connection (UUID | Unset):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -213,5 +234,6 @@ async def asyncio(
             path=path,
             client=client,
             consent=consent,
+            connection=connection,
         )
     ).parsed

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_generated/models/__init__.py

@@ -22,6 +22,8 @@ from .device_authorization_response import DeviceAuthorizationResponse
 from .export_patient_fhir_prefer import ExportPatientFhirPrefer
 from .export_patient_fhir_response_202 import ExportPatientFhirResponse202
 from .export_patient_fhir_response_202_status import ExportPatientFhirResponse202Status
+from .export_patient_pdf_combined import ExportPatientPdfCombined
+from .export_patient_pdf_hubble_version import ExportPatientPdfHubbleVersion
 from .export_patient_pdf_prefer import ExportPatientPdfPrefer
 from .export_patient_pdf_response_202 import ExportPatientPdfResponse202
 from .export_patient_pdf_response_202_status import ExportPatientPdfResponse202Status
@@ -68,6 +70,8 @@ __all__ = (
     "ExportPatientFhirPrefer",
     "ExportPatientFhirResponse202",
     "ExportPatientFhirResponse202Status",
+    "ExportPatientPdfCombined",
+    "ExportPatientPdfHubbleVersion",
     "ExportPatientPdfPrefer",
     "ExportPatientPdfResponse202",
     "ExportPatientPdfResponse202Status",

hubble_sdk_python-0.3.1/hubble_sdk/_generated/models/export_patient_pdf_combined.py

@@ -0,0 +1,27 @@
+from enum import StrEnum
+
+
+class ExportPatientPdfCombined(StrEnum):
+    TRUE = "true"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    # How API responses are parsed. The API may add values to this enum without a
+    # new SDK release, so a value this version does not know becomes a member
+    # carrying the raw string instead of raising. It compares equal to that string
+    # and is absent from list(ExportPatientPdfCombined), which is how to tell it apart.
+    # A value that is not a string is a malformed response and still raises.
+    # Constructing the enum directly stays strict, so a typo in a value you pass
+    # in still raises and membership checks are unchanged.
+    @classmethod
+    def _from_value(cls, value: object) -> "ExportPatientPdfCombined":
+        try:
+            return cls(value)
+        except ValueError:
+            if not isinstance(value, str):
+                raise
+            member = str.__new__(cls, value)
+            member._name_ = value
+            member._value_ = value
+            return member

hubble_sdk_python-0.3.1/hubble_sdk/_generated/models/export_patient_pdf_hubble_version.py

@@ -0,0 +1,27 @@
+from enum import StrEnum
+
+
+class ExportPatientPdfHubbleVersion(StrEnum):
+    VALUE_0 = "2026-11-01"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    # How API responses are parsed. The API may add values to this enum without a
+    # new SDK release, so a value this version does not know becomes a member
+    # carrying the raw string instead of raising. It compares equal to that string
+    # and is absent from list(ExportPatientPdfHubbleVersion), which is how to tell it apart.
+    # A value that is not a string is a malformed response and still raises.
+    # Constructing the enum directly stays strict, so a typo in a value you pass
+    # in still raises and membership checks are unchanged.
+    @classmethod
+    def _from_value(cls, value: object) -> "ExportPatientPdfHubbleVersion":
+        try:
+            return cls(value)
+        except ValueError:
+            if not isinstance(value, str):
+                raise
+            member = str.__new__(cls, value)
+            member._name_ = value
+            member._value_ = value
+            return member

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_generated/models/operation_outcome.py

@@ -51,9 +51,7 @@ class OperationOutcome:
 
     @classmethod
     def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
-        from ..models.operation_outcome_issue_item import (
-            OperationOutcomeIssueItem,
-        )
+        from ..models.operation_outcome_issue_item import OperationOutcomeIssueItem
 
         d = dict(src_dict)
         resource_type = cast(Literal["OperationOutcome"], d.pop("resourceType"))

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_hubble.py

@@ -65,6 +65,8 @@ _APP_TOKEN_RENEW_MARGIN = 60.0
 # goes into a URL, so neither can add path segments or a query string.
 _RESOURCE_TYPE_RE = re.compile(r"[A-Z][A-Za-z]+")
 _RESOURCE_ID_RE = re.compile(r"[A-Za-z0-9\-.]{1,64}")
+# How long export_pdf waits by default for a versioned export to be built.
+_EXPORT_TIMEOUT = 600.0
 
 
 
@@ -130,22 +132,68 @@ def _require_fhir_namespace(base_url: str, url: httpx.URL, shown: str) -> None:
         raise HubbleError(f"Invalid FHIR path: {shown!r}")
 
 
-def _pdf_export(resp: httpx.Response) -> PdfExport:
+def _pdf_export(
+    resp: httpx.Response, file: httpx.Response | None = None, version: str | None = None
+) -> PdfExport:
+    # The counts come from Hubble's response; the body from `file` when the export
+    # was downloaded separately.
     def _count(header: str) -> int | None:
         try:
             return int(resp.headers[header])
         except (KeyError, ValueError):
             return None
 
+    body = file if file is not None else resp
     return PdfExport(
-        content=resp.content,
-        content_type=resp.headers.get("content-type", ""),
+        content=body.content,
+        content_type=body.headers.get("content-type", ""),
         sources_total=_count("X-Hubble-Sources-Total"),
         sources_failed=_count("X-Hubble-Sources-Failed"),
         resource_count=_count("X-Hubble-Resource-Count"),
+        version=version,
     )
 
 
+def _versioned_pdf_export(
+    send: Callable[[httpx.URL, dict[str, str]], httpx.Response],
+    base_url: str,
+    start: httpx.URL,
+    version: str,
+    timeout: float,
+) -> PdfExport:
+    # A versioned export is only built in the background: start it, poll
+    # Content-Location until the 303 to the file, then download the file without
+    # the access token, which must never reach the storage host.
+    deadline = time.monotonic() + timeout
+    resp = send(start, {"Hubble-Version": version, "Prefer": "respond-async"})
+    while True:
+        if resp.status_code not in (202, 303):
+            raise HubbleError(f"PDF export failed: {resp.status_code}")
+        # Any other version would be a file in a layout the caller did not ask for.
+        served = resp.headers.get("Hubble-Version")
+        if served != version:
+            raise HubbleError(f"Asked for Hubble-Version {version}, got {served!r}")
+        if resp.status_code == 303:
+            break
+        location = resp.headers.get("Content-Location")
+        wait = resp.headers.get("Retry-After")
+        if location is None or wait is None or not wait.isdigit():
+            raise HubbleError("PDF export response has no Content-Location or Retry-After")
+        poll = start.join(location)
+        _require_fhir_namespace(base_url, poll, location)
+        if time.monotonic() + int(wait) > deadline:
+            raise HubbleError("PDF export was not ready before the timeout.")
+        time.sleep(int(wait))
+        resp = send(poll, {})
+    download = resp.headers.get("Location")
+    if download is None:
+        raise HubbleError("PDF export redirect has no Location")
+    file = httpx.get(download)
+    if not file.is_success:
+        raise HubbleError(f"PDF export download failed: {file.status_code}")
+    return _pdf_export(resp, file, version)
+
+
 class Hubble:
     """Client for the Hubble Patient Access API.
 
@@ -276,34 +324,55 @@ class Hubble:
         ``{"_count": ..., "_offset": ...}``."""
         return self.fhir(consent_id, "Patient/$everything", params=params)
 
-    def export_pdf(self, consent_id: str, *, connection: str | None = None) -> PdfExport:
+    def export_pdf(
+        self,
+        consent_id: str,
+        *,
+        connection: str | None = None,
+        version: str | None = None,
+        timeout: float = _EXPORT_TIMEOUT,
+    ) -> PdfExport:
         """The patient's records as PDF via ``Patient/$pdf``: a ZIP of per-source
-        PDFs, or one source's PDF when ``connection`` selects it. See `PdfExport`."""
-        params = {"connection": connection} if connection is not None else None
-        return _pdf_export(
-            self._consent_get(consent_id, _fhir_url(self.base_url, "Patient/$pdf"), params)
+        PDFs, or one source's PDF when ``connection`` selects it. See `PdfExport`.
+
+        Pass ``version`` (a ``Hubble-Version``, such as ``"2026-11-01"``) for that
+        version's export instead. It is built in the background, so this waits up
+        to ``timeout`` seconds for it, then downloads it."""
+        url = _fhir_url(self.base_url, "Patient/$pdf")
+        if connection is not None:
+            url = url.copy_set_param("connection", connection)
+        if version is None:
+            return _pdf_export(self._consent_get(consent_id, url, None))
+        return _versioned_pdf_export(
+            lambda u, headers: self._consent_request(consent_id, u, headers),
+            self.base_url,
+            url,
+            version,
+            timeout,
         )
 
     def _consent_get(
-        self,
-        consent_id: str,
-        url: httpx.URL,
-        params: Mapping[str, Any] | None,
-        retry: bool = True,
+        self, consent_id: str, url: httpx.URL, params: Mapping[str, Any] | None
+    ) -> httpx.Response:
+        resp = self._consent_request(consent_id, url.copy_merge_params(dict(params or {})), {})
+        if not resp.is_success:
+            raise HubbleError(f"FHIR request failed: {resp.status_code}")
+        return resp
+
+    def _consent_request(
+        self, consent_id: str, url: httpx.URL, headers: dict[str, str], retry: bool = True
     ) -> httpx.Response:
         # The control client's connection pool, with the Bearer token replacing its
         # Basic credentials for this one request. `consent` is set last, so a
         # caller's params or a followed link cannot point it at another consent.
         token = self._application_token()
         resp = self._control.get_httpx_client().get(
-            url.copy_merge_params(dict(params or {})).copy_set_param("consent", consent_id),
-            headers={"Authorization": f"Bearer {token}"},
+            url.copy_set_param("consent", consent_id),
+            headers={**headers, "Authorization": f"Bearer {token}"},
         )
         if resp.status_code == 401 and retry:
             self._application_token(stale=token)
-            return self._consent_get(consent_id, url, params, retry=False)
-        if not resp.is_success:
-            raise HubbleError(f"FHIR request failed: {resp.status_code}")
+            return self._consent_request(consent_id, url, headers, retry=False)
         return resp
 
     def _usable_app_token(self, stale: str | None) -> str | None:
@@ -602,7 +671,13 @@ class PatientSession:
         """Read the patient summary via ``Patient/$summary`` (a FHIR Bundle)."""
         return self.fhir("Patient/$summary")
 
-    def export_pdf(self, *, connection: str | None = None) -> PdfExport:
+    def export_pdf(
+        self,
+        *,
+        connection: str | None = None,
+        version: str | None = None,
+        timeout: float = _EXPORT_TIMEOUT,
+    ) -> PdfExport:
         """Export the patient's records as PDF via ``Patient/$pdf``.
 
         Returns a `PdfExport`: the raw body (a ZIP of per-source PDFs plus a
@@ -610,27 +685,42 @@ class PatientSession:
         single PDF when ``connection`` selects one source) together with the
         per-source counts from the response headers, so you can tell how many
         sources failed without opening the archive. Refreshes and retries once
-        on 401."""
-        params = {"connection": connection} if connection is not None else None
-        return _pdf_export(
-            self._fhir_request("Patient/$pdf", params, retry=self.refresh_token is not None)
+        on 401.
+
+        Pass ``version`` (a ``Hubble-Version``, such as ``"2026-11-01"``) for that
+        version's export instead. It is built in the background, so this waits up
+        to ``timeout`` seconds for it, then downloads it."""
+        retry = self.refresh_token is not None
+        url = _fhir_url(self._hubble.base_url, "Patient/$pdf")
+        if connection is not None:
+            url = url.copy_set_param("connection", connection)
+        if version is None:
+            return _pdf_export(self._fhir_request(url, retry))
+        return _versioned_pdf_export(
+            lambda u, headers: self._send(u, headers, retry),
+            self._hubble.base_url,
+            url,
+            version,
+            timeout,
         )
 
     def _fhir_get(self, path: str, params: dict[str, Any] | None, retry: bool) -> dict[str, Any]:
-        return self._fhir_request(path, params, retry).json()
+        url = _fhir_url(self._hubble.base_url, path).copy_merge_params(params or {})
+        return self._fhir_request(url, retry).json()
 
-    def _fhir_request(
-        self, path: str, params: dict[str, Any] | None, retry: bool
-    ) -> httpx.Response:
-        url = _fhir_url(self._hubble.base_url, path)
-        resp = self._data.get_httpx_client().get(url, params=params)
-        if resp.status_code == 401 and retry:
-            self.refresh()
-            return self._fhir_request(path, params, retry=False)
+    def _fhir_request(self, url: httpx.URL, retry: bool) -> httpx.Response:
+        resp = self._send(url, {}, retry)
         if not resp.is_success:
             raise HubbleError(f"FHIR request failed: {resp.status_code}")
         return resp
 
+    def _send(self, url: httpx.URL, headers: dict[str, str], retry: bool) -> httpx.Response:
+        resp = self._data.get_httpx_client().get(url, headers=headers)
+        if resp.status_code == 401 and retry:
+            self.refresh()
+            return self._send(url, headers, retry=False)
+        return resp
+
     def refresh(self) -> None:
         """Exchange the refresh token for a fresh access token (rotating)."""
         if not self.refresh_token:
@@ -688,15 +778,18 @@ class PdfExport:
 
     ``content`` is the raw body — a ZIP of per-source PDFs (with a
     ``manifest.json`` naming each file and marking it complete/partial/failed),
-    or a single PDF when ``connection`` was set. The counts come from the
+    or a single PDF when ``connection`` was set. With a ``version``, it is that
+    version's export, described in the API reference. The counts come from the
     response headers; a non-zero ``sources_failed`` means some records are
-    missing."""
+    missing. ``version`` is the ``Hubble-Version`` served, or ``None`` when none
+    was asked for."""
 
     content: bytes
     content_type: str
     sources_total: int | None = None
     sources_failed: int | None = None
     resource_count: int | None = None
+    version: str | None = None
 
 
 # Invoked whenever a session rotates its tokens (on refresh), so callers can

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/hubble_sdk/_webhooks.py

@@ -60,8 +60,8 @@ class WebhookEvent:
     ``type`` is one of:
 
     - ``consent.created``: a consent was created, from the API or the portal.
-    - ``consent.completed``: the patient finished the link flow, so the device
-      code can be redeemed.
+    - ``consent.completed``: the patient finished the link flow and is done
+      adding sources. Sources still pending keep settling afterwards.
     - ``consent.source.created``: a source was added; ``source.status`` is the
       status it starts in (``available`` if the patient connected it directly,
       ``pending`` if it is retrieved on the patient's behalf).

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/pyproject.toml

@@ -3,7 +3,7 @@
 # none); this file and the build config are not.
 [project]
 name = "hubble-sdk-python"
-version = "0.3.0"
+version = "0.3.1"
 description = "Python client for the Hubble Patient Access API."
 readme = "README.md"
 requires-python = ">=3.11"

{hubble_sdk_python-0.3.0 → hubble_sdk_python-0.3.1}/tests/test_hubble.py

@@ -464,6 +464,104 @@ def test_export_pdf_forwards_connection_and_is_not_partial_without_failures():
     assert "/api/v1/fhir/Patient/$pdf" in str(req.url)
 
 
+VERSION = "2026-11-01"
+STORAGE = "https://exports.example-storage.com/abc.zip?sig=1"
+
+
+def _versioned_export_routes(poll_url: str = "/api/v1/fhir/exports/exp_1"):
+    queued = {"Hubble-Version": VERSION, "Content-Location": poll_url, "Retry-After": "0"}
+    start = respx.get(f"{BASE}/api/v1/fhir/Patient/$pdf").mock(
+        return_value=httpx.Response(202, headers=queued)
+    )
+    poll = respx.get(f"{BASE}/api/v1/fhir/exports/exp_1").mock(
+        side_effect=[
+            httpx.Response(202, headers=queued),
+            httpx.Response(
+                303,
+                headers={
+                    "Hubble-Version": VERSION,
+                    "Location": STORAGE,
+                    "X-Hubble-Sources-Total": "2",
+                    "X-Hubble-Sources-Failed": "0",
+                },
+            ),
+        ]
+    )
+    download = respx.get(STORAGE).mock(
+        return_value=httpx.Response(200, content=b"PK zip", headers={"Content-Type": "application/zip"})
+    )
+    return start, poll, download
+
+
+@respx.mock
+def test_export_pdf_with_a_version_polls_then_downloads_without_the_token():
+    start, poll, download = _versioned_export_routes()
+    session = hub().session("cat_abc")
+
+    result = session.export_pdf(version=VERSION, connection="epic")
+
+    started = start.calls.last.request
+    assert started.headers["Hubble-Version"] == VERSION
+    assert started.headers["Prefer"] == "respond-async"
+    assert started.url.params["connection"] == "epic"
+    assert poll.call_count == 2
+    assert poll.calls.last.request.headers["Authorization"] == "Bearer cat_abc"
+    assert "Authorization" not in download.calls.last.request.headers
+    assert result.content == b"PK zip"
+    assert result.content_type == "application/zip"
+    assert (result.sources_total, result.sources_failed, result.version) == (2, 0, VERSION)
+
+
+@respx.mock
+def test_export_pdf_with_a_version_names_the_consent_on_every_request():
+    _token_route(return_value=httpx.Response(200, json=APP_TOKEN))
+    start, poll, _ = _versioned_export_routes("/api/v1/fhir/exports/exp_1?consent=cns_1")
+
+    hub().export_pdf("cns_1", version=VERSION)
+
+    assert start.calls.last.request.url.params["consent"] == "cns_1"
+    assert all(c.request.url.params["consent"] == "cns_1" for c in poll.calls)
+
+
+@respx.mock
+def test_export_pdf_refuses_a_different_version_than_it_asked_for():
+    respx.get(f"{BASE}/api/v1/fhir/Patient/$pdf").mock(return_value=httpx.Response(200, content=b"%PDF"))
+    with pytest.raises(HubbleError, match="PDF export failed: 200"):
+        hub().session("cat_abc").export_pdf(version=VERSION)
+
+    respx.get(f"{BASE}/api/v1/fhir/Patient/$pdf").mock(
+        return_value=httpx.Response(
+            202, headers={"Content-Location": "/api/v1/fhir/exports/exp_1", "Retry-After": "0"}
+        )
+    )
+    with pytest.raises(HubbleError, match="got None"):
+        hub().session("cat_abc").export_pdf(version=VERSION)
+
+
+@respx.mock
+def test_export_pdf_polls_only_this_apis_fhir_surface():
+    respx.get(f"{BASE}/api/v1/fhir/Patient/$pdf").mock(
+        return_value=httpx.Response(
+            202,
+            headers={"Hubble-Version": VERSION, "Content-Location": "https://evil.example/x", "Retry-After": "0"},
+        )
+    )
+    with pytest.raises(HubbleError, match="Invalid FHIR path"):
+        hub().session("cat_abc").export_pdf(version=VERSION)
+
+
+@respx.mock
+def test_export_pdf_gives_up_after_the_timeout():
+    respx.get(f"{BASE}/api/v1/fhir/Patient/$pdf").mock(
+        return_value=httpx.Response(
+            202,
+            headers={"Hubble-Version": VERSION, "Content-Location": "/api/v1/fhir/exports/exp_1", "Retry-After": "5"},
+        )
+    )
+    with pytest.raises(HubbleError, match="not ready before the timeout"):
+        hub().session("cat_abc").export_pdf(version=VERSION, timeout=1)
+
+
 @respx.mock
 def test_fhir_preserves_slash_and_dollar_in_operation_path():
     route = respx.get(url__regex=rf"{BASE}/api/v1/fhir/Patient/\$everything").mock(