smoke-sdk 0.1.0__py3-none-any.whl

smoke_sdk/__init__.py

@@ -0,0 +1,6 @@
+"""Smoke SDK for Python: the public API v1 client and webhook signature verification."""
+
+from .client import SmokeApiError, SmokeClient, __version__
+from .webhooks import verify_webhook_signature
+
+__all__ = ["SmokeApiError", "SmokeClient", "verify_webhook_signature", "__version__"]

smoke_sdk/client.py

@@ -0,0 +1,267 @@
+"""Client of the Smoke public API v1 (standard library only)."""
+
+from __future__ import annotations
+
+import json
+import random
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Tuple, Union, cast
+
+from .types import (
+    Asset,
+    AssetPage,
+    ClientPage,
+    FindingDetail,
+    FindingPage,
+    MemberPage,
+    Project,
+    ProjectPage,
+    Snapshot,
+    Workspace,
+)
+
+__version__ = "0.1.0"
+RETRYABLE = {408, 429, 500, 502, 503, 504}
+Content = Union[bytes, str]
+
+
+class SmokeApiError(Exception):
+    """An error answer of the API. ``code`` is stable (see the API guide)."""
+
+    def __init__(
+        self,
+        status: int,
+        code: str,
+        message: str,
+        details: Optional[List[Any]] = None,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(f"{code}: {message}")
+        self.status = status
+        self.code = code
+        self.message = message
+        self.details = details or []
+        #: ``X-Smoke-Request-Id``: include it when reporting a problem.
+        self.request_id = request_id
+
+
+class SmokeClient:
+    """Smoke public API v1.
+
+    ``token`` is an integration or personal token (``smk_…``); ``base_url`` is
+    ``https://api.<your Smoke domain>/v1``. 429, 5xx and network errors are retried with backoff
+    (honouring ``Retry-After``); uploads send the same ``Idempotency-Key`` on every attempt.
+    """
+
+    def __init__(
+        self,
+        token: str,
+        base_url: str,
+        max_retries: int = 3,
+        timeout: float = 30.0,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        if not token:
+            raise ValueError("token is required")
+        self._token = token
+        self._base = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._timeout = timeout
+        self._sleep = sleep
+
+    # ---- resources ------------------------------------------------------------------------
+
+    def workspace(self) -> Workspace:
+        return cast(Workspace, self._request("GET", "/workspace"))
+
+    def list_clients(self, cursor: Optional[str] = None, limit: Optional[int] = None) -> ClientPage:
+        return cast(ClientPage, self._request("GET", "/clients", {"cursor": cursor, "limit": limit}))
+
+    def list_projects(
+        self, client_id: Optional[str] = None, cursor: Optional[str] = None, limit: Optional[int] = None
+    ) -> ProjectPage:
+        q = {"clientId": client_id, "cursor": cursor, "limit": limit}
+        return cast(ProjectPage, self._request("GET", "/projects", q))
+
+    def get_project(self, project_id: str) -> Project:
+        return cast(Project, self._request("GET", f"/projects/{_q(project_id)}"))
+
+    def list_assets(
+        self, project_id: Optional[str] = None, cursor: Optional[str] = None, limit: Optional[int] = None
+    ) -> AssetPage:
+        q = {"projectId": project_id, "cursor": cursor, "limit": limit}
+        return cast(AssetPage, self._request("GET", "/assets", q))
+
+    def get_asset(self, asset_id: str) -> Asset:
+        return cast(Asset, self._request("GET", f"/assets/{_q(asset_id)}"))
+
+    def upload_inventory(
+        self,
+        asset_id: str,
+        files: Sequence[Tuple[str, Content]],
+        release: Optional[str] = None,
+        commit: Optional[str] = None,
+        environment: Optional[str] = None,
+        pipeline_url: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Snapshot:
+        """Uploads the asset's complete inventory: ``files`` are ``(path, content)`` pairs (every
+        lockfile, or one SBOM). Then ``wait_for_match(result["id"])``."""
+        fields = {"release": release, "commit": commit, "environment": environment, "pipelineUrl": pipeline_url}
+        body, ctype = _multipart(files, {k: v for k, v in fields.items() if v})
+        return cast(
+            Snapshot,
+            self._request(
+                "POST",
+                f"/assets/{_q(asset_id)}/inventory",
+                body=body,
+                content_type=ctype,
+                idempotency_key=idempotency_key or str(uuid.uuid4()),
+            ),
+        )
+
+    def get_snapshot(self, snapshot_id: str) -> Snapshot:
+        return cast(Snapshot, self._request("GET", f"/snapshots/{_q(snapshot_id)}"))
+
+    def wait_for_match(self, snapshot_id: str, timeout: float = 300.0, interval: float = 5.0) -> Snapshot:
+        """Polls until matching finished (``matched``, ``failed`` or ``superseded``)."""
+        deadline = time.monotonic() + timeout
+        while True:
+            s = self.get_snapshot(snapshot_id)
+            if s["match"]["status"] != "pending":
+                return s
+            if time.monotonic() > deadline:
+                raise TimeoutError(f"snapshot {snapshot_id} not matched in time")
+            self._sleep(interval)
+
+    def list_members(self, cursor: Optional[str] = None, limit: Optional[int] = None) -> MemberPage:
+        return cast(MemberPage, self._request("GET", "/members", {"cursor": cursor, "limit": limit}))
+
+    def list_findings(self, cursor: Optional[str] = None, **filters: Any) -> FindingPage:
+        """Filters: ``projectId``, ``assetId``, ``clientId``, ``priority`` (``"P1,P2"``),
+        ``status`` (comma-separated or ``"all"``), ``assigneeId``, ``contextLevel``
+        (``"act_now,schedule"``; also ``needs_context``, ``unrated``), ``updatedSince``, ``limit``."""
+        return cast(FindingPage, self._request("GET", "/findings", {**filters, "cursor": cursor}))
+
+    def iter_findings(self, **filters: Any) -> Iterator[Dict[str, Any]]:
+        """Every finding matching the filters, page by page."""
+        cursor: Optional[str] = None
+        while True:
+            page = self.list_findings(cursor=cursor, **filters)
+            yield from cast(List[Dict[str, Any]], page["items"])
+            cursor = page["nextCursor"]
+            if not cursor:
+                return
+
+    def get_finding(self, finding_id: str) -> FindingDetail:
+        return cast(FindingDetail, self._request("GET", f"/findings/{_q(finding_id)}"))
+
+    def update_finding(self, finding_id: str, **patch: Any) -> FindingDetail:
+        """``status``, ``reason``, ``note``, ``expiresAt``, ``until``, ``assigneeId`` (a member's
+        user id, or None to unassign)."""
+        return cast(
+            FindingDetail,
+            self._request("PATCH", f"/findings/{_q(finding_id)}", json_body=patch),
+        )
+
+    # ---- transport ------------------------------------------------------------------------
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        query: Optional[Dict[str, Any]] = None,
+        json_body: Any = None,
+        body: Optional[bytes] = None,
+        content_type: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        url = self._base + path
+        params = {k: str(v) for k, v in (query or {}).items() if v is not None and v != ""}
+        if params:
+            url += "?" + urllib.parse.urlencode(params)
+        headers = {
+            "Authorization": f"Bearer {self._token}",
+            "Accept": "application/json",
+            "User-Agent": f"smoke-sdk-python/{__version__}",
+        }
+        data = body
+        if json_body is not None:
+            data = json.dumps(json_body).encode()
+            headers["Content-Type"] = "application/json"
+        elif content_type:
+            headers["Content-Type"] = content_type
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        attempt = 0
+        while True:
+            req = urllib.request.Request(url, data=data, method=method, headers=headers)
+            try:
+                with urllib.request.urlopen(req, timeout=self._timeout) as res:
+                    return json.loads(res.read() or b"{}")
+            except urllib.error.HTTPError as e:
+                raw = e.read()
+                if e.code in RETRYABLE and attempt < self._max_retries:
+                    self._sleep(_retry_after(e.headers.get("Retry-After")) or _backoff(attempt))
+                    attempt += 1
+                    continue
+                try:
+                    err = json.loads(raw or b"{}").get("error", {})
+                except ValueError:
+                    err = {}
+                raise SmokeApiError(
+                    e.code,
+                    err.get("code") or f"HTTP_{e.code}",
+                    err.get("message") or str(e.reason),
+                    err.get("details"),
+                    e.headers.get("X-Smoke-Request-Id"),
+                ) from None
+            except (urllib.error.URLError, TimeoutError, ConnectionError):
+                if attempt >= self._max_retries:
+                    raise
+                self._sleep(_backoff(attempt))
+                attempt += 1
+
+
+def _q(v: str) -> str:
+    return urllib.parse.quote(v, safe="")
+
+
+def _retry_after(v: Optional[str]) -> Optional[float]:
+    try:
+        n = float(v) if v else 0
+    except ValueError:
+        return None
+    return n if n > 0 else None
+
+
+def _backoff(attempt: int) -> float:
+    return min(30.0, 0.5 * 2**attempt) * (0.5 + random.random() / 2)
+
+
+def _multipart(files: Sequence[Tuple[str, Content]], fields: Dict[str, str]) -> Tuple[bytes, str]:
+    boundary = "smoke-" + uuid.uuid4().hex
+    out = bytearray()
+
+    def part(headers: str, content: bytes) -> None:
+        out.extend(f"--{boundary}\r\n{headers}\r\n\r\n".encode())
+        out.extend(content)
+        out.extend(b"\r\n")
+
+    for path, content in files:
+        name = path.rsplit("/", 1)[-1].replace('"', "")
+        data = content.encode() if isinstance(content, str) else content
+        part(
+            f'Content-Disposition: form-data; name="files"; filename="{name}"\r\n'
+            "Content-Type: application/octet-stream",
+            data,
+        )
+        part('Content-Disposition: form-data; name="paths"', path.encode())
+    for k, v in fields.items():
+        part(f'Content-Disposition: form-data; name="{k}"', v.encode())
+    out.extend(f"--{boundary}--\r\n".encode())
+    return bytes(out), f"multipart/form-data; boundary={boundary}"

smoke_sdk/types.py

@@ -0,0 +1,324 @@
+"""Response types of the Smoke public API v1. Generated by tools/generate_types.py from
+openapi.json: do not edit by hand. Within v1 fields are only added, never removed."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Optional, TypedDict
+
+class WorkspacePlan(TypedDict):
+    code: str
+    tier: Literal["free", "pro", "agency", "enterprise"]
+
+
+class Workspace(TypedDict):
+    id: str
+    name: str
+    timeZone: str
+    plan: WorkspacePlan
+
+
+class ClientPageItemsItem(TypedDict):
+    id: str
+    name: str
+    archived: bool
+    createdAt: str
+
+
+class ClientPage(TypedDict):
+    items: list[ClientPageItemsItem]
+    nextCursor: Optional[str]
+
+
+class ProjectPageItemsItemClient(TypedDict):
+    id: str
+    name: str
+
+
+class ProjectPageItemsItem(TypedDict):
+    id: str
+    name: str
+    client: Optional[ProjectPageItemsItemClient]
+    environment: Literal["production", "staging", "development"]
+    archived: bool
+    createdAt: str
+
+
+class ProjectPage(TypedDict):
+    items: list[ProjectPageItemsItem]
+    nextCursor: Optional[str]
+
+
+class ProjectClient(TypedDict):
+    id: str
+    name: str
+
+
+class Project(TypedDict):
+    id: str
+    name: str
+    client: Optional[ProjectClient]
+    environment: Literal["production", "staging", "development"]
+    archived: bool
+    createdAt: str
+
+
+class AssetPageItemsItemProject(TypedDict):
+    id: str
+    name: str
+
+
+class AssetPageItemsItem(TypedDict):
+    id: str
+    name: str
+    kind: Literal["repository", "manifest_upload", "host", "container_image", "database"]
+    project: AssetPageItemsItemProject
+    archived: bool
+    inventoryUpdatedAt: Optional[str]
+    staleAt: Optional[str]
+    url: str
+    createdAt: str
+
+
+class AssetPage(TypedDict):
+    items: list[AssetPageItemsItem]
+    nextCursor: Optional[str]
+
+
+class AssetProject(TypedDict):
+    id: str
+    name: str
+
+
+class Asset(TypedDict):
+    id: str
+    name: str
+    kind: Literal["repository", "manifest_upload", "host", "container_image", "database"]
+    project: AssetProject
+    archived: bool
+    inventoryUpdatedAt: Optional[str]
+    staleAt: Optional[str]
+    url: str
+    createdAt: str
+
+
+class SnapshotRelease(TypedDict):
+    version: Optional[str]
+    commit: Optional[str]
+    environment: Optional[str]
+    pipelineUrl: Optional[str]
+
+
+class SnapshotMatch(TypedDict):
+    status: Literal["pending", "matched", "failed", "superseded"]
+    matchedAt: Optional[str]
+
+
+class SnapshotFindingsUnresolved(TypedDict):
+    p1: int
+    p2: int
+    p3: int
+    p4: int
+
+
+class SnapshotFindingsNew(TypedDict):
+    p1: int
+    p2: int
+    p3: int
+    p4: int
+
+
+class SnapshotFindings(TypedDict):
+    unresolved: SnapshotFindingsUnresolved
+    new: SnapshotFindingsNew
+
+
+class Snapshot(TypedDict):
+    id: str
+    assetId: str
+    source: Literal["upload", "mcp", "repository", "collector", "ci", "api"]
+    release: Optional[SnapshotRelease]
+    createdAt: str
+    match: SnapshotMatch
+    findings: Optional[SnapshotFindings]
+
+
+class MemberPageItemsItem(TypedDict):
+    userId: str
+    email: str
+    displayName: Optional[str]
+    role: Literal["owner", "admin", "member"]
+    joinedAt: str
+
+
+class MemberPage(TypedDict):
+    items: list[MemberPageItemsItem]
+    nextCursor: Optional[str]
+
+
+class FindingPageItemsItemProject(TypedDict):
+    id: str
+    name: str
+
+
+class FindingPageItemsItemClient(TypedDict):
+    id: str
+    name: str
+
+
+class FindingPageItemsItemAsset(TypedDict):
+    id: str
+    name: str
+
+
+class FindingPageItemsItemAdvisory(TypedDict):
+    id: str
+
+
+class FindingPageItemsItemContextAssessment(TypedDict):
+    level: Optional[Literal["act_now", "schedule", "track"]]
+    status: Literal["assessed", "needs_context", "unrated", "none"]
+
+
+class FindingPageItemsItem(TypedDict):
+    id: str
+    url: str
+    project: FindingPageItemsItemProject
+    client: Optional[FindingPageItemsItemClient]
+    asset: FindingPageItemsItemAsset
+    ecosystem: str
+    package: str
+    version: str
+    status: Literal["open", "in_progress", "pending_verification", "fixed", "mitigated", "ignored", "snoozed", "closed"]
+    statusChangedAt: str
+    priority: Literal["P1", "P2", "P3", "P4"]
+    priorityRule: str
+    severity: str
+    kev: bool
+    epss: Optional[float]
+    fixState: Literal["available", "partial", "blocked", "none", "unknown"]
+    advisory: Optional[FindingPageItemsItemAdvisory]
+    advisoryCount: int
+    assigneeUserId: Optional[str]
+    slaDueAt: str
+    slaState: Optional[Literal["on_track", "due_soon", "overdue", "met"]]
+    firstSeenAt: str
+    firstSeenRelease: Optional[str]
+    fixedAt: Optional[str]
+    fixedRelease: Optional[str]
+    needsCheck: bool
+    contextAssessment: Optional[FindingPageItemsItemContextAssessment]
+    updatedAt: str
+
+
+class FindingPage(TypedDict):
+    items: list[FindingPageItemsItem]
+    nextCursor: Optional[str]
+
+
+class FindingDetailProject(TypedDict):
+    id: str
+    name: str
+
+
+class FindingDetailClient(TypedDict):
+    id: str
+    name: str
+
+
+class FindingDetailAsset(TypedDict):
+    id: str
+    name: str
+
+
+class FindingDetailAdvisory(TypedDict):
+    id: str
+
+
+class FindingDetailContextAssessmentDecisive(TypedDict):
+    advisoryId: str
+    exploitation: Literal["active", "likely", "none"]
+    exploitationSource: Optional[Literal["kev", "manual", "epss"]]
+    attackPath: Optional[Literal["network", "network_interaction", "adjacent", "local"]]
+    reachable: Optional[bool]
+    rule: Literal["matrix", "distro_unimportant", "kernel_not_running"]
+
+
+class FindingDetailContextAssessmentCounts(TypedDict):
+    act_now: int
+    schedule: int
+    track: int
+    unrated: int
+    needs_context: int
+
+
+class FindingDetailContextAssessment(TypedDict):
+    level: Optional[Literal["act_now", "schedule", "track"]]
+    status: Literal["assessed", "needs_context", "unrated", "none"]
+    decisive: Optional[FindingDetailContextAssessmentDecisive]
+    counts: FindingDetailContextAssessmentCounts
+    missingQuestions: list[Literal["reach", "input"]]
+
+
+class FindingDetailAdvisoriesItemSeverity(TypedDict):
+    level: str
+    score: Optional[float]
+    vector: Optional[str]
+
+
+FindingDetailAdvisoriesItemPrerequisiteExplanation = TypedDict(
+    "FindingDetailAdvisoriesItemPrerequisiteExplanation",
+    {
+        "en": str,
+        "zh-TW": str,
+    },
+)
+
+
+class FindingDetailAdvisoriesItemPrerequisite(TypedDict):
+    explanation: FindingDetailAdvisoriesItemPrerequisiteExplanation
+    sources: list[str]
+
+
+class FindingDetailAdvisoriesItem(TypedDict):
+    id: str
+    aliases: list[str]
+    cveIds: list[str]
+    severity: FindingDetailAdvisoriesItemSeverity
+    kev: bool
+    epss: Optional[float]
+    withdrawn: bool
+    prerequisite: Optional[FindingDetailAdvisoriesItemPrerequisite]
+    decision: Optional[Literal["affected", "not_affected"]]
+
+
+class FindingDetail(TypedDict):
+    id: str
+    url: str
+    project: FindingDetailProject
+    client: Optional[FindingDetailClient]
+    asset: FindingDetailAsset
+    ecosystem: str
+    package: str
+    version: str
+    status: Literal["open", "in_progress", "pending_verification", "fixed", "mitigated", "ignored", "snoozed", "closed"]
+    statusChangedAt: str
+    priority: Literal["P1", "P2", "P3", "P4"]
+    priorityRule: str
+    severity: str
+    kev: bool
+    epss: Optional[float]
+    fixState: Literal["available", "partial", "blocked", "none", "unknown"]
+    advisory: Optional[FindingDetailAdvisory]
+    advisoryCount: int
+    assigneeUserId: Optional[str]
+    slaDueAt: str
+    slaState: Optional[Literal["on_track", "due_soon", "overdue", "met"]]
+    firstSeenAt: str
+    firstSeenRelease: Optional[str]
+    fixedAt: Optional[str]
+    fixedRelease: Optional[str]
+    needsCheck: bool
+    contextAssessment: FindingDetailContextAssessment
+    updatedAt: str
+    advisories: list[FindingDetailAdvisoriesItem]
+    fixVersions: list[str]

smoke_sdk/webhooks.py

@@ -0,0 +1,35 @@
+"""Smoke webhook signature verification (FR-NOT-14)."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import time
+from typing import Optional, Union
+
+
+def verify_webhook_signature(
+    raw_body: Union[bytes, str],
+    header: Optional[str],
+    secret: str,
+    tolerance_seconds: int = 300,
+    now: Optional[float] = None,
+) -> bool:
+    """Checks ``X-Smoke-Signature`` (``t=<unix seconds>,v1=<hex>[,v1=<hex>]``).
+
+    The signature is HMAC-SHA256 with the signing secret over ``<t>.<raw body>``; during a secret
+    rotation there are two ``v1`` values and either may match. ``t`` must be within
+    ``tolerance_seconds`` of now. Pass the raw body exactly as received, before JSON parsing.
+    """
+    if not header:
+        return False
+    parts = [p.strip() for p in header.split(",")]
+    t = next((p[2:] for p in parts if p.startswith("t=")), "")
+    if not t.isdigit():
+        return False
+    current = time.time() if now is None else now
+    if abs(current - int(t)) > tolerance_seconds:
+        return False
+    body = raw_body.encode() if isinstance(raw_body, str) else raw_body
+    expected = hmac.new(secret.encode(), t.encode() + b"." + body, hashlib.sha256).hexdigest()
+    return any(hmac.compare_digest(p[3:], expected) for p in parts if p.startswith("v1="))

smoke_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.5
+Name: smoke-sdk
+Version: 0.1.0
+Summary: Python SDK for the Smoke public API v1 and webhook signatures
+Project-URL: Homepage, https://github.com/Aircraft-IT/smoke-sdk-python
+Project-URL: Source, https://github.com/Aircraft-IT/smoke-sdk-python
+Project-URL: Issues, https://github.com/Aircraft-IT/smoke-sdk-python/issues
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Smoke SDK for Python
+
+Client for the Smoke public API v1 and helper to verify Smoke webhook signatures. Python 3.9 or
+later; standard library only.
+
+```sh
+pip install smoke-sdk
+```
+
+## API
+
+Create an **integration token** (Admins, after turning on *API and webhooks* in the workspace
+settings) or a personal token on the API tokens page. Keep it in a secret store, never in code.
+
+```python
+import os
+from smoke_sdk import SmokeClient
+
+smoke = SmokeClient(os.environ["SMOKE_TOKEN"], "https://api.<your Smoke domain>/v1")
+
+# Every P1 and P2 finding that still needs work, page by page.
+for f in smoke.iter_findings(priority="P1,P2", status="open,in_progress"):
+    print(f["priority"], f["package"], f["version"], f["url"])
+
+# Assign one to a member (user id from smoke.list_members()).
+smoke.update_finding(finding_id, status="in_progress", assigneeId=user_id)
+
+# Upload the inventory at every release, then wait for the result.
+with open("package-lock.json", "rb") as fh:
+    snap = smoke.upload_inventory(
+        asset_id, [("package-lock.json", fh.read())], release="v1.4.2", commit=os.environ["GIT_SHA"]
+    )
+done = smoke.wait_for_match(snap["id"])
+if (done["findings"] or {}).get("unresolved", {}).get("p1", 0) > 0:
+    raise SystemExit(1)
+```
+
+Retries: 429, 5xx and network errors are retried up to 3 times with backoff, honouring
+`Retry-After`; uploads send the same `Idempotency-Key` on every attempt. Errors are raised as
+`SmokeApiError` with `status`, `code` (stable, see the API guide), `details` and `request_id`.
+
+## Webhooks
+
+```python
+from smoke_sdk import verify_webhook_signature
+
+# Flask: request.get_data() is the raw body.
+@app.post("/smoke")
+def smoke_webhook():
+    if not verify_webhook_signature(
+        request.get_data(), request.headers.get("X-Smoke-Signature"), os.environ["SMOKE_WEBHOOK_SECRET"]
+    ):
+        return "", 401
+    event = request.get_json()
+    # Deduplicate by event["id"] (X-Smoke-Event-Id): a resent event keeps its id.
+    return "", 204
+```
+
+## Versions
+
+This SDK follows semver and targets API `v1`, which only changes additively. `smoke_sdk/types.py`
+is generated from `openapi.json` (`python3 tools/generate_types.py`), a copy of the public API
+document (`https://api.<domain>/v1/openapi.json`); a test checks they agree.
+
+## Source and releases
+
+This repository is published at <https://github.com/Aircraft-IT/smoke-sdk-python> when a version
+is released: each release is a tag `v<version>` on `main`, and pushing it runs
+[the publish workflow](.github/workflows/publish.yml), which tests, builds and publishes the
+package to PyPI through trusted publishing, with attestations. On pypi.org each file shows the
+commit and workflow it was built from. Development happens in Smoke's own repository, so `main`
+here moves only at releases.
+
+Issues are welcome. Pull requests are not merged directly; a change we take is made in the
+development repository and appears here with the next release. Contributions are under the
+Apache License 2.0, like the rest of the repository.
+
+## License
+
+Apache-2.0

smoke_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+smoke_sdk/__init__.py,sha256=z1X64BNQAKQ-8LP_Bb_4ELepr9nN8WdQhQUtyNifYKQ,284
+smoke_sdk/client.py,sha256=4159yfPHajOLO6ShCLVKxY_SEbkK9Kw5F3IfK95Oyl8,10189
+smoke_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smoke_sdk/types.py,sha256=pHt2x6wgHKYaHeQVLn7xCsjE7Ogvlcg7mqjBlHyWmCw,7801
+smoke_sdk/webhooks.py,sha256=YyrNVC85W_R0dZNJX4IpRneNPxZ6sSt9PMGG57Z0YNY,1297
+smoke_sdk-0.1.0.dist-info/METADATA,sha256=KcZpMCxNnd3ISC-62HYlCtq5syf-qOSLWw6YW49R7kk,3650
+smoke_sdk-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+smoke_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+smoke_sdk-0.1.0.dist-info/RECORD,,

smoke_sdk-0.1.0.dist-info/WHEEL

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

smoke_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.