pytest-devant-cloud 0.1.0__py3-none-any.whl

pytest_devant_cloud/__init__.py

@@ -0,0 +1,12 @@
+"""pytest plugin that streams runs, results, and step trees to Devant Cloud.
+
+Public API is intentionally tiny — the plugin is registered via the
+`pytest11` entry-point group and configured via env vars or CLI flags. See
+the README for the contract.
+"""
+
+from . import mapping
+from .client import DevqClient
+
+__all__ = ["DevqClient", "mapping"]
+__version__ = "0.1.0"

pytest_devant_cloud/client.py

@@ -0,0 +1,238 @@
+"""HTTP client for Devant Cloud's `/v1/runs/*` endpoints.
+
+Thin wrapper around `httpx` with bearer auth, retry on 5xx/429/network
+errors, and the resolve-test-case fallback chain. The plugin owns the
+lifecycle (createRun → submitResults → completeRun); the client owns the
+wire-level concerns (auth, retries, JSON encoding).
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from .mapping import CIInfo
+
+
+# ── data classes ─────────────────────────────────────────────────────────
+
+
+@dataclass
+class ResolvedCase:
+    """Result of resolveTestCase — matches JS reporter-core's ResolvedCase."""
+
+    id: int
+    key: str
+    minted: bool
+
+
+# ── client ───────────────────────────────────────────────────────────────
+
+
+class DevqClient:
+    """Devant Cloud REST client. One instance per pytest session."""
+
+    def __init__(
+        self,
+        api_url: str,
+        api_token: str,
+        project_id: int,
+        *,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ) -> None:
+        # Strip trailing slash so url joins don't double up.
+        self.api_url = api_url.rstrip("/")
+        self.project_id = project_id
+        self.max_retries = max_retries
+        # Re-use one Connection pool for the whole session — pytest can
+        # easily emit hundreds of POSTs in a fast suite, and TCP setup
+        # cost dwarfs the request itself otherwise.
+        self._http = httpx.Client(
+            headers={
+                "Authorization": f"Bearer {api_token}",
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+            timeout=timeout,
+        )
+
+    # ── lifecycle ────────────────────────────────────────────────────────
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "DevqClient":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    # ── low-level request with retry ─────────────────────────────────────
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: Any | None = None,
+    ) -> httpx.Response:
+        """One request with bounded retry.
+
+        Retries on 5xx, 429, and network errors with exponential backoff
+        (0.25s, 0.5s, 1s). 4xx errors fail fast so callers see schema
+        problems immediately.
+        """
+        url = f"{self.api_url}{path}"
+        last_exc: Exception | None = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = self._http.request(method, url, json=json_body)
+            except httpx.RequestError as exc:
+                last_exc = exc
+                if attempt >= self.max_retries:
+                    raise
+                time.sleep(0.25 * (2 ** attempt))
+                continue
+
+            if resp.status_code >= 500 or resp.status_code == 429:
+                if attempt >= self.max_retries:
+                    resp.raise_for_status()
+                time.sleep(0.25 * (2 ** attempt))
+                continue
+
+            resp.raise_for_status()
+            return resp
+
+        # Should be unreachable — every path above either returns or raises.
+        if last_exc:
+            raise last_exc
+        raise RuntimeError("retry loop exited without response")
+
+    # ── API surface ──────────────────────────────────────────────────────
+
+    def create_run(
+        self,
+        *,
+        name: str,
+        framework: str = "pytest",
+        ci: CIInfo | None = None,
+        mode: str = "automated",
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "project_id": self.project_id,
+            "mode": mode,
+            "name": name,
+            "framework": framework,
+        }
+        if ci:
+            payload["ci"] = ci
+        resp = self._request("POST", "/v1/runs", json_body=payload)
+        return resp.json()
+
+    def resolve_test_case(
+        self,
+        *,
+        explicit_key: str | None,
+        full_name: str,
+    ) -> ResolvedCase:
+        """Mirrors reporter-core/src/resolve.ts.
+
+        Order: explicit @KEY → exact name search → auto-create.
+        """
+        # 1. explicit @KEY.
+        if explicit_key:
+            try:
+                resp = self._http.get(
+                    f"{self.api_url}/v1/test-cases/by-key/{quote(explicit_key)}",
+                    params={"project_id": self.project_id},
+                )
+                if resp.status_code == 200:
+                    body = resp.json()
+                    return ResolvedCase(
+                        id=int(body["id"]),
+                        key=str(body["key"]),
+                        minted=False,
+                    )
+            except httpx.HTTPError:
+                # Fall through to search → mint.
+                pass
+
+        # 2. exact name search.
+        try:
+            resp = self._http.get(
+                f"{self.api_url}/v1/test-cases",
+                params={"project_id": self.project_id, "search": full_name},
+            )
+            if resp.status_code == 200:
+                items = resp.json().get("items", [])
+                for it in items:
+                    if it.get("name") == full_name:
+                        return ResolvedCase(
+                            id=int(it["id"]),
+                            key=str(it["key"]),
+                            minted=False,
+                        )
+        except httpx.HTTPError:
+            pass
+
+        # 3. auto-create.
+        resp = self._request(
+            "POST",
+            "/v1/test-cases",
+            json_body={
+                "project_id": self.project_id,
+                "name": full_name,
+                "is_automated": True,
+            },
+        )
+        body = resp.json()
+        return ResolvedCase(
+            id=int(body["id"]),
+            key=str(body["key"]),
+            minted=True,
+        )
+
+    def submit_results(
+        self,
+        run_id: int,
+        results: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        resp = self._request(
+            "POST",
+            f"/v1/runs/{run_id}/results",
+            json_body={"results": results},
+        )
+        body = resp.json()
+        return body.get("results", [])
+
+    def submit_coverage(
+        self,
+        run_id: int,
+        summary: dict[str, Any],
+    ) -> None:
+        self._request(
+            "POST",
+            f"/v1/runs/{run_id}/coverage",
+            json_body=summary,
+        )
+
+    def complete_run(
+        self,
+        run_id: int,
+        *,
+        status: str = "complete",
+        html_report_url: str | None = None,
+    ) -> None:
+        payload: dict[str, Any] = {"status": status}
+        if html_report_url is not None:
+            payload["html_report_url"] = html_report_url
+        self._request(
+            "POST",
+            f"/v1/runs/{run_id}/complete",
+            json_body=payload,
+        )

pytest_devant_cloud/mapping.py

@@ -0,0 +1,374 @@
+"""Pure functions for translating pytest's runtime data into Devant Cloud's
+wire shapes.
+
+These are kept side-effect-free (no HTTP, no logging) so they can be unit-
+tested without spinning up a server. The plugin module composes them with
+the HTTP client to actually stream events.
+
+Mirrors the JS helpers in `@devant-net/reporter-core` (status mapping, key
+extraction, CI detection) — keep the two in sync if you change either.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Any, Literal, TypedDict
+
+# ── types (mirror packages/reporter-core/src/types.ts) ────────────────────
+
+ResultStatus = Literal["pass", "fail", "blocked", "skipped", "in_progress"]
+StepStatus = Literal["pass", "fail", "blocked", "skipped"]
+
+
+class SubmitStep(TypedDict, total=False):
+    title: str
+    status: StepStatus
+    duration_ms: int
+    category: str | None
+    error_message: str | None
+    children: list["SubmitStep"]
+
+
+class CIInfo(TypedDict, total=False):
+    provider: str
+    branch: str
+    commit_sha: str
+    commit_msg: str
+    author: str
+    pr_number: int
+    pr_url: str
+    repo_url: str
+    ci_link: str
+
+
+# API caps error_message at 8192 chars (see api/src/runs.ts schema). We
+# truncate client-side so an oversized longrepr doesn't 4xx the whole
+# submit-results call.
+_ERROR_MESSAGE_MAX = 8192
+
+
+# ── status normalization ─────────────────────────────────────────────────
+
+
+def map_status(outcome: str) -> ResultStatus:
+    """Pytest TestReport.outcome → Devant Cloud ResultStatus.
+
+    pytest emits a small fixed vocabulary on `TestReport.outcome`:
+      * passed / failed / skipped — normal outcomes
+      * error — setup/teardown error; we treat it as a failure since the
+        case did not pass
+
+    We also accept "xfailed"/"xpassed" as pytest internally sometimes uses
+    these for marked-xfail tests. xfail-that-failed is the *expected*
+    outcome → pass-equivalent. xfail-that-passed is unexpected and
+    surfaces as a fail so dashboards flag it.
+    """
+    table: dict[str, ResultStatus] = {
+        "passed": "pass",
+        "failed": "fail",
+        "error": "fail",
+        "skipped": "skipped",
+        "xfailed": "pass",
+        "xpassed": "fail",
+    }
+    return table.get(outcome, "blocked")
+
+
+def map_step_status(outcome: str) -> StepStatus:
+    """Step-level subset of map_status (no in_progress for steps)."""
+    table: dict[str, StepStatus] = {
+        "passed": "pass",
+        "failed": "fail",
+        "error": "fail",
+        "skipped": "skipped",
+    }
+    return table.get(outcome, "blocked")
+
+
+# ── @KEY extraction ──────────────────────────────────────────────────────
+
+# Same shape as the JS regex in reporter-core/src/resolve.ts:
+#   prefix:  uppercase alpha, then any uppercase alphanumeric
+#   suffix:  uppercase alphanumeric
+# Match against individual tokens after splitting on whitespace.
+_KEY_TOKEN_RE = re.compile(r"^@?([A-Z][A-Z0-9]*-[A-Z0-9]+)$")
+
+
+def extract_key(*candidates: str | None) -> str | None:
+    """Pluck the first `@KEY` style token out of the candidate strings.
+
+    Callers pass anything that might contain a key — marker args, the
+    nodeid, the test function's title path, etc. Returns None if no
+    token matches.
+    """
+    for c in candidates:
+        if not c:
+            continue
+        for tok in c.split():
+            m = _KEY_TOKEN_RE.match(tok)
+            if m is not None:
+                return m.group(1)
+    return None
+
+
+# ── full_name ────────────────────────────────────────────────────────────
+
+
+def full_name(nodeid: str) -> str:
+    """Display name + identity key for the test case row.
+
+    pytest nodeids already include parametrize variants and class scope
+    (`tests/test_x.py::TestThing::test_y[a-1]`), so we use them verbatim —
+    just trimmed.
+    """
+    return nodeid.strip()
+
+
+# ── error formatting ─────────────────────────────────────────────────────
+
+
+def format_error(longrepr: Any) -> str | None:
+    """Turn pytest's longrepr (string-or-rich-object) into a bounded string.
+
+    pytest's `TestReport.longrepr` is either None, a string, or a rich
+    ReprExceptionInfo-like object with a `__str__` that renders the
+    traceback. We coerce everything to a string and truncate to the API's
+    8192-char cap (see api/src/runs.ts attempt schema).
+    """
+    if longrepr is None:
+        return None
+    s = longrepr if isinstance(longrepr, str) else str(longrepr)
+    if not s:
+        return None
+    if len(s) > _ERROR_MESSAGE_MAX:
+        return s[: _ERROR_MESSAGE_MAX - 1] + "…"  # ellipsis
+    return s
+
+
+# ── duration ─────────────────────────────────────────────────────────────
+
+
+def duration_ms(seconds: float | int | None) -> int:
+    """Pytest reports durations in fractional seconds. The API wants int ms."""
+    if seconds is None:
+        return 0
+    if seconds <= 0:
+        return 0
+    return int(round(seconds * 1000))
+
+
+# ── phase aggregation ────────────────────────────────────────────────────
+
+
+def overall_status_from_phases(phases: dict[str, Any]) -> ResultStatus:
+    """Collapse setup/call/teardown reports into a single ResultStatus.
+
+    Decision order:
+      1. setup.failed → blocked (the test never ran, so we don't call it
+         a fail — that would taint failure-rate charts with infra issues).
+      2. call.failed → fail
+      3. teardown.failed → fail (the test code ran, but resources leaked
+         or finalizers blew up; surface it)
+      4. call.skipped → skipped
+      5. setup or call passed → pass
+      6. anything else → blocked
+    """
+    setup = phases.get("setup")
+    call = phases.get("call")
+    teardown = phases.get("teardown")
+
+    if setup is not None and setup.outcome == "failed":
+        return "blocked"
+    # @pytest.mark.skip / skipif / collection-time skip puts outcome='skipped'
+    # on the SETUP report (the test body never runs). This must be checked
+    # before the "anything else" fallback or every @skip lands as 'blocked'.
+    if setup is not None and setup.outcome == "skipped":
+        return "skipped"
+    if call is not None and call.outcome in ("failed", "error"):
+        return "fail"
+    if teardown is not None and teardown.outcome in ("failed", "error"):
+        return "fail"
+    if call is not None and call.outcome == "skipped":
+        return "skipped"
+    if call is not None and call.outcome == "passed":
+        return "pass"
+    if setup is not None and setup.outcome == "passed" and call is None:
+        # setup ran clean but call was never reported — typically a
+        # collection-time skip. Treat as skipped, not blocked.
+        return "skipped"
+    return "blocked"
+
+
+def build_steps(phases: dict[str, Any]) -> list[SubmitStep]:
+    """Build the per-phase step tree from setup/call/teardown reports.
+
+    Each phase that actually fired becomes one step at the top level. We
+    emit them in lifecycle order so the UI shows setup → call → teardown.
+    """
+    out: list[SubmitStep] = []
+    for phase in ("setup", "call", "teardown"):
+        rep = phases.get(phase)
+        if rep is None:
+            continue
+        step: SubmitStep = {
+            "title": phase,
+            "status": map_step_status(rep.outcome),
+            "duration_ms": duration_ms(getattr(rep, "duration", 0.0)),
+            "category": "hook",
+            "error_message": format_error(getattr(rep, "longrepr", None)),
+            "children": [],
+        }
+        out.append(step)
+    return out
+
+
+# ── CI detection (parity with reporter-core/src/ci.ts) ───────────────────
+
+
+def _env() -> dict[str, str]:
+    return dict(os.environ)
+
+
+def detect_ci() -> CIInfo | None:
+    """Auto-populate the `ci` block on POST /v1/runs.
+
+    Mirrors reporter-core/src/ci.ts so Python and JS reporters produce
+    indistinguishable run rows for the same CI build. Every field is
+    optional — partial detection (e.g. raw `CI=true`) still yields a
+    usable record.
+    """
+    env = _env()
+
+    if env.get("GITHUB_ACTIONS"):
+        ref = env.get("GITHUB_REF", "")
+        m = re.search(r"refs/pull/(\d+)", ref)
+        pr_number = int(m.group(1)) if m else None
+        repo = env.get("GITHUB_REPOSITORY")
+        server = env.get("GITHUB_SERVER_URL", "https://github.com")
+        repo_url = f"{server}/{repo}" if repo else None
+        run_id = env.get("GITHUB_RUN_ID")
+        run_attempt = env.get("GITHUB_RUN_ATTEMPT")
+        ci_link: str | None = None
+        if repo_url and run_id:
+            ci_link = f"{repo_url}/actions/runs/{run_id}"
+            if run_attempt:
+                ci_link = f"{ci_link}/attempts/{run_attempt}"
+        out: CIInfo = {"provider": "github"}
+        branch = (
+            env.get("GITHUB_HEAD_REF")
+            or env.get("GITHUB_REF_NAME")
+            or env.get("GITHUB_REF")
+        )
+        if branch:
+            out["branch"] = branch
+        if env.get("GITHUB_SHA"):
+            out["commit_sha"] = env["GITHUB_SHA"]
+        if env.get("GITHUB_ACTOR"):
+            out["author"] = env["GITHUB_ACTOR"]
+        if pr_number is not None:
+            out["pr_number"] = pr_number
+            if repo_url:
+                out["pr_url"] = f"{repo_url}/pull/{pr_number}"
+        if repo_url:
+            out["repo_url"] = repo_url
+        if ci_link:
+            out["ci_link"] = ci_link
+        return out
+
+    if env.get("GITLAB_CI"):
+        out = {"provider": "gitlab"}
+        branch = env.get("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME") or env.get(
+            "CI_COMMIT_BRANCH"
+        )
+        if branch:
+            out["branch"] = branch
+        if env.get("CI_COMMIT_SHA"):
+            out["commit_sha"] = env["CI_COMMIT_SHA"]
+        if env.get("CI_COMMIT_MESSAGE"):
+            out["commit_msg"] = env["CI_COMMIT_MESSAGE"]
+        if env.get("GITLAB_USER_NAME"):
+            out["author"] = env["GITLAB_USER_NAME"]
+        if env.get("CI_MERGE_REQUEST_IID"):
+            try:
+                out["pr_number"] = int(env["CI_MERGE_REQUEST_IID"])
+            except ValueError:
+                pass
+        if env.get("CI_MERGE_REQUEST_URL"):
+            out["pr_url"] = env["CI_MERGE_REQUEST_URL"]
+        if env.get("CI_PROJECT_URL"):
+            out["repo_url"] = env["CI_PROJECT_URL"]
+        return out
+
+    if env.get("CIRCLECI"):
+        out = {"provider": "circleci"}
+        if env.get("CIRCLE_BRANCH"):
+            out["branch"] = env["CIRCLE_BRANCH"]
+        if env.get("CIRCLE_SHA1"):
+            out["commit_sha"] = env["CIRCLE_SHA1"]
+        if env.get("CIRCLE_USERNAME"):
+            out["author"] = env["CIRCLE_USERNAME"]
+        pr_url = env.get("CIRCLE_PULL_REQUEST")
+        if pr_url:
+            m = re.search(r"/pull/(\d+)", pr_url)
+            if m:
+                out["pr_number"] = int(m.group(1))
+            out["pr_url"] = pr_url
+        if env.get("CIRCLE_REPOSITORY_URL"):
+            out["repo_url"] = env["CIRCLE_REPOSITORY_URL"]
+        return out
+
+    if env.get("JENKINS_URL"):
+        out = {"provider": "jenkins"}
+        branch = env.get("GIT_BRANCH") or env.get("BRANCH_NAME")
+        if branch:
+            out["branch"] = branch
+        if env.get("GIT_COMMIT"):
+            out["commit_sha"] = env["GIT_COMMIT"]
+        if env.get("BUILD_USER"):
+            out["author"] = env["BUILD_USER"]
+        if env.get("CHANGE_ID"):
+            try:
+                out["pr_number"] = int(env["CHANGE_ID"])
+            except ValueError:
+                pass
+        if env.get("CHANGE_URL"):
+            out["pr_url"] = env["CHANGE_URL"]
+        if env.get("GIT_URL"):
+            out["repo_url"] = env["GIT_URL"]
+        return out
+
+    if env.get("TF_BUILD"):
+        out = {"provider": "azure"}
+        branch = env.get("SYSTEM_PULLREQUEST_SOURCEBRANCH") or env.get(
+            "BUILD_SOURCEBRANCH"
+        )
+        if branch:
+            out["branch"] = branch
+        if env.get("BUILD_SOURCEVERSION"):
+            out["commit_sha"] = env["BUILD_SOURCEVERSION"]
+        if env.get("BUILD_SOURCEVERSIONMESSAGE"):
+            out["commit_msg"] = env["BUILD_SOURCEVERSIONMESSAGE"]
+        if env.get("BUILD_REQUESTEDFOR"):
+            out["author"] = env["BUILD_REQUESTEDFOR"]
+        pr_number = env.get("SYSTEM_PULLREQUEST_PULLREQUESTNUMBER")
+        if pr_number:
+            try:
+                out["pr_number"] = int(pr_number)
+            except ValueError:
+                pass
+        if env.get("BUILD_REPOSITORY_URI"):
+            out["repo_url"] = env["BUILD_REPOSITORY_URI"]
+        return out
+
+    if env.get("CI"):
+        out = {"provider": "unknown"}
+        branch = env.get("BRANCH") or env.get("GIT_BRANCH")
+        if branch:
+            out["branch"] = branch
+        commit = env.get("COMMIT_SHA") or env.get("GIT_COMMIT")
+        if commit:
+            out["commit_sha"] = commit
+        return out
+
+    return None

pytest_devant_cloud/plugin.py

@@ -0,0 +1,464 @@
+"""pytest plugin entrypoint — streams every test into Devant Cloud.
+
+Why these hooks (sourced from pytest 9.x reference docs):
+
+  * pytest_addoption            — register CLI flags (--devant-api-url, etc.)
+                                  and the custom `devant` marker.
+  * pytest_configure            — read env/CLI options, register the marker,
+                                  and stand up the HTTP client. Doesn't open
+                                  the run yet — we want to know the test
+                                  count from collection first.
+  * pytest_sessionstart         — `POST /v1/runs` once collection has happened
+                                  (unless DEVQ_RUN_ID is set; then we attach
+                                  to an externally-owned run).
+  * pytest_runtest_makereport   — wrapper hook that stashes the phase report
+                                  (setup/call/teardown) on the item, so the
+                                  later logreport hook can see all three
+                                  phases at once. This is the documented
+                                  pattern in pytest's "make test result info
+                                  available in fixtures" example.
+  * pytest_runtest_logreport    — central reporting hook. We fire on the
+                                  *teardown* report (which is always last)
+                                  so we have setup+call+teardown in hand
+                                  when we POST /v1/runs/:id/results.
+  * pytest_sessionfinish        — `POST /v1/runs/:id/complete`.
+  * pytest_unconfigure          — close the HTTP client.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import os
+import sys
+from typing import Any
+
+import pytest
+
+from . import mapping
+from .client import DevqClient, ResolvedCase
+
+
+# ── pytest stash keys ───────────────────────────────────────────────────
+
+# Stashed on each Item so the wrapper makereport can accumulate phase reports
+# across setup/call/teardown without leaking module-level state.
+_PHASES_KEY: pytest.StashKey[dict[str, pytest.TestReport]] = pytest.StashKey()
+
+# Stashed on the Config so every hook gets at the live plugin state.
+_STATE_KEY: pytest.StashKey["_State"] = pytest.StashKey()
+
+
+class _State:
+    """Plugin runtime state — one per pytest session."""
+
+    def __init__(
+        self,
+        *,
+        client: DevqClient,
+        run_name: str,
+        external_run_id: int | None,
+    ) -> None:
+        self.client = client
+        self.run_name = run_name
+        self.run_id: int | None = external_run_id
+        self.external_run = external_run_id is not None
+        # Per-fullName cache so retries (e.g. pytest-rerunfailures) share
+        # one resolveTestCase call instead of minting duplicates.
+        self.resolved_cases: dict[str, ResolvedCase] = {}
+        # Track every nodeid we've already POSTed for. pytest emits a
+        # logreport per phase; we only want to submit one combined result
+        # per test, on teardown.
+        self.submitted: set[str] = set()
+
+
+# ── CLI options + marker ────────────────────────────────────────────────
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup(
+        "devant_cloud", "stream test results to Devant Cloud"
+    )
+    group.addoption(
+        "--devant-api-url",
+        action="store",
+        default=None,
+        help="Devant Cloud API URL (env: DEVQ_API_URL)",
+    )
+    group.addoption(
+        "--devant-token",
+        action="store",
+        default=None,
+        help="Bearer token (env: DEVQ_TOKEN)",
+    )
+    group.addoption(
+        "--devant-project-id",
+        action="store",
+        type=int,
+        default=None,
+        help="Project id (env: DEVQ_PROJECT_ID)",
+    )
+    group.addoption(
+        "--devant-run-name",
+        action="store",
+        default=None,
+        help="Run display name (env: DEVQ_RUN_NAME)",
+    )
+    group.addoption(
+        "--devant-run-id",
+        action="store",
+        type=int,
+        default=None,
+        help="Attach to an externally created run instead of creating one "
+        "(env: DEVQ_RUN_ID)",
+    )
+    group.addoption(
+        "--devant-disable",
+        action="store_true",
+        default=False,
+        help="Disable the Devant Cloud reporter for this run",
+    )
+
+
+def _opt(config: pytest.Config, cli: str, env: str, default: Any) -> Any:
+    """CLI flag wins, then env var, then default."""
+    v = config.getoption(cli, default=None)
+    if v is not None:
+        return v
+    if env in os.environ and os.environ[env] != "":
+        return os.environ[env]
+    return default
+
+
+# ── configure ───────────────────────────────────────────────────────────
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    # Register the `@pytest.mark.devant("KEY")` marker so pytest doesn't
+    # warn about "unknown marker" when users adopt it.
+    config.addinivalue_line(
+        "markers",
+        'devant(key): bind this test to a Devant Cloud test_case by key '
+        '(e.g. @pytest.mark.devant("DEF-AB12"))',
+    )
+
+    if config.getoption("--devant-disable", default=False):
+        return
+
+    api_url = _opt(
+        config, "--devant-api-url", "DEVQ_API_URL", "http://localhost:32124"
+    )
+    api_token_explicit = (
+        config.getoption("--devant-token", default=None)
+        or os.environ.get("DEVQ_TOKEN")
+    )
+    api_token = api_token_explicit or "dev-admin-token"
+
+    project_raw = _opt(config, "--devant-project-id", "DEVQ_PROJECT_ID", 1)
+    try:
+        project_id = int(project_raw)
+    except (TypeError, ValueError):
+        project_id = 0
+    if project_id <= 0:
+        # Don't blow up the test run — just refuse to enable the plugin.
+        sys.stderr.write(
+            "[devant] DEVQ_PROJECT_ID must be a positive integer; reporter "
+            "disabled for this run\n"
+        )
+        return
+
+    # Warn loudly when shipping the dev fallback token at a non-local URL —
+    # same footgun guard the playwright reporter has.
+    if not api_token_explicit:
+        lowered = api_url.lower()
+        is_local = any(
+            lowered.startswith(p)
+            for p in (
+                "http://localhost",
+                "https://localhost",
+                "http://127.0.0.1",
+                "https://127.0.0.1",
+                "http://0.0.0.0",
+                "https://0.0.0.0",
+                "http://[::1]",
+                "https://[::1]",
+            )
+        )
+        if not is_local:
+            sys.stderr.write(
+                f'[devant] DEVQ_TOKEN is not set; falling back to "dev-admin-token" '
+                f"against {api_url}. Set DEVQ_TOKEN to a real CI token for "
+                "production use.\n"
+            )
+
+    run_name = _opt(
+        config,
+        "--devant-run-name",
+        "DEVQ_RUN_NAME",
+        f"pytest — {_dt.datetime.now(_dt.timezone.utc).isoformat(timespec='seconds')}",
+    )
+
+    external_run_raw = _opt(config, "--devant-run-id", "DEVQ_RUN_ID", None)
+    external_run_id: int | None = None
+    if external_run_raw not in (None, ""):
+        try:
+            n = int(external_run_raw)
+            if n > 0:
+                external_run_id = n
+        except (TypeError, ValueError):
+            pass
+
+    client = DevqClient(
+        api_url=api_url,
+        api_token=api_token,
+        project_id=project_id,
+    )
+    state = _State(
+        client=client,
+        run_name=str(run_name),
+        external_run_id=external_run_id,
+    )
+    config.stash[_STATE_KEY] = state
+
+
+# ── session lifecycle ───────────────────────────────────────────────────
+
+
+def pytest_sessionstart(session: pytest.Session) -> None:
+    state = session.config.stash.get(_STATE_KEY, None)
+    if state is None or state.external_run:
+        return
+    ci = mapping.detect_ci()
+    try:
+        row = state.client.create_run(
+            name=state.run_name,
+            framework="pytest",
+            ci=ci,
+        )
+        state.run_id = int(row["id"])
+        sys.stderr.write(
+            f'[devant] created run #{state.run_id} "{state.run_name}"\n'
+        )
+    except Exception as exc:  # noqa: BLE001 — never break the test run
+        sys.stderr.write(f"[devant] failed to create run: {exc}\n")
+
+
+def pytest_sessionfinish(
+    session: pytest.Session, exitstatus: int
+) -> None:
+    state = session.config.stash.get(_STATE_KEY, None)
+    if state is None or state.run_id is None:
+        return
+    if state.external_run:
+        return
+    try:
+        state.client.complete_run(state.run_id)
+        sys.stderr.write(f"[devant] closed run #{state.run_id}\n")
+    except Exception as exc:  # noqa: BLE001
+        sys.stderr.write(f"[devant] failed to complete run: {exc}\n")
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    state = config.stash.get(_STATE_KEY, None)
+    if state is None:
+        return
+    try:
+        state.client.close()
+    except Exception:  # noqa: BLE001
+        pass
+
+
+# ── per-test phase capture ──────────────────────────────────────────────
+
+
+@pytest.hookimpl(wrapper=True, tryfirst=True)
+def pytest_runtest_makereport(item: pytest.Item, call: pytest.CallInfo[None]):
+    """Stash each phase report on the item so logreport can see them all.
+
+    This is the canonical pattern from pytest's "make test result info
+    available in fixtures" example (doc/en/example/simple.rst). We need
+    setup + call + teardown in one place to build the step tree.
+    """
+    rep: pytest.TestReport = yield
+    phases = item.stash.setdefault(_PHASES_KEY, {})
+    phases[rep.when] = rep
+    return rep
+
+
+# Note: pytest_runtest_logreport fires once per phase (setup, call, teardown)
+# but only receives the TestReport, not the Item — so it can't see the
+# stashed phase dict. We instead use pytest_runtest_logfinish, which fires
+# once per test node *after* all three phases, and resolve back to the Item
+# via session.items. This matches the pytest 9 hook reference for plugins
+# that need cross-phase visibility.
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_runtest_logfinish(
+    nodeid: str, location: tuple[str, int | None, str]
+) -> None:
+    """Fires after teardown's logreport, once per test node.
+
+    By the time we get here, makereport has stashed setup/call/teardown
+    on the item's stash. We look up the item via the active session and
+    submit one combined result.
+    """
+    session = _active_session()
+    if session is None:
+        return
+    state: _State | None = session.config.stash.get(_STATE_KEY, None)
+    if state is None or state.run_id is None:
+        return
+    if nodeid in state.submitted:
+        return
+    state.submitted.add(nodeid)
+
+    item = _item_for_nodeid(session, nodeid)
+    if item is None:
+        return
+    phases: dict[str, pytest.TestReport] = item.stash.get(_PHASES_KEY, {})
+    if not phases:
+        return
+
+    try:
+        _submit_one(state, item, phases)
+    except Exception as exc:  # noqa: BLE001
+        sys.stderr.write(
+            f'[devant] failed to submit result for "{nodeid}": {exc}\n'
+        )
+
+
+# ── helpers ──────────────────────────────────────────────────────────────
+
+
+_SESSION: pytest.Session | None = None
+
+
+def _active_session() -> pytest.Session | None:
+    return _SESSION
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_collection(session: pytest.Session) -> None:
+    """Side-channel: keep a reference to the session for the logfinish hook,
+    which doesn't receive it. pytest_collection fires once per session,
+    before any test runs, and is the earliest hook that hands us the Session.
+    """
+    global _SESSION
+    _SESSION = session
+
+
+def _item_for_nodeid(
+    session: pytest.Session, nodeid: str
+) -> pytest.Item | None:
+    for it in session.items:
+        if it.nodeid == nodeid:
+            return it
+    return None
+
+
+def _explicit_key_from_item(item: pytest.Item) -> str | None:
+    """Try every place a key might live: marker args, item.name, nodeid."""
+    candidates: list[str | None] = []
+    for marker in item.iter_markers(name="devant"):
+        for a in marker.args:
+            if isinstance(a, str):
+                candidates.append(a)
+    candidates.append(item.name)
+    candidates.append(item.nodeid)
+    return mapping.extract_key(*candidates)
+
+
+def _submit_one(
+    state: _State,
+    item: pytest.Item,
+    phases: dict[str, pytest.TestReport],
+) -> None:
+    full_name = mapping.full_name(item.nodeid)
+
+    # Cache by full_name so retries collapse into one resolveTestCase call.
+    resolved = state.resolved_cases.get(full_name)
+    if resolved is None:
+        explicit_key = _explicit_key_from_item(item)
+        try:
+            resolved = state.client.resolve_test_case(
+                explicit_key=explicit_key,
+                full_name=full_name,
+            )
+        except Exception as exc:  # noqa: BLE001
+            sys.stderr.write(
+                f'[devant] could not resolve test case for "{full_name}": {exc}\n'
+            )
+            return
+        state.resolved_cases[full_name] = resolved
+        if resolved.minted:
+            sys.stderr.write(
+                f'[devant] minted {resolved.key} for "{full_name}" '
+                f"— add @pytest.mark.devant(\"{resolved.key}\") to bind it\n"
+            )
+
+    status = mapping.overall_status_from_phases(phases)
+    total_duration = sum(
+        mapping.duration_ms(getattr(rep, "duration", 0.0))
+        for rep in phases.values()
+    )
+
+    # Pull the most informative longrepr for the result-level error_message
+    # (call > teardown > setup) so the run table shows the test failure,
+    # not the cleanup error that followed it.
+    error_message: str | None = None
+    for phase in ("call", "teardown", "setup"):
+        rep = phases.get(phase)
+        if rep is None or rep.outcome == "passed":
+            continue
+        msg = mapping.format_error(getattr(rep, "longrepr", None))
+        if msg:
+            error_message = msg
+            break
+
+    # Captured stdout/stderr — pytest stashes these on the report when
+    # capturing is enabled (the default). Concat across phases so the
+    # attempt has the full picture.
+    stdout_parts: list[str] = []
+    stderr_parts: list[str] = []
+    for phase in ("setup", "call", "teardown"):
+        rep = phases.get(phase)
+        if rep is None:
+            continue
+        cap_out = getattr(rep, "capstdout", "") or ""
+        cap_err = getattr(rep, "capstderr", "") or ""
+        if cap_out:
+            stdout_parts.append(cap_out)
+        if cap_err:
+            stderr_parts.append(cap_err)
+    stdout = "".join(stdout_parts) or None
+    stderr = "".join(stderr_parts) or None
+
+    # Bound captured output to the API caps (65k chars) so a noisy test
+    # doesn't 4xx the entire submit.
+    if stdout and len(stdout) > 65_000:
+        stdout = stdout[:65_000]
+    if stderr and len(stderr) > 65_000:
+        stderr = stderr[:65_000]
+
+    started_at = _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds")
+    steps = mapping.build_steps(phases)
+
+    submit_payload: dict[str, Any] = {
+        "test_case_id": resolved.id,
+        "status": status,
+        "duration_ms": total_duration,
+        "error_message": error_message,
+        "attempts": [
+            {
+                "attempt_no": 1,
+                "status": status,
+                "duration_ms": total_duration,
+                "started_at": started_at,
+                "error_message": error_message,
+                "stdout": stdout,
+                "stderr": stderr,
+                "steps": steps,
+            }
+        ],
+    }
+    state.client.submit_results(state.run_id, [submit_payload])

pytest_devant_cloud-0.1.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: pytest-devant-cloud
+Version: 0.1.0
+Summary: pytest plugin that streams runs, results, and step trees to Devant Cloud's /v1/runs API.
+Project-URL: Homepage, https://github.com/devant-net/devq-cloud/tree/main/packages/pytest-devant-cloud
+Project-URL: Repository, https://github.com/devant-net/devq-cloud
+Author: Devant Cloud
+License: DevQ Cloud Enterprise License
+        
+        Copyright (c) 2026 DevQ Cloud. All rights reserved.
+        
+        ================================================================================
+        THIS IS A TEMPLATE. Review with legal counsel before publishing to npm.
+        ================================================================================
+        
+        1. DEFINITIONS
+        
+           "Software" means this npm package and its source code, including all
+           modifications and derivative works.
+        
+           "Service" means the DevQ Cloud hosted product made available by DevQ Cloud
+           to its customers.
+        
+           "Subscription" means a current, paid commercial agreement between you and
+           DevQ Cloud authorising use of the Service, OR a free-tier registration
+           accepted by DevQ Cloud.
+        
+           "You" means the individual or legal entity exercising rights under this
+           License.
+        
+        2. GRANT OF USE
+        
+           Subject to the terms below and the existence of an active Subscription,
+           DevQ Cloud grants You a non-exclusive, non-transferable, revocable license
+           to:
+        
+           (a) install and run the Software on Your own systems and continuous
+               integration infrastructure;
+           (b) use the Software solely to connect to and interact with the Service;
+           (c) make modifications to the Software for Your own internal use, provided
+               such modifications are not distributed.
+        
+        3. RESTRICTIONS
+        
+           You may not, except to the extent expressly permitted by applicable law:
+        
+           (a) redistribute, sublicense, sell, rent, lease, or otherwise transfer the
+               Software or any modified version of the Software to any third party;
+           (b) use the Software to provide a managed, hosted, or commercial service
+               that competes with the Service;
+           (c) remove, alter, or obscure any proprietary notices in the Software;
+           (d) reverse engineer, decompile, or disassemble the Software, except as
+               expressly permitted by applicable law notwithstanding this limitation;
+           (e) use the Software in violation of any applicable law or regulation.
+        
+        4. NO TRANSFER OF OWNERSHIP
+        
+           The Software is licensed, not sold. DevQ Cloud retains all right, title,
+           and interest in and to the Software, including all intellectual property
+           rights.
+        
+        5. TERMINATION
+        
+           This License terminates automatically and immediately if Your Subscription
+           ends, expires, or is terminated for any reason. Upon termination, You must
+           cease all use of the Software and destroy all copies in Your possession.
+        
+        6. NO WARRANTY
+        
+           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.
+        
+        7. LIMITATION OF LIABILITY
+        
+           IN NO EVENT SHALL DEVQ CLOUD OR ITS CONTRIBUTORS 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. DEVQ CLOUD'S TOTAL LIABILITY FOR
+           ALL CLAIMS RELATED TO THE SOFTWARE SHALL NOT EXCEED THE FEES PAID BY YOU
+           FOR THE SUBSCRIPTION IN THE TWELVE (12) MONTHS PRECEDING THE CLAIM.
+        
+        8. GOVERNING LAW
+        
+           This License is governed by the laws of the jurisdiction in which DevQ
+           Cloud is incorporated, without regard to its conflict of law principles.
+        
+        9. ENTIRE AGREEMENT
+        
+           This License, together with the Subscription terms, constitutes the
+           entire agreement between You and DevQ Cloud concerning the Software and
+           supersedes all prior or contemporaneous agreements, proposals, or
+           communications.
+        
+        For commercial licensing inquiries, contact: licensing@devq.cloud
+License-File: LICENSE
+Keywords: ci,devant,devq,pytest,reporter,test-reporting
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24
+Requires-Dist: pytest>=7.0
+Description-Content-Type: text/markdown
+
+# pytest-devant-cloud
+
+pytest plugin that streams runs, results, and per-test step trees into
+[Devant Cloud](https://github.com/devant-net/devq-cloud) as your suite
+executes — the Python sibling of `@devant-net/playwright-reporter`.
+
+## Install
+
+```bash
+pip install pytest-devant-cloud
+```
+
+The plugin auto-registers via the `pytest11` entry-point group. No
+`conftest.py` changes are needed.
+
+## Configure
+
+Set env vars before invoking pytest:
+
+| Var | Default | Notes |
+|---|---|---|
+| `DEVQ_API_URL` | `http://localhost:32124` | Your tenant's URL |
+| `DEVQ_TOKEN` | `dev-admin-token` | Bearer token (CI/CD settings) |
+| `DEVQ_PROJECT_ID` | `1` | Devant Cloud project id |
+| `DEVQ_RUN_NAME` | `pytest — <ISO date>` | Display name on the run |
+| `DEVQ_RUN_ID` | _(unset)_ | Attach to an externally-created run instead of creating one |
+
+Or with CLI flags:
+
+```bash
+pytest \
+  --devant-api-url=https://acme.devq.cloud \
+  --devant-token=$DEVQ_TOKEN \
+  --devant-project-id=1
+```
+
+To disable the plugin for one run without uninstalling:
+
+```bash
+pytest -p no:devant_cloud
+```
+
+## How tests bind to test cases
+
+Each pytest item resolves to a Devant Cloud `test_case` row in this order:
+
+1. **`@pytest.mark.devant("DEF-AB12")` marker** on the test — looked up
+   via `GET /v1/test-cases/by-key/DEF-AB12`.
+2. **Exact name match** (`<file>::<test>` nodeid) in the project →
+   `GET /v1/test-cases?search=…`.
+3. **Auto-create** → `POST /v1/test-cases`. The plugin prints the new key:
+   ```
+   [devant] minted DEF-XYZ9 for "tests/test_auth.py::test_login"
+            — add @pytest.mark.devant("DEF-XYZ9") to bind it
+   ```
+
+Bind the key in source once and future runs (even with renames) reuse the
+same case.
+
+## What gets sent
+
+| pytest hook | Devant Cloud call |
+|---|---|
+| `pytest_sessionstart` | `POST /v1/runs` (skipped if `DEVQ_RUN_ID` is set) |
+| `pytest_runtest_makereport` (wrapper) | stashes setup/call/teardown reports on the item |
+| `pytest_runtest_logreport` (teardown phase) | resolve test case → `POST /v1/runs/:id/results` with step tree |
+| `pytest_sessionfinish` | `POST /v1/runs/:id/complete` (skipped if `DEVQ_RUN_ID` is set) |
+
+The step tree includes one node per phase (setup / call / teardown) with
+status, duration, and longrepr captured as `error_message`.
+
+## CI metadata
+
+Auto-detected for GitHub Actions, GitLab CI, CircleCI, Jenkins, and Azure
+DevOps, plus a generic `CI=true` fallback. Populates the `ci_*` columns
+on the run so the dashboard can deep-link to commits and PRs.

pytest_devant_cloud-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pytest_devant_cloud/__init__.py,sha256=sz4Rh-0ayx1hg_8v5Si1QAgRyRH5ipCkoSj1SBS_LQU,369
+pytest_devant_cloud/client.py,sha256=oFF1uq620QLkNeN2HEsm6NdJTSJJSEvw_vikJ7kyi-8,7559
+pytest_devant_cloud/mapping.py,sha256=uy0RGadoxI-YIg9FrxAoLWljYK4pYTjNj76ICQncjfM,13553
+pytest_devant_cloud/plugin.py,sha256=drvVGqvDka--lznrN8FuTIslzCcPGueviWPhuZNaPbg,16279
+pytest_devant_cloud-0.1.0.dist-info/METADATA,sha256=zokO2oRWKj1qjRkn3AOaw4K8HJt-t-uvZm0pvTL3LMM,7914
+pytest_devant_cloud-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pytest_devant_cloud-0.1.0.dist-info/entry_points.txt,sha256=4s6QpFgmv3P_kVcfd4qW_BPTlTIgR6i7eWPW5D15YIY,53
+pytest_devant_cloud-0.1.0.dist-info/licenses/LICENSE,sha256=NGeEdLb0IImvgOt1Yoh8iXxDPpqBHGiRHjTTONweVwE,3608
+pytest_devant_cloud-0.1.0.dist-info/RECORD,,

pytest_devant_cloud-0.1.0.dist-info/WHEEL

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

pytest_devant_cloud-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+devant_cloud = pytest_devant_cloud.plugin

pytest_devant_cloud-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,88 @@
+DevQ Cloud Enterprise License
+
+Copyright (c) 2026 DevQ Cloud. All rights reserved.
+
+================================================================================
+THIS IS A TEMPLATE. Review with legal counsel before publishing to npm.
+================================================================================
+
+1. DEFINITIONS
+
+   "Software" means this npm package and its source code, including all
+   modifications and derivative works.
+
+   "Service" means the DevQ Cloud hosted product made available by DevQ Cloud
+   to its customers.
+
+   "Subscription" means a current, paid commercial agreement between you and
+   DevQ Cloud authorising use of the Service, OR a free-tier registration
+   accepted by DevQ Cloud.
+
+   "You" means the individual or legal entity exercising rights under this
+   License.
+
+2. GRANT OF USE
+
+   Subject to the terms below and the existence of an active Subscription,
+   DevQ Cloud grants You a non-exclusive, non-transferable, revocable license
+   to:
+
+   (a) install and run the Software on Your own systems and continuous
+       integration infrastructure;
+   (b) use the Software solely to connect to and interact with the Service;
+   (c) make modifications to the Software for Your own internal use, provided
+       such modifications are not distributed.
+
+3. RESTRICTIONS
+
+   You may not, except to the extent expressly permitted by applicable law:
+
+   (a) redistribute, sublicense, sell, rent, lease, or otherwise transfer the
+       Software or any modified version of the Software to any third party;
+   (b) use the Software to provide a managed, hosted, or commercial service
+       that competes with the Service;
+   (c) remove, alter, or obscure any proprietary notices in the Software;
+   (d) reverse engineer, decompile, or disassemble the Software, except as
+       expressly permitted by applicable law notwithstanding this limitation;
+   (e) use the Software in violation of any applicable law or regulation.
+
+4. NO TRANSFER OF OWNERSHIP
+
+   The Software is licensed, not sold. DevQ Cloud retains all right, title,
+   and interest in and to the Software, including all intellectual property
+   rights.
+
+5. TERMINATION
+
+   This License terminates automatically and immediately if Your Subscription
+   ends, expires, or is terminated for any reason. Upon termination, You must
+   cease all use of the Software and destroy all copies in Your possession.
+
+6. NO WARRANTY
+
+   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.
+
+7. LIMITATION OF LIABILITY
+
+   IN NO EVENT SHALL DEVQ CLOUD OR ITS CONTRIBUTORS 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. DEVQ CLOUD'S TOTAL LIABILITY FOR
+   ALL CLAIMS RELATED TO THE SOFTWARE SHALL NOT EXCEED THE FEES PAID BY YOU
+   FOR THE SUBSCRIPTION IN THE TWELVE (12) MONTHS PRECEDING THE CLAIM.
+
+8. GOVERNING LAW
+
+   This License is governed by the laws of the jurisdiction in which DevQ
+   Cloud is incorporated, without regard to its conflict of law principles.
+
+9. ENTIRE AGREEMENT
+
+   This License, together with the Subscription terms, constitutes the
+   entire agreement between You and DevQ Cloud concerning the Software and
+   supersedes all prior or contemporaneous agreements, proposals, or
+   communications.
+
+For commercial licensing inquiries, contact: licensing@devq.cloud