preflight-sdk 1.0.0__py3-none-any.whl

preflight_sdk/__init__.py

@@ -0,0 +1,45 @@
+from ._version import API_VERSION, SDK_VERSION
+from .client import UNAVAILABLE, Preflight, new_idempotency_key, parse_retry_after, unavailable_decision
+from .errors import (
+    AuthenticationError,
+    ConflictError,
+    InvalidRequestError,
+    NetworkError,
+    NotFoundError,
+    PermissionDeniedError,
+    PreflightError,
+    RateLimitError,
+    RequestTimeoutError,
+    ServerError,
+)
+from .webhooks import verify_webhook
+from .types import (
+    BatchJob,
+    BatchResult,
+    CheckRequest,
+    ConsentRequest,
+    Decision,
+    Evidence,
+    EvidencePdf,
+    ImportOptions,
+    ListKind,
+    NewList,
+    Obligation,
+    OptOutRequest,
+    Outcome,
+    OutcomeReceipt,
+    Reason,
+    ReasonCode,
+)
+
+__all__ = [
+    "UNAVAILABLE", "Preflight", "PreflightError", "unavailable_decision",
+    "BatchJob", "BatchResult", "CheckRequest", "ConsentRequest", "Decision", "Evidence", "EvidencePdf", "ImportOptions", "ListKind", "NewList", "Obligation",
+    "OptOutRequest", "Outcome", "OutcomeReceipt", "Reason", "ReasonCode",
+]
+__all__ += ["verify_webhook"]
+__all__ += [
+    "API_VERSION", "SDK_VERSION", "new_idempotency_key", "parse_retry_after",
+    "AuthenticationError", "ConflictError", "InvalidRequestError", "NetworkError", "NotFoundError",
+    "PermissionDeniedError", "RateLimitError", "RequestTimeoutError", "ServerError",
+]

preflight_sdk/_version.py

@@ -0,0 +1,4 @@
+SDK_VERSION = "1.0.0"
+"""This SDK's version. Sent as ``User-Agent: preflight-sdk-python/<version>``."""
+API_VERSION = "1"
+"""The API version this SDK speaks: the ``/v1`` path prefix and docs/openapi.yaml ``info.version``."""

preflight_sdk/client.py

@@ -0,0 +1,514 @@
+from __future__ import annotations
+
+import email.utils
+import json
+import random
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Dict, List, Optional, Sequence
+
+from ._version import SDK_VERSION
+from .errors import NetworkError, PreflightError, RequestTimeoutError, error_for_status
+from .types import (
+    BatchJob,
+    CheckRequest,
+    ConsentRequest,
+    Decision,
+    Evidence,
+    EvidencePdf,
+    ImportOptions,
+    NewList,
+    OptOutRequest,
+)
+
+UNAVAILABLE = "preflight_unavailable"
+OUTCOMES = ("placed", "not_placed", "failed")
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    """Refuse every redirect: urllib would copy Authorization to the new location, even on another host. The 30x
+    then surfaces as an HTTPError (a 4xx-class failure, so check() fails closed and nothing is retried)."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):  # type: ignore[no-untyped-def]
+        return None
+
+
+_OPENER = urllib.request.build_opener(_NoRedirect)
+
+
+def _seg(s: str) -> str:
+    """One path segment, percent-encoded."""
+    return urllib.parse.quote(s, safe="")
+
+
+def _query(q: Dict[str, Any]) -> str:
+    """`?a=1&b=2` from the values that are not None (booleans as true/false), or "" when there are none."""
+    pairs = [(k, str(v).lower() if isinstance(v, bool) else str(v)) for k, v in q.items() if v is not None]
+    return "?" + urllib.parse.urlencode(pairs) if pairs else ""
+
+
+_ERROR_BODY_CAP = 64 * 1024  # an error body only carries {"error": {"code", "message", "request_id"}}
+
+
+def _read_body(resp: Any, deadline: float, cap: Optional[int] = None) -> bytes:
+    """Read a response body in chunks, raising TimeoutError once the monotonic deadline passes; stop at `cap`."""
+    chunks: List[bytes] = []
+    n = 0
+    while cap is None or n < cap:
+        if time.monotonic() >= deadline:
+            raise TimeoutError("deadline exceeded while reading the response")
+        chunk = resp.read1(65536)
+        if not chunk:
+            break
+        chunks.append(chunk)
+        n += len(chunk)
+    return b"".join(chunks)[:cap]
+
+
+def unavailable_decision(message: str, status: Optional[int] = None, idempotency_key: Optional[str] = None) -> Decision:
+    """The decision to act on when there is no answer: do not dial. There is no fail-open mode."""
+    reason: Dict[str, Any] = {"code": UNAVAILABLE, "message": message}
+    if status is not None:
+        reason["status"] = status
+    if idempotency_key is not None:
+        reason["idempotency_key"] = idempotency_key
+    return {"decision": "block", "reasons": [reason], "obligations": [], "warnings": []}  # type: ignore[return-value]
+
+
+def new_idempotency_key() -> str:
+    """A fresh Idempotency-Key. Every write already gets one per call; pass your own (`idempotency_key=`) when you
+    retry a failed call yourself, so a write that landed before its answer was lost is replayed, not recorded twice."""
+    return str(uuid.uuid4())
+
+
+def parse_retry_after(value: Optional[str], now: Optional[float] = None) -> Optional[float]:
+    """Seconds to wait from a Retry-After header (delay-seconds or an HTTP date), or None when absent or unreadable."""
+    if value is None:
+        return None
+    v = value.strip()
+    if v.isascii() and v.isdigit() and len(v) <= 9:
+        return float(int(v))
+    try:
+        at = email.utils.parsedate_to_datetime(v)
+    except (TypeError, ValueError, IndexError):
+        return None
+    if at is None or at.tzinfo is None:
+        return None
+    return max(0.0, at.timestamp() - (time.time() if now is None else now))
+
+
+def _retryable(e: PreflightError) -> bool:
+    """Whether a failed attempt may be repeated: no response, a timeout, a 429 or a 5xx."""
+    return e.status is None or e.status == 429 or e.status >= 500
+
+
+class _Retry:
+    """How many times, and how patiently, a call is retried. Backoff before retry n (from 0) is uniform in
+    [0, min(max_delay, base * 2**n)) ("full jitter"); a Retry-After longer than `max_delay` ends the call."""
+
+    def __init__(self, retries: int, base: float, max_delay: float):
+        self.retries = retries
+        self.base = base
+        self.max_delay = max_delay
+
+
+class Preflight:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        *,
+        check_timeout: float = 0.3,
+        request_timeout: float = 10.0,
+        throw_on_error: bool = False,
+        max_retries: int = 2,
+        check_max_retries: int = 1,
+        retry_base_delay: float = 0.2,
+        max_retry_delay: float = 10.0,
+    ):
+        """Timeouts and delays are in seconds; timeouts are per attempt. `check_timeout` defaults to 300 ms.
+
+        A network error, timeout, 429 or 5xx is retried: `max_retries` times for every call except check() and the
+        creates the server does not deduplicate (never retried), `check_max_retries` times for check(). Retry n waits
+        a random time up to `retry_base_delay * 2**n`, or the server's Retry-After, at most `max_retry_delay`; a
+        longer Retry-After raises at once. check() never waits longer than its timeout."""
+        self._base = base_url.rstrip("/")
+        self._key = api_key
+        self._check_timeout = check_timeout
+        self._timeout = request_timeout
+        self._throw = throw_on_error
+        self._retry = _Retry(max_retries, retry_base_delay, max_retry_delay)
+        # check() sits in front of a dial: a Retry-After (whole seconds) ends it at once with the fail-closed decision.
+        self._check_retry = _Retry(check_max_retries, min(retry_base_delay, 0.025), check_timeout)
+
+    def _attempt(
+        self, method: str, path: str, data: Optional[bytes], headers: Dict[str, str], timeout: float
+    ) -> "tuple[bytes, int, Any]":
+        """One attempt with a total deadline. `urlopen(timeout=)` only bounds each socket operation, so a server
+        that drips bytes could outlast it: the attempt runs in a daemon thread that we stop waiting for at the
+        deadline (the body is read in chunks against the same monotonic deadline, so the thread ends soon after)."""
+        deadline = time.monotonic() + timeout
+        box: Dict[str, Any] = {}
+
+        def run() -> None:
+            try:
+                req = urllib.request.Request(self._base + path, data=data, headers=headers, method=method)
+                with _OPENER.open(req, timeout=timeout) as resp:
+                    box["ok"] = (_read_body(resp, deadline), resp.status, resp.headers)
+            except urllib.error.HTTPError as e:
+                # A non-2xx (or refused 30x): read its body here, under the same deadline and capped, not in the
+                # caller's thread where only the per-socket timeout would bound a server that drips its error page.
+                try:
+                    e.preflight_body = _read_body(e, deadline, _ERROR_BODY_CAP)  # type: ignore[attr-defined]
+                except Exception:  # a failure while reading the error body is still a server-side failure
+                    e.preflight_body = b""  # type: ignore[attr-defined]
+                finally:
+                    e.close()
+                box["err"] = e
+            except BaseException as e:  # handed back to the caller's thread
+                box["err"] = e
+
+        t = threading.Thread(target=run, daemon=True)
+        t.start()
+        t.join(max(0.0, deadline - time.monotonic()))
+        if t.is_alive():
+            raise TimeoutError(f"no complete response within {timeout}s")
+        if "err" in box:
+            raise box["err"]
+        return box["ok"]
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Any,
+        timeout: float,
+        idempotency_key: Optional[str],
+        *,
+        content_type: Optional[str] = None,
+        binary: bool = False,
+        retry: Optional[_Retry] = None,
+    ) -> Any:
+        """A network error, a timeout, a 429 or a 5xx is retried (up to the policy's count, with jittered
+        exponential backoff or the server's Retry-After); any other status is not. Every attempt of a POST sends the
+        same Idempotency-Key, and the server replays a key it has already answered, so a retry never records a
+        write twice. Returns parsed JSON or raises PreflightError.
+
+        `content_type` sends `body` (bytes or str) as is instead of as JSON; `binary` returns (bytes, headers)
+        instead of parsing JSON."""
+        headers = {"Authorization": f"Bearer {self._key}", "User-Agent": f"preflight-sdk-python/{SDK_VERSION}"}
+        data = None
+        if body is not None:
+            if content_type:
+                data = body.encode() if isinstance(body, str) else bytes(body)
+            else:
+                data = json.dumps(body).encode()
+            headers["Content-Type"] = content_type or "application/json"
+        if method == "POST":
+            headers["Idempotency-Key"] = idempotency_key or new_idempotency_key()
+        policy = retry or self._retry
+        retries = policy.retries
+        attempt = 0
+        while True:
+            try:
+                return self._one(method, path, data, headers, timeout, binary)
+            except PreflightError as e:
+                err = e
+            if attempt >= retries or not _retryable(err):
+                raise err
+            if err.retry_after is not None:
+                if err.retry_after > policy.max_delay:
+                    raise err  # the caller decides whether to wait that long
+                wait = err.retry_after
+            else:
+                wait = random.uniform(0, min(policy.max_delay, policy.base * 2**attempt))
+            time.sleep(wait)
+            attempt += 1
+
+    def _one(
+        self, method: str, path: str, data: Optional[bytes], headers: Dict[str, str], timeout: float, binary: bool
+    ) -> Any:
+        """One attempt: the response, or a PreflightError subclass saying why not."""
+        try:
+            raw, status, resp_headers = self._attempt(method, path, data, headers, timeout)
+        except urllib.error.HTTPError as e:
+            text = getattr(e, "preflight_body", b"").decode(errors="replace")
+            try:
+                parsed = json.loads(text)
+            except ValueError:
+                parsed = None
+            err = parsed.get("error") if isinstance(parsed, dict) else None
+            err = err if isinstance(err, dict) else {}
+            retry_after = parse_retry_after(e.headers.get("Retry-After") if e.headers is not None else None)
+            raise error_for_status(
+                e.code, err.get("message") or f"preflight {e.code}", err.get("code"), parsed, retry_after
+            ) from None
+        except Exception as e:  # URLError, timeouts, http.client.HTTPException, bad encodings
+            reason = getattr(e, "reason", None)
+            if isinstance(e, TimeoutError) or isinstance(reason, TimeoutError):
+                raise RequestTimeoutError(f"no complete response within {timeout}s: {e!r}") from None
+            raise NetworkError(f"network error: {e!r}") from None
+        if binary:
+            return raw, resp_headers
+        try:
+            return json.loads(raw.decode())
+        except ValueError:
+            raise PreflightError("unreadable response body", status) from None
+
+    def check(
+        self,
+        req: CheckRequest,
+        *,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+        throw_on_error: Optional[bool] = None,
+    ) -> Decision:
+        """Ask before every call or text. Never raises by default: on a timeout, network error, 429, 5xx (after one
+        quick retry, never a wait longer than the timeout) or 4xx it returns {"decision": "block", "reasons": [{"code": "preflight_unavailable"}]}. Treat that
+        as do-not-dial. With throw_on_error=True it raises PreflightError instead. There is no fail-open mode."""
+        idempotency_key = idempotency_key or new_idempotency_key()
+        try:
+            d = self._request(
+                "POST",
+                "/v1/check",
+                dict(req),
+                self._check_timeout if timeout is None else timeout,
+                idempotency_key,
+                retry=self._check_retry,
+            )
+            if (
+                not isinstance(d, dict)
+                or d.get("decision") not in ("allow", "defer", "block")
+                or not isinstance(d.get("reasons"), list)
+            ):
+                raise PreflightError("malformed decision in response", 200)
+            return d
+        except Exception as e:  # never let a check() call raise unless asked to: fail closed
+            pe = e if isinstance(e, PreflightError) else PreflightError(f"unexpected error: {e!r}")
+            if self._throw if throw_on_error is None else throw_on_error:
+                if pe is e:
+                    raise
+                raise pe from e
+            return unavailable_decision(str(pe), pe.status, idempotency_key)
+
+    def release_unplaced(
+        self, req: CheckRequest, unavailable: Decision, *, timeout: Optional[float] = None
+    ) -> Optional[Dict[str, Any]]:
+        """After check() returned the preflight_unavailable block, the server may still have recorded the check as
+        an allowed attempt that you never dialed. This replays the check under the key the block carries (the server
+        answers with the stored decision while the key is within its 5 minute window) and, if that was an allowed,
+        committed check, reports "not_placed" so it stops counting toward frequency and volume caps. Pass the same
+        request and the block decision. Returns the receipt, or None when there was nothing to release (no key on
+        the decision, or the check was not an allow). Raises PreflightError on any failure: retry it."""
+        key = next((r.get("idempotency_key") for r in unavailable["reasons"] if r.get("code") == UNAVAILABLE), None)
+        if key is None:
+            return None
+        d = self._request("POST", "/v1/check", dict(req), self._t(timeout), key)
+        if not isinstance(d, dict) or d.get("decision") != "allow" or d.get("committed") is not True or not isinstance(d.get("check_id"), str):
+            return None
+        return self.report_outcome(d["check_id"], "not_placed", timeout=timeout)
+
+    def record_consent(
+        self, req: ConsentRequest, *, idempotency_key: Optional[str] = None, timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """Record consent where you collect it. Raises PreflightError on any failure."""
+        return self._request(
+            "POST", "/v1/consents", dict(req), self._timeout if timeout is None else timeout, idempotency_key
+        )
+
+    def record_opt_out(
+        self, req: OptOutRequest, *, idempotency_key: Optional[str] = None, timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """Send every opt-out here. Raises PreflightError on any failure: retry it until it succeeds."""
+        return self._request(
+            "POST", "/v1/opt-outs", dict(req), self._timeout if timeout is None else timeout, idempotency_key
+        )
+
+    def report_outcome(
+        self,
+        check_id: str,
+        outcome: str,
+        provider_ref: Optional[str] = None,
+        *,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Report what happened to an allowed, committed check once the call or text ends: "placed", "not_placed"
+        (never sent) or "failed" (sent to the provider, never reached the line). Only "placed" keeps counting as an
+        attempt. Raises PreflightError on any failure, including a bad `outcome`: retry it until it succeeds."""
+        if outcome not in OUTCOMES:
+            raise PreflightError(f"outcome must be one of {', '.join(OUTCOMES)}", None, "invalid_outcome")
+        body: Dict[str, Any] = {"outcome": outcome}
+        if provider_ref is not None:
+            body["provider_ref"] = provider_ref
+        path = f"/v1/checks/{urllib.parse.quote(check_id, safe='')}/outcome"
+        return self._request("POST", path, body, self._timeout if timeout is None else timeout, idempotency_key)
+
+    def get_evidence(self, phone: str, *, timeout: Optional[float] = None) -> Evidence:
+        """Everything Preflight holds about one number."""
+        path = "/v1/evidence?" + urllib.parse.urlencode({"phone": phone})
+        return self._request("GET", path, None, self._timeout if timeout is None else timeout, None)
+
+    def _t(self, timeout: Optional[float]) -> float:
+        return self._timeout if timeout is None else timeout
+
+    def revoke_consent(
+        self,
+        consent_id: str,
+        reason: Optional[str] = None,
+        *,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Revoke a consent (idempotent: revoking again keeps the first revocation). Raises PreflightError on any
+        failure."""
+        body: Dict[str, Any] = {} if reason is None else {"reason": reason}
+        return self._request("POST", f"/v1/consents/{_seg(consent_id)}/revoke", body, self._t(timeout), idempotency_key)
+
+    def get_consent_capture(self, capture_id: str, *, timeout: Optional[float] = None) -> Dict[str, Any]:
+        """A consent capture's certificate (from the consent widget), pending, claimed or expired."""
+        return self._request("GET", f"/v1/consent-captures/{_seg(capture_id)}", None, self._t(timeout), None)
+
+    def claim_consent_capture(
+        self, capture_id: str, phone: str, *, idempotency_key: Optional[str] = None, timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """Claim a widget capture as consent. `phone` must be the phone from the form submission you accepted; the
+        server refuses the claim (409) if it is not the capture's. Raises PreflightError on any failure."""
+        path = f"/v1/consent-captures/{_seg(capture_id)}/claim"
+        return self._request("POST", path, {"phone": phone}, self._t(timeout), idempotency_key)
+
+    def create_list(
+        self, list_: NewList, *, idempotency_key: Optional[str] = None, timeout: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """Create a list (national_dnc, state_dnc, litigator, reassigned or custom). Retried with the same
+        Idempotency-Key, so a retry never creates a second list."""
+        return self._request("POST", "/v1/lists", dict(list_), self._t(timeout), idempotency_key)
+
+    def _all_pages(self, path: str, timeout: Optional[float]) -> Dict[str, Any]:
+        """Every row of a list endpoint, following next_cursor page by page: {"data": [...]}."""
+        data: list = []
+        cursor: Optional[str] = None
+        while True:
+            q = _query({"limit": 1000, "cursor": cursor})
+            page = self._request("GET", path + q, None, self._t(timeout), None)
+            data.extend(page.get("data") or [])
+            cursor = page.get("next_cursor")
+            if not cursor:
+                return {"data": data}
+
+    def list_lists(self, *, timeout: Optional[float] = None) -> Dict[str, Any]:
+        """The workspace's lists with entry counts and freshness, every page: {"data": [...]}."""
+        return self._all_pages("/v1/lists", timeout)
+
+    def import_list_entries(
+        self,
+        list_id: str,
+        text: "str | bytes",
+        *,
+        options: Optional[ImportOptions] = None,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Import entries into a list: delimited text, one entry per line, sent as is (see the README for the
+        format and options). A large file needs a larger `timeout` than the default. Raises PreflightError on any
+        failure, including a refused replace. Retried with the same Idempotency-Key: the server answers a repeat of
+        the same file and options with the first import's result instead of importing again."""
+        path = f"/v1/lists/{_seg(list_id)}/entries" + _query(dict(options or {}))
+        return self._request("POST", path, text, self._t(timeout), idempotency_key, content_type="text/plain")
+
+    def get_check_evidence(self, check_id: str, *, timeout: Optional[float] = None) -> Dict[str, Any]:
+        """The evidence bundle for one check, with its SHA-256 and the audit chain status."""
+        return self._request("GET", f"/v1/checks/{_seg(check_id)}/evidence", None, self._t(timeout), None)
+
+    def get_check_evidence_pdf(self, check_id: str, *, timeout: Optional[float] = None) -> EvidencePdf:
+        """The same evidence as a PDF, with the bundle's SHA-256 from the response header."""
+        path = f"/v1/checks/{_seg(check_id)}/evidence.pdf"
+        pdf, headers = self._request("GET", path, None, self._t(timeout), None, binary=True)
+        return {"pdf": pdf, "bundle_sha256": headers.get("X-Preflight-Evidence-Sha256")}
+
+    def get_rule_changes(self, since: Optional[str] = None, *, timeout: Optional[float] = None) -> Dict[str, Any]:
+        """Changes to the rule data since a rules version (YYYY-MM-DD.N) or a date, oldest first."""
+        return self._request("GET", "/v1/rules/changes" + _query({"since": since}), None, self._t(timeout), None)
+
+    def get_rule_impact(
+        self,
+        *,
+        since: Optional[str] = None,
+        until: Optional[str] = None,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Your recent checks re-evaluated under the deployed rules (last 30 days, paged by next_cursor)."""
+        q = _query({"since": since, "until": until, "cursor": cursor, "limit": limit})
+        return self._request("GET", "/v1/rules/impact" + q, None, self._t(timeout), None)
+
+    def create_webhook(
+        self,
+        url: str,
+        events: Optional[Sequence[str]] = None,
+        *,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Register a webhook endpoint. The response carries its signing secret. Retried with the same
+        Idempotency-Key: the server replays the first response (secret included), so a retry never makes a second
+        endpoint."""
+        body: Dict[str, Any] = {"url": url}
+        if events is not None:
+            body["events"] = list(events)
+        return self._request("POST", "/v1/webhooks", body, self._t(timeout), idempotency_key)
+
+    def list_webhooks(self, *, timeout: Optional[float] = None) -> Dict[str, Any]:
+        """The workspace's webhook endpoints with pending and failed delivery counts, every page: {"data": [...]}."""
+        return self._all_pages("/v1/webhooks", timeout)
+
+    def delete_webhook(self, webhook_id: str, *, timeout: Optional[float] = None) -> Dict[str, Any]:
+        """Disable a webhook endpoint and cancel its pending deliveries (deleting again changes nothing)."""
+        return self._request("DELETE", f"/v1/webhooks/{_seg(webhook_id)}", None, self._t(timeout), None)
+
+    def batch(
+        self,
+        items: Sequence[CheckRequest],
+        *,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        max_wait: float = 600.0,
+        page_size: int = 1000,
+    ) -> BatchJob:
+        """Screen a list (screening only: items must not set commit=True). Submits the job, polls until it is
+        done and returns every result in item order. Raises PreflightError if the job fails, polling runs out of
+        time or a call fails: no answer means do not dial. An item the server could not evaluate comes back as
+        {"error": {...}}."""
+        t = self._timeout if timeout is None else timeout
+        job_id = self._request("POST", "/v1/checks/batch", {"items": list(items)}, t, idempotency_key)["job_id"]
+        path = f"/v1/checks/batch/{_seg(job_id)}"
+        deadline = time.monotonic() + max_wait
+        while True:
+            s = self._request("GET", f"{path}?limit=1", None, t, None)
+            if s.get("status") == "done":
+                break
+            if s.get("status") == "failed":
+                raise PreflightError(f"batch job {job_id} failed: {s.get('error') or 'unknown'}", None, "batch_failed", s)
+            if time.monotonic() >= deadline:
+                raise PreflightError(f"batch job {job_id} not done in time", None, "batch_timeout")
+            time.sleep(poll_interval)
+        results: List[Any] = []
+        cursor: Optional[str] = None
+        last: Dict[str, Any] = {}
+        while True:
+            q = f"limit={page_size}" + (f"&cursor={urllib.parse.quote(cursor, safe='')}" if cursor else "")
+            last = self._request("GET", f"{path}?{q}", None, t, None)
+            results.extend(last["results"])
+            cursor = last.get("next_cursor")
+            if not cursor:
+                break
+        last["results"] = results
+        last.pop("next_cursor", None)
+        last.pop("next_offset", None)
+        return last  # type: ignore[return-value]

preflight_sdk/errors.py

@@ -0,0 +1,85 @@
+"""Every failure is a ``PreflightError``; the subclasses say why, so callers can branch with ``except`` instead of
+reading status codes. Statuses with no subclass of their own (a refused redirect, 413, 421) are plain
+``PreflightError``."""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class PreflightError(Exception):
+    """`status` is the HTTP status, or None for a network error or timeout. `code` is the server's error code.
+    `retry_after` is the server's Retry-After in seconds (429, 503), when it sent one."""
+
+    def __init__(
+        self,
+        message: str,
+        status: Optional[int] = None,
+        code: Optional[str] = None,
+        body: Any = None,
+        retry_after: Optional[float] = None,
+    ):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.body = body
+        self.retry_after = retry_after
+
+    @property
+    def request_id(self) -> Optional[str]:
+        """The server's id for the failed request (`error.request_id`, also the x-request-id header): quote it to
+        support. None when there was no server response."""
+        err = self.body.get("error") if isinstance(self.body, dict) else None
+        rid = err.get("request_id") if isinstance(err, dict) else None
+        return rid if isinstance(rid, str) else None
+
+
+class InvalidRequestError(PreflightError):
+    """400 or 422: the request is malformed or refused as sent (including a reused Idempotency-Key)."""
+
+
+class AuthenticationError(PreflightError):
+    """401: the API key is missing, wrong or revoked."""
+
+
+class PermissionDeniedError(PreflightError):
+    """403: the key is valid but may not do this (for example a read-only key on a write)."""
+
+
+class NotFoundError(PreflightError):
+    """404: no such resource in this workspace."""
+
+
+class ConflictError(PreflightError):
+    """409: the request conflicts with what is recorded (for example downgrading a placed outcome)."""
+
+
+class RateLimitError(PreflightError):
+    """429: slow down; `retry_after` says for how long."""
+
+
+class ServerError(PreflightError):
+    """5xx: the server failed; safe to retry later with the same Idempotency-Key."""
+
+
+class NetworkError(PreflightError):
+    """No HTTP response: DNS, connection refused or reset, TLS."""
+
+
+class RequestTimeoutError(PreflightError):
+    """No complete response within the per-attempt timeout."""
+
+
+def error_for_status(
+    status: int, message: str, code: Optional[str] = None, body: Any = None, retry_after: Optional[float] = None
+) -> PreflightError:
+    """The subclass for an HTTP status."""
+    cls = {
+        400: InvalidRequestError,
+        401: AuthenticationError,
+        403: PermissionDeniedError,
+        404: NotFoundError,
+        409: ConflictError,
+        422: InvalidRequestError,
+        429: RateLimitError,
+    }.get(status, ServerError if status >= 500 else PreflightError)
+    return cls(message, status, code, body, retry_after)

preflight_sdk/types.py

@@ -0,0 +1,209 @@
+"""Request and response types. Field names match the API's JSON (snake_case), so dicts pass straight through."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional, TypedDict, Union
+
+Channel = Literal["voice", "sms"]
+Purpose = Literal["marketing", "informational", "emergency"]
+Method = Literal["ai_voice", "prerecorded", "autodialed", "manual", "ai_text", "ai_agent", "ai_prerecorded"]
+ConsentKind = Literal["express_written", "express", "ebr_purchase", "ebr_inquiry"]
+Verdict = Literal["allow", "defer", "block"]
+Outcome = Literal["placed", "not_placed", "failed"]
+
+
+class _CheckRequired(TypedDict):
+    to: str
+    channel: Channel
+    purpose: Purpose
+
+
+class CheckRequest(_CheckRequired, total=False):
+    method: Method
+    seller: str
+    subject: str
+    recipient_state: str
+    at: str  # ISO 8601; what-if time, only with commit=False (committed: within 5 min of server time)
+    commit: bool  # batch items must leave it false or unset
+    line_type: Literal["wireless", "residential", "unknown"]  # only "residential" changes a verdict; a workspace with caller_attributes.tax_exempt_nonprofit true gets the 3-in-30 limit for any non-emergency purpose
+    existing_debt_or_contract: bool  # contact is primarily about an existing, uncompleted debt or contract; lifts Florida's do-not-call list only (Fla. Stat. 501.059(1)(k)2)
+    existing_customer: bool  # person called is an NJ "existing customer" (open payment obligation on merchandise, or a written contract with performance outstanding); lifts only the NJ mobile sales-call ban (N.J.A.C. 13:45D-1.3)
+    health_care_message: bool  # HIPAA health-care message to a residential line; needs caller_attributes.hipaa_covered_entity
+    message_text: str  # exact SMS text (max 2000 chars); with free_to_end_user the 160-character limit and STOP wording are checked
+    free_to_end_user: dict  # {"category": "package"|"inmate"|"financial"|"healthcare", "event_id", "conditions": [...], "signature_required"}; 47 CFR 64.1200(a)(9), needs the workspace's caller_attributes.free_to_end_user_<category> and a current free_to_end_user_attestations entry; the conditions are your representation, not verified
+
+
+# Every code a reason can carry (README "Reason codes"). New codes may appear: keep a default branch.
+ReasonCode = Literal[
+    "opted_out",
+    "consent_missing",
+    "national_dnc",
+    "state_dnc",
+    "state_ban",
+    "state_volume_cap",
+    "state_registration_missing",
+    "known_litigator",
+    "suppressed",
+    "dnc_list_missing",
+    "dnc_list_stale",
+    "dnc_list_not_covering",
+    "state_dnc_list_missing",
+    "litigator_list_missing",
+    "litigator_list_stale",
+    "unknown_area_code",
+    "non_geographic_number",
+    "unsupported_jurisdiction",
+    "emergency_disabled",
+    "emergency_subject_not_allowed",
+    "emergency_rule",
+    "no_allowed_time",
+    "outside_federal_window",
+    "outside_state_window",
+    "window_closing",
+    "state_holiday",
+    "state_no_calls_today",
+    "frequency_cap",
+    "rnd_unavailable",
+    "preflight_unavailable",
+]
+
+
+class Reason(TypedDict, total=False):
+    code: str  # a ReasonCode today; typed as str so a code added to the server later still type-checks
+    message: str
+    rule: str
+    source: str
+    verified: bool
+    status: int  # only on the SDK's own preflight_unavailable reason, when the server answered with a 4xx
+    idempotency_key: str  # only on the SDK's own preflight_unavailable reason: the key the check was sent under; see release_unplaced()
+
+
+class Obligation(TypedDict, total=False):
+    code: str
+    message: str
+    source: str
+    state: str
+    required: bool
+    trigger: str
+    timing: str
+    text: str
+    conditions: str
+    verified: bool
+
+
+class SourceText(TypedDict):
+    url: str
+    sha256: str
+    fetched_at: str
+
+
+class RulesReview(TypedDict):
+    reviewed_by: str
+    reviewed_on: str
+    scope: str
+
+
+class Decision(TypedDict, total=False):
+    decision: Verdict
+    reasons: List[Reason]
+    next_allowed_at: str
+    obligations: List[Obligation]
+    jurisdiction: Dict[str, Any]
+    warnings: List[str]
+    consent_ids: List[str]
+    check_id: str
+    committed: bool
+    evaluated_at: str
+    reference_snapshot: Optional[Dict[str, Any]]
+    rules_version: str
+    rules_in_force: List[str]
+    source_texts: List[SourceText]
+    rules_review: RulesReview
+
+
+class _ConsentRequired(TypedDict):
+    phone: str
+    kind: ConsentKind
+    source: str
+
+
+class ConsentRequest(_ConsentRequired, total=False):
+    seller: str
+    channels: List[Channel]
+    purposes: List[Purpose]
+    obtained_at: str
+    wording: str  # required for express_written: the exact wording shown to the person
+    ip: str
+    user_agent: str
+    evidence: Any
+
+
+class _OptOutRequired(TypedDict):
+    phone: str
+
+
+class OptOutRequest(_OptOutRequired, total=False):
+    channel: Channel  # omit to opt out on every channel
+    source: str
+    raw: str
+    received_at: str
+
+
+# A batch item the server could not evaluate is {"error": {"code", "message"}}: treat it as do-not-dial.
+BatchResult = Union[Decision, Dict[str, Any]]
+
+
+class BatchJob(TypedDict):
+    job_id: str
+    status: str
+    total: int
+    processed: int
+    counts: Dict[str, int]
+    results: List[BatchResult]  # in item order
+
+
+# The server's JSON is passed through as-is.
+Evidence = Dict[str, Any]
+
+
+class OutcomeReceipt(TypedDict):
+    check_id: str
+    outcome: Outcome
+    outcome_at: str
+    provider_ref: Optional[str]
+    counts_as_attempt: bool  # True only for "placed"
+    changed: bool  # False when the same outcome was already recorded
+
+
+ListKind = Literal["national_dnc", "state_dnc", "litigator", "reassigned", "custom"]
+
+
+class _NewListRequired(TypedDict):
+    kind: ListKind
+    name: str
+
+
+class NewList(_NewListRequired, total=False):
+    state: str  # two-letter state, required for state_dnc
+    source: str
+    area_codes: List[str]
+
+
+class ImportOptions(TypedDict, total=False):
+    """Query options of POST /v1/lists/{id}/entries; see the README's import table."""
+
+    mode: Literal["merge", "replace"]
+    delimiter: Literal["comma", "tab", "pipe", "semicolon"]
+    header: bool
+    phone_col: str
+    area_code_col: str
+    registered_col: str
+    disconnected_col: str
+    edition_date: str  # YYYY-MM-DD
+    source: str
+    area_codes: str  # comma-separated, e.g. "303,720"
+    force: bool
+
+
+class EvidencePdf(TypedDict):
+    pdf: bytes
+    bundle_sha256: Optional[str]  # from the X-Preflight-Evidence-Sha256 header

preflight_sdk/webhooks.py

@@ -0,0 +1,78 @@
+"""Verifies the ``preflight-signature`` header on webhook deliveries (#280).
+
+Scheme (src/webhooks.rs ``sign``)::
+
+    preflight-signature: t=<unix seconds>,v1=<hex(HMAC-SHA256(secret, "<t>.<raw body>"))>
+
+The key is the endpoint secret exactly as returned by ``create_webhook`` (including ``whsec_``), as UTF-8 bytes.
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import math
+import re
+import time
+from typing import Optional, Union
+
+_HEX64 = re.compile(r"[0-9a-f]{64}")
+_DIGITS = re.compile(r"[0-9]{1,15}")
+
+
+def verify_webhook(
+    raw_body: Union[bytes, bytearray, memoryview, str],
+    header: Optional[str],
+    secret: str,
+    tolerance: float = 300,
+    now: Optional[float] = None,
+) -> bool:
+    """True only when ``header`` carries a ``v1`` signature of ``raw_body`` under ``secret`` and its ``t`` is within
+    ``tolerance`` seconds of ``now`` (default ``time.time()``) in either direction.
+
+    Every other case returns False (fail closed): missing or malformed header, non-numeric, stale or future
+    timestamp, wrong signature. Pass the body exactly as received (``request.get_data()``, ``await request.body()``)
+    or its undecoded text; a parsed dict does not match and raises ``TypeError``, as do an empty secret and a bad
+    tolerance, because those are programming errors. Any one matching ``v1`` value is accepted.
+    """
+    if isinstance(raw_body, str):
+        body = raw_body.encode("utf-8")
+    elif isinstance(raw_body, (bytes, bytearray, memoryview)):
+        body = bytes(raw_body)
+    else:
+        raise TypeError("verify_webhook needs the raw request body (bytes or text), not a parsed object")
+    if not isinstance(secret, str) or not secret:
+        raise TypeError("verify_webhook needs the endpoint secret")
+    if isinstance(tolerance, bool) or not isinstance(tolerance, (int, float)) or not (0 <= tolerance < math.inf):
+        raise TypeError("tolerance must be a non-negative number")
+    if not isinstance(header, str):
+        return False
+    current = time.time() if now is None else now
+    if not isinstance(current, (int, float)) or not math.isfinite(current):
+        return False
+
+    t: Optional[str] = None
+    sigs = []
+    for part in header.split(","):
+        key, eq, value = part.partition("=")
+        if not eq:
+            return False
+        key, value = key.strip(), value.strip()
+        if key == "t":
+            if t is not None:  # two timestamps: ambiguous, refuse
+                return False
+            t = value
+        elif key == "v1":
+            sigs.append(value)
+        # other schemes are ignored
+    if t is None or not _DIGITS.fullmatch(t) or not sigs:
+        return False
+    if abs(current - int(t)) > tolerance:
+        return False
+
+    expected = hmac.new(secret.encode("utf-8"), t.encode("ascii") + b"." + body, hashlib.sha256).hexdigest()
+    ok = False
+    for sig in sigs:
+        # Compare every candidate (no early exit); compare_digest is constant time for equal-length inputs.
+        if _HEX64.fullmatch(sig) and hmac.compare_digest(sig.encode("ascii"), expected.encode("ascii")):
+            ok = True
+    return ok

preflight_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: preflight-sdk
+Version: 1.0.0
+Summary: Thin fail-closed client for the Preflight pre-dial API. Standard library only.
+License-Expression: MIT
+Project-URL: Homepage, https://www.preflightapi.com/docs/
+Project-URL: Documentation, https://www.preflightapi.com/docs/
+Project-URL: Support, https://www.preflightapi.com/support.html
+Project-URL: Source, https://github.com/palfi-andras/preflight
+Keywords: preflight,tcpa,dnc,opt-out,consent,voice,sms
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Communications :: Telephony
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Preflight Python SDK
+
+A thin client for the Preflight pre-dial API. Standard library only (Python 3.9+), no dependencies. Typed (`py.typed`).
+
+```sh
+pip install preflight-sdk
+```
+
+Preflight applies encoded rules and keeps evidence. This SDK does not make anyone compliant and does not replace
+counsel.
+
+```python
+from preflight_sdk import Preflight
+
+pf = Preflight("https://api.preflightapi.com", os.environ["PREFLIGHT_KEY"])
+
+d = pf.check({"to": "(702) 555-0142", "channel": "voice", "purpose": "marketing", "method": "ai_voice"})
+if d["decision"] == "allow":
+    place_call()                                  # d["obligations"] belong in your opening script
+elif d["decision"] == "defer":
+    reschedule(d["next_allowed_at"])
+else:
+    drop_lead(d["reasons"])                       # includes "preflight_unavailable"
+
+pf.record_opt_out({"phone": "+12065550142", "channel": "voice", "source": "in_call", "raw": "stop calling me"})
+pf.record_consent({"phone": "+17025550142", "kind": "express_written", "source": "https://acme.example/quote", "wording": "..."})
+job = pf.batch(items)                              # polls until done; job["results"] is in item order
+pf.report_outcome(check_id, "placed", "CA123")           # after the call or text ends: placed | not_placed | failed
+ev = pf.get_evidence("+17025550142")
+```
+
+Account and data calls, each one request to the endpoint of the same name in the [API reference](https://www.preflightapi.com/docs/api.html):
+
+```python
+pf.revoke_consent(consent_id, "asked to stop")
+pf.get_consent_capture(capture_id)                     # consent widget certificate
+pf.claim_consent_capture(capture_id, "+17025550142")   # 409 unless it is the capture's phone
+lst = pf.create_list({"kind": "litigator", "name": "Vendor feed"})
+pf.import_list_entries(lst["id"], file_text, options={"mode": "replace", "edition_date": "2026-10-01"}, timeout=120)
+pf.list_lists()
+pf.get_check_evidence(check_id)
+r = pf.get_check_evidence_pdf(check_id)                # {"pdf": bytes, "bundle_sha256": ...}
+pf.get_rule_changes("2026-10-14.3")                    # or a date, or None for all
+pf.get_rule_impact(limit=1000)                         # follow next_cursor with cursor=
+hook = pf.create_webhook("https://acme.example/preflight", ["opt_out.created"])  # secret shown once
+pf.list_webhooks()
+pf.delete_webhook(hook["id"])
+```
+
+## Verifying webhooks
+
+```python
+from preflight_sdk import verify_webhook
+
+# raw body exactly as received: request.get_data() (Flask), await request.body() (Starlette), never a parsed dict
+if not verify_webhook(request.get_data(), request.headers.get("preflight-signature"), os.environ["PREFLIGHT_WEBHOOK_SECRET"]):
+    abort(400)
+```
+
+Returns `True` only when a `v1` value in `preflight-signature` is the HMAC-SHA256 of `<t>.<raw body>` under the
+endpoint secret (the whole `whsec_...` string from `create_webhook`) and `t` is within `tolerance` seconds (default
+300) of now in either direction. Anything else (missing or malformed header, non-numeric, stale or future `t`, wrong
+signature) returns `False`; it never raises for bad input from the network. It raises `TypeError` for programming
+errors: a body that is not bytes or str (for example a parsed dict), an empty secret, a negative tolerance. The
+compare is constant time (`hmac.compare_digest`), and any matching `v1` is accepted (for secret rotation).
+`verify_webhook(raw_body, header, secret, tolerance=300, now=None)`; `now` is Unix seconds, for tests.
+Receiver guide: [Webhooks guide](https://www.preflightapi.com/docs/).
+
+## Fail-closed behaviour
+
+- `check()` defaults to a **300 ms** timeout per attempt. On a timeout, a network error, a 429, a 5xx (after one
+  quick retry) or any 4xx it **returns** `{"decision": "block", "reasons": [{"code": "preflight_unavailable", ...}]}` instead of
+  raising. Treat it like any other `block`: do not dial or text. A 4xx also carries its HTTP `status` in the reason.
+- A timeout can leave a check the server already recorded as an allowed attempt that you never dialed; it keeps
+  counting toward the frequency and volume caps. The block's reason carries the `idempotency_key` the check was sent
+  under. Call `pf.release_unplaced(req, d)` (same request, the block decision) within 5 minutes: it replays the key and,
+  if the stored check was an allow, reports `not_placed`. Over-counting is the safe direction, so skipping this only
+  costs reachable leads. Never use it for a call you placed.
+- There is no fail-open option. The only alternative is `throw_on_error=True` (on the client or per call), which
+  raises `PreflightError` (with `status`, `code`, `body`, `retry_after`) so you can handle the failure yourself. Even then, no
+  answer means do not dial.
+- Retries: a network error, timeout, 429 or 5xx is retried; any other status is not. `check()` gets one quick retry
+  (`check_max_retries`, default 1) and never sleeps longer than its timeout, so a `Retry-After` longer than that ends
+  it at once with the block decision: worst case about two timeouts. Every other call gets `max_retries` (default 2)
+  with jittered exponential backoff (`retry_base_delay`, default 0.2 s) or the server's `Retry-After` when it sends
+  one, up to `max_retry_delay` (default 10 s); a longer `Retry-After` raises `RateLimitError` (or `ServerError` for
+  a 503) with `retry_after` so you can schedule the retry.
+- A retry never records a write twice: every attempt of a POST sends the **same** `Idempotency-Key`, and the server
+  replays a key it has already answered instead of running the request again. The key is a UUID generated
+  per call; when you retry a failed `record_opt_out` (or any write) yourself, pass `idempotency_key=` (your inbound
+  message id, or `new_idempotency_key()` kept for the job) so your retries are replays too. The server keeps keys
+  for 24 hours: a retry later than that runs again (for an opt-out, a second opt-out event: it still blocks, but the
+  audit trail shows it twice).
+- Every method other than `check()` always raises `PreflightError` on failure (default timeout 10 s): swallowing a
+  failed opt-out or revocation would be unsafe, so retry it until it succeeds.
+- `import_list_entries` and `create_list` retry like any write; a replayed import returns the first import's counts
+  and does not apply the file again.
+- `create_webhook` retries like any write; a replay returns the same signing secret, so a retry never makes a second
+  endpoint.
+- `batch()` is screening only (items must not set `commit`). It raises if the job fails or polling exceeds
+  `max_wait`; an item the server could not evaluate comes back as `{"error": {...}}`: treat it as do-not-dial.
+
+The per-attempt timeout is a total deadline (not per socket read), covering an error response's body too, so a server that drips bytes cannot outlast it. The SDK never follows redirects (a 30x fails closed without a retry and the API key is never sent elsewhere), and `check()` rejects a response whose `reasons` is not a list.
+
+## Errors
+
+Every failure is a `PreflightError`; the subclass says why: `InvalidRequestError` (400, 422), `AuthenticationError`
+(401), `PermissionDeniedError` (403), `NotFoundError` (404), `ConflictError` (409), `RateLimitError` (429),
+`ServerError` (5xx), `NetworkError` (no response) and `RequestTimeoutError`. Other statuses (a refused redirect, 413,
+421) are a plain `PreflightError`.
+
+```python
+from preflight_sdk import AuthenticationError, PreflightError
+
+try:
+    pf.record_opt_out(opt_out, idempotency_key=inbound_message_id)
+except AuthenticationError:
+    alert_ops("Preflight key rejected")
+except PreflightError as e:
+    requeue(opt_out, delay=e.retry_after)  # keep the same key on the next try
+```
+
+Requests send `User-Agent: preflight-sdk-python/<SDK_VERSION>`. `SDK_VERSION` and `API_VERSION` (the `/v1` API this
+SDK speaks) are exported.
+
+Request and response types (`TypedDict`) are in `preflight_sdk.types`.
+

preflight_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+preflight_sdk/__init__.py,sha256=DKTC5Wl_tIb3O4rTH8DB-v7acSWtvypWROMYOf2uQTM,1336
+preflight_sdk/_version.py,sha256=_PY6d1b1O7YeLRCErRzOn60IKqRXzy14pEJAhflkK2I,225
+preflight_sdk/client.py,sha256=K_sht-trve5DkFd0TJzD_gm6dak00nviBm7Z9Mx_53c,25079
+preflight_sdk/errors.py,sha256=EK7vNchh5C-d775xGDk2O9iyC5XvCr8RUnRCrgBoeb8,2957
+preflight_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+preflight_sdk/types.py,sha256=sgnmCZoArAATPjd4IaCQey6yxiWKjY7hqe_XZuTl4F4,6511
+preflight_sdk/webhooks.py,sha256=Zps2I10rS6VpgZPOHmPYx-FZ7FEfPxHvsGzjPiHwipo,3142
+preflight_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=P6ChiR3AXZTZj_O0VVHfZpD_s66vqdh-je564oqI1A4,1074
+preflight_sdk-1.0.0.dist-info/METADATA,sha256=n_VrWbWgegdELCHDLXxcRai0tyqWjY0rcE8rIDjS6-M,8770
+preflight_sdk-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+preflight_sdk-1.0.0.dist-info/top_level.txt,sha256=iQplzLkBdOzJn85UlQoMvWYs-7T9m8r2OAHWWgt_s68,14
+preflight_sdk-1.0.0.dist-info/RECORD,,

preflight_sdk-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

preflight_sdk-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IBUR Ventures LLC
+
+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.

preflight_sdk-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+preflight_sdk