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

hubble_sdk/_hubble.py

@@ -0,0 +1,379 @@
+"""Hand-written ergonomics layer over the generated client.
+
+The generated code under ``_generated`` is a faithful, low-level mapping of the
+OpenAPI contract and is regenerated on every spec change; nothing here is
+generated. This module is the surface users actually import: it defaults the
+base URL, picks the right auth scheme per call (HTTP Basic for the control
+plane, Bearer for the FHIR data plane), builds FHIR URLs correctly, polls the
+device-authorization flow, and refreshes consent tokens transparently.
+"""
+
+from __future__ import annotations
+
+import base64
+import time
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any, TypeVar
+from urllib.parse import unquote
+
+import httpx
+
+from ._generated.api.default import (
+    create_consent_link,
+    exchange_token,
+    get_consent as _get_consent,
+    list_consents as _list_consents,
+    revoke_consent as _revoke_consent,
+)
+from ._generated.client import AuthenticatedClient
+from ._generated.models import (
+    Consent,
+    ConsentLinkRequest,
+    ConsentList,
+    ConsentStatus,
+    DeviceAuthorizationResponse,
+    TokenRequest,
+    TokenRequestGrantType,
+    TokenResponse,
+)
+from ._generated.types import UNSET
+
+DEFAULT_BASE_URL = "https://api.hubble.ai"
+_DEVICE_CODE_GRANT = TokenRequestGrantType("urn:ietf:params:oauth:grant-type:device_code")
+_REFRESH_GRANT = TokenRequestGrantType("refresh_token")
+_PENDING = {"authorization_pending", "slow_down"}
+
+
+def _err_code(parsed: Any) -> str | None:
+    code = getattr(parsed, "error", None)
+    return code.value if hasattr(code, "value") else code
+
+
+_T = TypeVar("_T")
+
+
+def _unwrap(result: Any, expected: type[_T], ctx: str) -> _T:
+    # The generated .sync() returns the success model, an error model, or None.
+    # Route calls through this so a non-success result can't be silently used.
+    if not isinstance(result, expected):
+        raise HubbleError(f"{ctx}: {result}")
+    return result
+
+
+def _ensure_ok(resp: Any, ctx: str) -> None:
+    # For operations with no response body (e.g. a 204): assert a 2xx status.
+    if not 200 <= resp.status_code < 300:
+        raise HubbleError(f"{ctx}: HTTP {resp.status_code}")
+
+
+class Hubble:
+    """Client for the Hubble Patient Access API.
+
+    Args:
+        client_id / client_secret: your application credentials.
+        base_url: defaults to the production host; override only with a trusted
+            value (your access tokens are sent to it).
+    """
+
+    def __init__(self, client_id: str, client_secret: str, base_url: str = DEFAULT_BASE_URL):
+        self.base_url = base_url.rstrip("/")
+        basic = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode()
+        # Control plane authenticates with HTTP Basic.
+        self._control = AuthenticatedClient(base_url=self.base_url, token=basic, prefix="Basic")
+
+    # ── link flow (OAuth device authorization grant) ──────────────────────────
+
+    def create_link(
+        self,
+        *,
+        patient_ref: str | None = None,
+        patient: Mapping[str, Any] | None = None,
+        providers: list[Mapping[str, Any]] | None = None,
+    ) -> DeviceAuthorizationResponse:
+        """Start the patient link flow. Send the patient to the returned
+        ``verification_uri_complete``, then call `wait_for_authorization()`.
+
+        Optionally prefill the link. ``patient`` is a mapping of demographics
+        (``first_name``, ``last_name``, ``birth_date``, ``sex``, ``phone``,
+        ``email``, and a nested ``address``); ``providers`` is a list of provider
+        seeds (each ``{"name": ..., "phone"?: ...}``) to prefill the patient's
+        list. The patient can add, change, or remove any of it on the link page."""
+        body: dict[str, Any] = {}
+        if patient_ref is not None:
+            body["patient_ref"] = patient_ref
+        if patient is not None:
+            body["patient"] = dict(patient)
+        if providers is not None:
+            body["providers"] = [dict(p) for p in providers]
+        return _unwrap(
+            create_consent_link.sync(client=self._control, body=ConsentLinkRequest.from_dict(body)),
+            DeviceAuthorizationResponse,
+            "Could not create consent link",
+        )
+
+    def wait_for_authorization(
+        self,
+        link: DeviceAuthorizationResponse,
+        *,
+        timeout: float = 600.0,
+        on_refresh: RefreshCallback | None = None,
+    ) -> PatientSession:
+        """Poll the token endpoint until the patient authorizes, honoring the
+        server's ``interval`` and ``slow_down``. Returns a `PatientSession`.
+
+        Pass ``on_refresh`` to be notified when the returned session later rotates
+        its tokens, so you can persist the new values."""
+        deadline = time.monotonic() + timeout
+        interval = float(link.interval)
+        while True:
+            resp = exchange_token.sync_detailed(
+                client=self._control,
+                body=TokenRequest(grant_type=_DEVICE_CODE_GRANT, device_code=link.device_code),
+            )
+            if resp.status_code == 200 and isinstance(resp.parsed, TokenResponse):
+                return PatientSession._from_token(self, resp.parsed, on_refresh=on_refresh)
+            code = _err_code(resp.parsed)
+            if code not in _PENDING:
+                raise HubbleError(f"Authorization failed: {code or resp.status_code}")
+            if time.monotonic() >= deadline:
+                raise ConsentTimeout("Patient did not authorize before the timeout.")
+            if code == "slow_down":
+                interval += 5
+            time.sleep(interval)
+
+    # ── consent management (control plane) ────────────────────────────────────
+
+    def list_consents(
+        self, *, status: str | None = None, patient_ref: str | None = None
+    ) -> list[Consent]:
+        """List consents, optionally filtered by ``status`` or ``patient_ref``."""
+        result = _list_consents.sync(
+            client=self._control,
+            status=ConsentStatus(status) if status is not None else UNSET,
+            patient_ref=patient_ref if patient_ref is not None else UNSET,
+        )
+        # _unwrap raises on failure, so this never returns [] to mean "errored".
+        return list(_unwrap(result, ConsentList, "Could not list consents").consents)
+
+    def get_consent(self, consent_id: str) -> Consent:
+        """Fetch a single consent by id."""
+        return _unwrap(
+            _get_consent.sync(id=consent_id, client=self._control),
+            Consent,
+            f"Could not fetch consent {consent_id}",
+        )
+
+    def revoke_consent(self, consent_id: str) -> None:
+        """Revoke a consent. Idempotent; all its tokens stop working immediately."""
+        # 204 with no body — assert success rather than expecting data.
+        _ensure_ok(
+            _revoke_consent.sync_detailed(id=consent_id, client=self._control),
+            f"Could not revoke consent {consent_id}",
+        )
+
+    # ── reconstruct a session from stored tokens ──────────────────────────────
+
+    def session(
+        self,
+        access_token: str,
+        *,
+        refresh_token: str | None = None,
+        consent_id: str | None = None,
+        on_refresh: RefreshCallback | None = None,
+    ) -> PatientSession:
+        """Reconstruct a `PatientSession` from previously stored tokens. Pass
+        ``on_refresh`` to be notified when the session rotates its tokens, so you can
+        persist the new values."""
+        return PatientSession(
+            self,
+            access_token=access_token,
+            refresh_token=refresh_token,
+            consent_id=consent_id,
+            on_refresh=on_refresh,
+        )
+
+
+class PatientSession:
+    """A consent-scoped session for reading one patient's FHIR data.
+
+    Holds the consent tokens and reads the FHIR data plane with a Bearer token,
+    refreshing transparently on expiry. Reconstruct a later session from stored
+    tokens with `Hubble.session()`.
+    """
+
+    def __init__(
+        self,
+        hubble: Hubble,
+        *,
+        access_token: str,
+        refresh_token: str | None = None,
+        consent_id: str | None = None,
+        on_refresh: RefreshCallback | None = None,
+    ):
+        self._hubble = hubble
+        self.access_token = access_token
+        self.refresh_token = refresh_token
+        self.consent_id = consent_id
+        #: Called with the rotated tokens whenever this session refreshes.
+        self.on_refresh = on_refresh
+        self._data = AuthenticatedClient(base_url=hubble.base_url, token=access_token)  # Bearer
+
+    @classmethod
+    def _from_token(
+        cls, hubble: Hubble, tr: TokenResponse, on_refresh: RefreshCallback | None = None
+    ) -> PatientSession:
+        return cls(
+            hubble,
+            access_token=tr.access_token,
+            refresh_token=tr.refresh_token,
+            consent_id=tr.consent_id,
+            on_refresh=on_refresh,
+        )
+
+    # ── FHIR data plane (Bearer) ──────────────────────────────────────────────
+
+    def fhir(self, path: str, *, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """GET a FHIR path, e.g. ``"Patient/$everything"`` or ``"Observation"``.
+
+        Returns the raw FHIR R4 resource as JSON (a dict). To work with typed
+        models, parse it with the optional ``fhir.resources`` package, e.g.
+        ``from fhir.resources.bundle import Bundle; Bundle.model_validate(result)``.
+
+        The path is passed through httpx unencoded, so ``/`` and ``$`` survive
+        (unlike the raw generated client). Refreshes and retries once on 401."""
+        return self._fhir_get(path, params, retry=self.refresh_token is not None)
+
+    def everything(self, **params: Any) -> dict[str, Any]:
+        """Read the patient's full record via ``Patient/$everything`` (a FHIR Bundle)."""
+        return self.fhir("Patient/$everything", params=params or None)
+
+    def summary(self) -> dict[str, Any]:
+        """Read the patient summary via ``Patient/$summary`` (a FHIR Bundle)."""
+        return self.fhir("Patient/$summary")
+
+    def export_pdf(self, *, connection: str | None = None) -> 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
+        ``manifest.json`` marking each source complete/partial/failed, or a
+        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
+        resp = self._fhir_request("Patient/$pdf", params, retry=self.refresh_token is not None)
+
+        def _count(header: str) -> int | None:
+            try:
+                return int(resp.headers[header])
+            except (KeyError, ValueError):
+                return None
+
+        return PdfExport(
+            content=resp.content,
+            content_type=resp.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"),
+        )
+
+    def _fhir_get(self, path: str, params: dict[str, Any] | None, retry: bool) -> dict[str, Any]:
+        return self._fhir_request(path, params, retry).json()
+
+    def _fhir_request(
+        self, path: str, params: dict[str, Any] | None, retry: bool
+    ) -> httpx.Response:
+        # Guard against escaping the FHIR namespace (which would send the consent
+        # token there): URL resolution normalizes raw `..`, and decoding then
+        # catches percent-encoded (`%2e%2e`) segments a server might resolve.
+        url = httpx.URL(self._hubble.base_url).join(f"/api/v1/fhir/{path.lstrip('/')}")
+        if not url.path.startswith("/api/v1/fhir/") or ".." in unquote(url.path).split("/"):
+            raise HubbleError(f"Invalid FHIR path: {path!r}")
+        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)
+        if not resp.is_success:
+            raise HubbleError(f"FHIR request failed: {resp.status_code}")
+        return resp
+
+    def refresh(self) -> None:
+        """Exchange the refresh token for a fresh access token (rotating)."""
+        if not self.refresh_token:
+            raise HubbleError("No refresh token available to refresh this session.")
+        result = _unwrap(
+            exchange_token.sync(
+                client=self._hubble._control,
+                body=TokenRequest(grant_type=_REFRESH_GRANT, refresh_token=self.refresh_token),
+            ),
+            TokenResponse,
+            "Token refresh failed",
+        )
+        self.access_token = result.access_token
+        self.refresh_token = result.refresh_token
+        # Close the old client's connection pool before replacing it with one
+        # carrying the new token, so rotating tokens does not leak connections.
+        self._data.get_httpx_client().close()
+        self._data = AuthenticatedClient(base_url=self._hubble.base_url, token=self.access_token)
+        # Notify the caller so it can persist the rotated tokens.
+        if self.on_refresh is not None:
+            self.on_refresh(
+                TokenSet(
+                    access_token=self.access_token,
+                    refresh_token=self.refresh_token,
+                    consent_id=self.consent_id,
+                )
+            )
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        self._data.get_httpx_client().close()
+
+    def __enter__(self) -> PatientSession:
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+
+# ── callback types and errors ─────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class TokenSet:
+    """The rotating token set a session holds; passed to an ``on_refresh`` callback."""
+
+    access_token: str
+    refresh_token: str | None = None
+    consent_id: str | None = None
+
+
+@dataclass(frozen=True)
+class PdfExport:
+    """The result of `PatientSession.export_pdf`.
+
+    ``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
+    response headers; a non-zero ``sources_failed`` means some records are
+    missing."""
+
+    content: bytes
+    content_type: str
+    sources_total: int | None = None
+    sources_failed: int | None = None
+    resource_count: int | None = None
+
+
+# Invoked whenever a session rotates its tokens (on refresh), so callers can
+# persist the new values.
+RefreshCallback = Callable[["TokenSet"], None]
+
+
+class HubbleError(Exception):
+    """Base error for the Hubble client."""
+
+
+class ConsentTimeout(HubbleError):
+    """The patient did not authorize before the timeout elapsed."""

hubble_sdk_python-0.0.2.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,46 @@
+hubble_sdk/__init__.py,sha256=lyGGBoULJqdApAePja5KAOjHMMhM60F-XhvLXJR2dm4,1042
+hubble_sdk/_hubble.py,sha256=JI6gF3AfgDn37NkkBXWkzUgJsTSVCF647da1N95TO4E,15489
+hubble_sdk/_generated/__init__.py,sha256=vHzWGo0njcFBcxGMOUuCWyhYdJi_xldILX7pdrPzdYA,168
+hubble_sdk/_generated/client.py,sha256=aXn2Tt52-cnyAkBJcNlIzxMx35J2g6FneRGuk_wlA40,12530
+hubble_sdk/_generated/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
+hubble_sdk/_generated/types.py,sha256=0We4NPvhIYASRpQ3le41nmJeEAVm42-2VKdzlJ4Ogok,1343
+hubble_sdk/_generated/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
+hubble_sdk/_generated/api/default/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
+hubble_sdk/_generated/api/default/attach_client_authorization.py,sha256=ZeMTt7o3tVJlI2hJHZ3v7iz1H4DiLo33kYh64vY-SLE,6622
+hubble_sdk/_generated/api/default/create_consent_link.py,sha256=88KZtzq0cJ9hLZpNQqzpj2GjR0rmxzHTSWvqmMCGFW8,6377
+hubble_sdk/_generated/api/default/exchange_token.py,sha256=86ysMEnY2jOUItEHEv06zeszFe4k2vxjn4h0nzvR8zk,5268
+hubble_sdk/_generated/api/default/export_patient_pdf.py,sha256=1EwGf-H1HMo0L0SwwzuTsml3lfWESexYwDQWLYClFus,6269
+hubble_sdk/_generated/api/default/get_consent.py,sha256=UkH6LMTsx2Mmqg9xgkIymw08QuJvcu1DMzuevi6z4pM,3808
+hubble_sdk/_generated/api/default/list_consents.py,sha256=LOcrDwTiRh4MV0-PigLYZWY1dkUfdyljNBA7d8zAa64,4906
+hubble_sdk/_generated/api/default/read_fhir.py,sha256=1sny0rT0ToKQ1sCWciEASQCUH-fOv4RNvbS80U2x2BU,5026
+hubble_sdk/_generated/api/default/revoke_consent.py,sha256=ocFu3svKMa-E2EKIPTE-JYZ7D0-ye9mR_XUNj58mwWE,3966
+hubble_sdk/_generated/models/__init__.py,sha256=iQFE98ouXrDKUs23VmpQcQFr7Qkdheexnp-rVy8Pg84,2053
+hubble_sdk/_generated/models/api_error.py,sha256=RrgLT6j31RWPbyMsgkFcu5DWaWi1aJooVL7C24gbGhw,780
+hubble_sdk/_generated/models/attach_client_authorization_body.py,sha256=ur71Z-fbahmKaJ0r68fkpAvaAM2ShtR1xc2ypqeNmAY,3475
+hubble_sdk/_generated/models/attach_client_authorization_response_201.py,sha256=5L2MNvzlYkpFFbt-oJI9fPf1r2oCZ9cIReqkcMn_0Wc,3220
+hubble_sdk/_generated/models/attach_client_authorization_response_201_status.py,sha256=B8XSR9rNquad1znJZygM-U47W-HNFe6DEi0QPLUt504,171
+hubble_sdk/_generated/models/consent.py,sha256=azEAKRMCeFAav3qcFhylMct1GnXQRmGcR8HJp9FwLcU,4949
+hubble_sdk/_generated/models/consent_error.py,sha256=6FO1yRkKkpS7ENGBZeCExFqjugzhScYYDV-W9A4t47Y,1030
+hubble_sdk/_generated/models/consent_link_request.py,sha256=I7GxVFnqwcrn-BNvzxZVjD1cUu-NEYhbe-tdn8MCyVI,2853
+hubble_sdk/_generated/models/consent_list.py,sha256=y9oZYL7QU6UQvm4qf9J_RbvLQnjWZvydhbpX6GO-Ld4,1250
+hubble_sdk/_generated/models/consent_source.py,sha256=3uj5-xud14iKW_jOO711CpnGsWFeGWs0LDALmg8kEJ0,1688
+hubble_sdk/_generated/models/consent_source_status.py,sha256=AMApXkgwZN0j8DOmwYPBh2zinjXriHYM39yRGjN4u-4,198
+hubble_sdk/_generated/models/consent_source_type.py,sha256=qfwhIElp1PQDuLgUdQryn-_aTDvZ8xkLUfIq237_MK4,166
+hubble_sdk/_generated/models/consent_status.py,sha256=jXZ3_yQ-M0vvoVuvs3vBbLnGcWPXYF-5ERz144_48aA,232
+hubble_sdk/_generated/models/device_authorization_request.py,sha256=fSilSwVylrWSzwLv_4LIGwh1kaIunr2pcdOx8sPZQpg,5138
+hubble_sdk/_generated/models/device_authorization_response.py,sha256=LWsLmhthCw_eRO_DaYrVdFPR8XTU6ZfS95FZYR2-DrY,2627
+hubble_sdk/_generated/models/fhir_resource.py,sha256=RWGpFkFgJVFdRleOKM8WTiFl4RFhM0wa_FjFVsaLvBI,1635
+hubble_sdk/_generated/models/o_auth_error.py,sha256=mrAIGsI6Cxq1f_xHPXD53xwMS_OI6lEJZ_SXObpnmxc,1252
+hubble_sdk/_generated/models/o_auth_error_error.py,sha256=lpg84xgoJ_hW8qaJr6CUJfBH1tsSKgeQfb7D1hStuIQ,474
+hubble_sdk/_generated/models/operation_outcome.py,sha256=oGYvHr9__XZ3wOP_LADPH9P8CCSjtvppAz6AS40az9U,1877
+hubble_sdk/_generated/models/operation_outcome_issue_item.py,sha256=wmV4n_E0880pwYchBbWH8f9PXRbR8atuzjK5Ep-54y0,1318
+hubble_sdk/_generated/models/patient_address.py,sha256=cajHVQIuvGl83SkQNdgwvdZOzfWTYNo8hRW2azNmTec,1619
+hubble_sdk/_generated/models/patient_demographics.py,sha256=igIRoU9SBKmnyEXjTJ_VIW-It19Z5y40Wn72wLZ6V5g,3000
+hubble_sdk/_generated/models/provider_seed.py,sha256=EmvivHxaDLQzl5H64FeZ86mUyTTxxUZB5KfFhhqm218,1133
+hubble_sdk/_generated/models/token_request.py,sha256=8ZOQVJIIPPTdtAUeuG8ADeQdz0QHrc0yyrR9pXXMjVM,2391
+hubble_sdk/_generated/models/token_request_grant_type.py,sha256=1PyWEyd65JbKn_gDDXoSa808pjia0Xj3hmPk-67XNZg,317
+hubble_sdk/_generated/models/token_response.py,sha256=HORaPEpLNuPdCtGMlR-CXt8sQEYQH6gEp0gNTpQoFeE,2121
+hubble_sdk_python-0.0.2.dist-info/METADATA,sha256=--IFrEDXx-xbr52oV5KcRxBFP3xTxWU-esOlqJroq4E,3773
+hubble_sdk_python-0.0.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+hubble_sdk_python-0.0.2.dist-info/licenses/LICENSE,sha256=S8zTUFi7pK2HOg-wSn6bFAWbNAO4Lt1UiyDu_vcqO6w,1063
+hubble_sdk_python-0.0.2.dist-info/RECORD,,

hubble_sdk_python-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hubble_sdk_python-0.0.2.dist-info/licenses/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.