sift-stack-py 0.17.0.dev0__py3-none-any.whl → 0.17.0.dev1__py3-none-any.whl

sift_client/_internal/grpc_transport/transport.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 from importlib.metadata import PackageNotFoundError, version
 from typing import TYPE_CHECKING, Any, TypedDict, cast
-from urllib.parse import ParseResult, urlparse
 
 import grpc
 import grpc.aio as grpc_aio
@@ -21,6 +20,7 @@ from sift_client._internal.grpc_transport._interceptors.metadata import (
     Metadata,
     MetadataInterceptor,
 )
+from sift_client._internal.urls import parse_host
 
 if TYPE_CHECKING:
     from sift_client._internal.grpc_transport._async_interceptors.base import ClientAsyncInterceptor
@@ -78,7 +78,7 @@ def use_sift_channel(
 
     credentials = get_ssl_credentials(cert_via_openssl)
     options = _compute_channel_options(config)
-    api_uri = _clean_uri(config["uri"], use_ssl)
+    api_uri = parse_host(config["uri"])
     channel = grpc.secure_channel(api_uri, credentials, options)
     interceptors = _compute_sift_interceptors(config, metadata)
     return grpc.intercept_channel(channel, *interceptors)
@@ -98,7 +98,7 @@ def use_sift_async_channel(
         return _use_insecure_sift_async_channel(config, metadata)
 
     return grpc_aio.secure_channel(
-        target=_clean_uri(config["uri"], use_ssl),
+        target=parse_host(config["uri"]),
         credentials=get_ssl_credentials(cert_via_openssl),
         options=_compute_channel_options(config),
         interceptors=_compute_sift_async_interceptors(config, metadata),
@@ -112,7 +112,7 @@ def _use_insecure_sift_channel(
     FOR DEVELOPMENT PURPOSES ONLY
     """
     options = _compute_channel_options(config)
-    api_uri = _clean_uri(config["uri"], False)
+    api_uri = parse_host(config["uri"])
     channel = grpc.insecure_channel(api_uri, options)
     interceptors = _compute_sift_interceptors(config, metadata)
     return grpc.intercept_channel(channel, *interceptors)
@@ -125,7 +125,7 @@ def _use_insecure_sift_async_channel(
     FOR DEVELOPMENT PURPOSES ONLY
     """
     return grpc_aio.insecure_channel(
-        target=_clean_uri(config["uri"], False),
+        target=parse_host(config["uri"]),
         options=_compute_channel_options(config),
         interceptors=_compute_sift_async_interceptors(config, metadata),
     )
@@ -205,21 +205,6 @@ def _metadata_async_interceptor(
     return MetadataAsyncInterceptor(md)
 
 
-def _clean_uri(uri: str, use_ssl: bool) -> str:
-    """
-    This will automatically transform the URI to an acceptable form regardless of whether or not
-    users included the scheme in the URL or included trailing slashes.
-    """
-
-    if "http://" in uri or "https://" in uri:
-        parsed: ParseResult = urlparse(uri)
-        return parsed.netloc
-
-    full_uri = f"https://{uri}" if use_ssl else f"http://{uri}"
-    parsed_res: ParseResult = urlparse(full_uri)
-    return parsed_res.netloc
-
-
 def _compute_user_agent() -> str:
     try:
         return f"sift_stack_py/{version('sift_stack_py')}"

sift_client/_internal/rest.py

@@ -6,7 +6,7 @@ from requests.adapters import HTTPAdapter
 from typing_extensions import NotRequired
 from urllib3.util import Retry
 
-from sift_client._internal.grpc_transport.transport import _clean_uri
+from sift_client._internal.urls import parse_host
 
 _DEFAULT_REST_RETRY = Retry(total=3, status_forcelist=[500, 502, 503, 504], backoff_factor=1)
 
@@ -33,7 +33,7 @@ class SiftRestConfig(TypedDict):
 def compute_uri(restconf: SiftRestConfig) -> str:
     uri = restconf["uri"]
     use_ssl = restconf.get("use_ssl", True)
-    clean_uri = _clean_uri(uri, use_ssl)
+    clean_uri = parse_host(uri)
 
     if use_ssl:
         return f"https://{clean_uri}"

sift_client/_internal/urls.py

@@ -0,0 +1,55 @@
+"""Helpers for turning Sift API endpoints into web-app (frontend) URLs.
+
+The Sift frontend can be hosted on several domains and the backend exposes no
+field for its own URL, so the frontend origin is derived client-side from the
+API host. This table mirrors the canonical mapping used by the Grafana
+datasource (sift-stack/sift-grafana-datasource,
+``src/components/sharelink/getFrontendHostnameDefaults.ts``). Hosts outside the
+table (on-prem and custom deployments) require an explicit override.
+"""
+
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+# API host (host[:port], no scheme) -> frontend origin (with scheme).
+_API_HOST_TO_FRONTEND_ORIGIN: dict[str, str] = {
+    "api.siftstack.com": "https://app.siftstack.com",
+    "gov.api.siftstack.com": "https://gov.siftstack.com",
+}
+
+
+def parse_origin(url: str) -> str:
+    """Normalize a URL or bare host into a ``scheme://host[:port]`` origin.
+
+    Bare hosts (no scheme) are assumed to be ``https``.
+    """
+    candidate = url if "://" in url else f"https://{url}"
+    parsed = urlparse(candidate)
+    return f"{parsed.scheme}://{parsed.netloc}".rstrip("/")
+
+
+def parse_host(url: str) -> str:
+    """Extract ``host[:port]`` from a URL or bare host string."""
+    candidate = url if "://" in url else f"https://{url}"
+    return urlparse(candidate).netloc
+
+
+def frontend_origin_for_api(api_base_url: str, override: str | None = None) -> str | None:
+    """Return the Sift web-app origin for a given API base URL.
+
+    Args:
+        api_base_url: The REST API base URL (e.g. ``https://api.siftstack.com``).
+        override: An explicit frontend origin (host or full URL) to use instead
+            of the derived value. Set this for on-prem or custom deployments
+            whose API host isn't in the built-in mapping.
+
+    Returns:
+        The frontend origin (e.g. ``https://app.siftstack.com``), or ``None``
+        when no override is given and the API host isn't recognized.
+    """
+    if override:
+        return parse_origin(override)
+    if not api_base_url:
+        return None
+    return _API_HOST_TO_FRONTEND_ORIGIN.get(parse_host(api_base_url))

sift_client/client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from sift_client._internal.urls import frontend_origin_for_api
 from sift_client.resources import (
     AssetsAPI,
     AssetsAPIAsync,
@@ -124,6 +125,7 @@ class SiftClient(
         grpc_url: str | None = None,
         rest_url: str | None = None,
         connection_config: SiftConnectionConfig | None = None,
+        app_url: str | None = None,
     ):
         """Initialize the SiftClient with specific connection parameters or a connection_config.
 
@@ -132,6 +134,10 @@ class SiftClient(
             grpc_url: The Sift gRPC API URL.
             rest_url: The Sift REST API URL.
             connection_config: A SiftConnectionConfig object to configure the connection behavior of the SiftClient.
+            app_url: The Sift web-app origin (e.g. ``https://app.siftstack.com``).
+                Set this for on-prem or custom deployments whose API host can't be
+                mapped to a frontend automatically; see the ``app_url`` property.
+                A value here takes precedence over ``connection_config.app_url``.
         """
         if not (api_key and grpc_url and rest_url) and not connection_config:
             raise ValueError(
@@ -152,6 +158,12 @@ class SiftClient(
         WithGrpcClient.__init__(self, grpc_client=grpc_client)
         WithRestClient.__init__(self, rest_client=rest_client)
 
+        # Explicit web-app origin override; falls back to the connection config's
+        # value, then to host-based derivation in the ``app_url`` property.
+        self._app_url: str | None = app_url or (
+            connection_config.app_url if connection_config else None
+        )
+
         # When set, test-results writes return synthesized responses without
         # contacting Sift. Read by `TestResultsAPIAsync._simulate`. Used by the
         # pytest plugin's ``--sift-disabled`` mode.
@@ -198,3 +210,18 @@ class SiftClient(
     def rest_client(self) -> RestClient:
         """The REST client used by the SiftClient for making REST API calls."""
         return self._rest_client
+
+    @property
+    def app_url(self) -> str | None:
+        """The Sift web-app origin for this client, or None if it can't be determined.
+
+        Uses the explicit override passed at construction when set, otherwise
+        derives the origin from the REST host for known Sift deployments (e.g.
+        ``https://api.siftstack.com`` -> ``https://app.siftstack.com``). Returns
+        None for unrecognized hosts with no override.
+
+        # TODO: Add a ``WithAppPage`` mixin on BaseType so resources (TestReport,
+        # Run, ...) can expose their own web-app link from ``_client.app_url`` plus
+        # a per-type path, instead of callers assembling paths by hand.
+        """
+        return frontend_origin_for_api(self.rest_client.base_url, override=self._app_url)

sift_client/pytest_plugin.py

@@ -15,6 +15,7 @@ from sift_client.errors import SiftWarning
 from sift_client.sift_types.test_report import ErrorInfo, TestStatus
 from sift_client.util.test_results import ReportContext
 from sift_client.util.test_results.context_manager import (
+    _quiet_fork_stderr,
     format_assertion_message,
     format_truncated_traceback,
 )
@@ -42,6 +43,12 @@ if TYPE_CHECKING:
 
 REPORT_CONTEXT: Any = None
 
+# Set at session end with the resolved (real) report id/URL when online and
+# uploaded. Read from a project's conftest in a later hook (e.g.
+# ``pytest_unconfigure``) to post the link, write a file, etc.
+SIFT_REPORT_ID_STASH_KEY = pytest.StashKey[str]()
+SIFT_REPORT_URL_STASH_KEY = pytest.StashKey[str]()
+
 _STASH_MISSING = object()
 
 _PARAMETRIZE_PATH_KEY = pytest.StashKey[Tuple[str, ...]]()
@@ -297,6 +304,33 @@ _REST_URI = _Option(
     "this ini value.",
 )
 
+_REPORT_URL_BASE = _Option(
+    cli_flag="--sift-report-url-base",
+    ini_name="sift_report_url_base",
+    cli_help="Sift web-app origin used to build the clickable report link in the "
+    "terminal footer (e.g. https://app.siftstack.com). Set this for on-prem or "
+    "custom deployments whose API host can't be mapped to a frontend "
+    "automatically. Also honored via the SIFT_APP_URL env var. When unset, the "
+    "link is derived from the REST URI for known Sift hosts.",
+    ini_help="Default for --sift-report-url-base. The Sift web-app origin used to "
+    "build the report link in the terminal footer. Also honored via the "
+    "SIFT_APP_URL env var. When unset, the link is derived from the REST URI for "
+    "known Sift hosts.",
+)
+
+_OPEN = _Option(
+    cli_flag="--sift-open-report",
+    ini_name="sift_open_report",
+    action="store_true",
+    cli_help="Open the resulting Sift test report in a browser at session end. "
+    "Online mode only; no-op when the report URL can't be resolved. Intended for "
+    "local development.",
+    ini_help="When true, open the report in a browser at session end (online only). "
+    "Defaults to false.",
+    ini_type="bool",
+    ini_default=False,
+)
+
 _AUTOUSE = _Option(
     ini_name="sift_autouse",
     ini_help="Default for the Sift autouse fixtures (report_context, step, "
@@ -350,6 +384,8 @@ _OPTIONS: tuple[_Option, ...] = (
     _DISABLED,
     _GRPC_URI,
     _REST_URI,
+    _REPORT_URL_BASE,
+    _OPEN,
     _AUTOUSE,
     _PACKAGE_STEP,
     _MODULE_STEP,
@@ -445,6 +481,305 @@ def _is_disabled(pytestconfig: pytest.Config | None) -> bool:
     return os.getenv("SIFT_DISABLED", "").lower() in ("1", "true", "yes")
 
 
+def _sdk_version() -> str:
+    """Return the installed ``sift_stack_py`` version, or ``"unknown"``."""
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        return version("sift_stack_py")
+    except PackageNotFoundError:
+        return "unknown"
+
+
+def _mode_label(config: pytest.Config) -> str:
+    """Resolve the active mode for the terminal header: disabled > offline > online."""
+    if _is_disabled(config):
+        return "disabled"
+    if _is_offline(config):
+        return "offline"
+    return "online"
+
+
+def pytest_report_header(config: pytest.Config) -> str | None:
+    """Emit a session-start header with the SDK version and active mode.
+
+    Suppressed under ``-q`` (negative verbosity), matching how pytest hides its
+    own platform/plugin header.
+    """
+    if config.get_verbosity() < 0:
+        return None
+    return f"Sift: sift-stack-py {_sdk_version()} — {_mode_label(config)} mode"
+
+
+def _resolve_real_report_id(context: Any) -> str | None:
+    """Resolve the real server-side report id for the online footer link.
+
+    In synchronous online mode (``--sift-log-file=false``) the report is created
+    directly against the API, so ``report.id_`` is already the real id. In the
+    default incremental mode the report is created through the simulate path
+    (a client-side UUID) and the background worker maps it to the real id on
+    replay, recording it in the ``<log>.tracking`` sidecar's ``id_map``. By the
+    time this footer runs the session-scoped report context has torn down and
+    the worker has drained, so the sidecar is final.
+
+    Returns ``None`` when the worker never mapped the report (e.g. it died before
+    replaying the create), meaning no real report exists to link.
+    """
+    report = context.report
+    if not report.id_:
+        # No id was ever assigned (unset/empty); nothing to link.
+        return None
+    sim_id = str(report.id_)
+    if not getattr(report, "is_simulated", False):
+        return sim_id
+    log_file = getattr(context, "log_file", None)
+    if log_file is None:
+        return None
+    from sift_client._internal.low_level_wrappers._test_results_log import LogTracking
+
+    return LogTracking.load(log_file).id_map.get(sim_id)
+
+
+_LABEL_WIDTH = 13
+
+
+def _sift_kv(terminalreporter: Any, label: str, value: str, **value_markup: bool) -> None:
+    """Write an indented ``label  value`` row, bolding the label.
+
+    ``value_markup`` (e.g. ``green=True``, ``cyan=True``) styles only the value.
+    Color is dropped automatically when the terminal has no markup (not a TTY or
+    ``--color=no``), so captured/CI output stays plain text.
+    """
+    terminalreporter.write("  ")
+    terminalreporter.write(f"{label:<{_LABEL_WIDTH}}", bold=True)
+    terminalreporter.write_line(value, **value_markup)
+
+
+# Step-count breakdown order and labels for the footer's "Steps" row.
+_STEP_COUNT_ORDER: tuple[tuple[TestStatus, str], ...] = (
+    (TestStatus.PASSED, "passed"),
+    (TestStatus.FAILED, "failed"),
+    (TestStatus.ERROR, "error"),
+    (TestStatus.ABORTED, "aborted"),
+    (TestStatus.SKIPPED, "skipped"),
+    (TestStatus.IN_PROGRESS, "in progress"),
+)
+
+
+# Per-status color for the footer's step breakdown: green pass, red
+# failure/error/abort, yellow skip; in-progress (and anything else) stays plain.
+_STEP_STATUS_MARKUP: dict[TestStatus, dict[str, bool]] = {
+    TestStatus.PASSED: {"green": True},
+    TestStatus.FAILED: {"red": True},
+    TestStatus.ERROR: {"red": True},
+    TestStatus.ABORTED: {"red": True},
+    TestStatus.SKIPPED: {"yellow": True},
+}
+
+
+def _step_count_segments(counts: Any) -> list[tuple[str, dict[str, bool]]]:
+    """Build ``(text, markup)`` segments for a step tally, non-zero only."""
+    return [
+        (f"{counts.get(status, 0)} {label}", _STEP_STATUS_MARKUP.get(status, {}))
+        for status, label in _STEP_COUNT_ORDER
+        if counts.get(status, 0)
+    ]
+
+
+def _measurement_segments(counts: Any) -> list[tuple[str, dict[str, bool]]]:
+    """Build ``(text, markup)`` segments for a measurement tally, non-zero only."""
+    segments: list[tuple[str, dict[str, bool]]] = []
+    if counts.get(True, 0):
+        segments.append((f"{counts[True]} passed", {"green": True}))
+    if counts.get(False, 0):
+        segments.append((f"{counts[False]} failed", {"red": True}))
+    return segments
+
+
+def _write_count_row(
+    terminalreporter: Any, label: str, segments: list[tuple[str, dict[str, bool]]]
+) -> None:
+    """Write a ``label  a · b · c`` row, applying each segment's color markup."""
+    terminalreporter.write("  ")
+    terminalreporter.write(f"{label:<{_LABEL_WIDTH}}", bold=True)
+    for index, (text, markup) in enumerate(segments):
+        if index:
+            terminalreporter.write(" · ")
+        terminalreporter.write(text, **markup)
+    terminalreporter.write_line("")
+
+
+def _report_panel_title(report: Any, terminalreporter: Any) -> str:
+    """``Sift report · <name>`` for the section rule, truncated to the terminal width.
+
+    The report name embeds a timestamp (and, for invocation-based runs, the
+    pytest args), so a long name is truncated with an ellipsis to keep the
+    separator line from wrapping.
+    """
+    base = "Sift report"
+    name = getattr(report, "name", None)
+    if not name:
+        return base
+    title = f"{base} · {name}"
+    fullwidth = getattr(getattr(terminalreporter, "_tw", None), "fullwidth", 80)
+    # Reserve room for the separator characters and spaces write_sep adds.
+    limit = max(len(base), fullwidth - 8)
+    if len(title) > limit:
+        title = title[: limit - 1] + "…"
+    return title
+
+
+def _maybe_open_report(url: str) -> None:
+    """Best-effort open the report URL in a browser (for ``--sift-open-report``).
+
+    Skipped on CI or non-interactive sessions so a committed ``sift_open_report``
+    setting can't spawn a browser on a headless agent; the flag is meant for
+    local development.
+    """
+    import sys
+    import webbrowser
+
+    if os.environ.get("CI") or not sys.stdout.isatty():
+        return
+    try:
+        # webbrowser.open forks/execs the platform opener while the gRPC client's
+        # background threads are live; redirect fd 2 across the fork to swallow
+        # gRPC's prefork notice (same treatment as the plugin's other fork sites).
+        with _quiet_fork_stderr():
+            webbrowser.open(url)
+    except Exception:
+        # Headless / no browser available: opening is a convenience, never fatal.
+        pass
+
+
+def pytest_terminal_summary(terminalreporter: Any, exitstatus: int, config: pytest.Config) -> None:
+    """Emit a session-end Sift report summary, adapting per mode.
+
+    The printed panel is suppressed under ``-q``, but programmatic side effects
+    (stashing the report ref for ``conftest.py``, ``--sift-open-report``) still run so
+    other plugins and CI steps can consume the result. The panel shows the
+    outcome (green/red), step and measurement tallies, and a per-mode action: a
+    report link (online), the upload command (offline), or a disabled note.
+    """
+    quiet = config.get_verbosity() < 0
+
+    if _is_disabled(config):
+        if not quiet:
+            terminalreporter.write_sep("=", "Sift", cyan=True, bold=True)
+            terminalreporter.write_line("Sift disabled — no test report created.")
+        return
+
+    context = REPORT_CONTEXT
+    if context is None:
+        # No gated test ran, so no report context was created. Nothing to show.
+        return
+
+    log_file = getattr(context, "log_file", None)
+    offline = _is_offline(config)
+
+    # Resolve the report link first so stashing and --sift-open-report run even under
+    # -q (programmatic consumers don't care about verbosity). Truthiness, not
+    # ``is not None``: a resolved-but-empty id (degenerate sidecar mapping, unset
+    # proto field) must fall through to the "not uploaded" path, not produce a
+    # ``/test-results/`` link.
+    report_id = None if offline else _resolve_real_report_id(context)
+    report_url = (
+        f"{context.client.app_url}/test-results/{report_id}"
+        if report_id and context.client.app_url
+        else None
+    )
+    if report_id:
+        config.stash[SIFT_REPORT_ID_STASH_KEY] = report_id
+    if report_url is not None:
+        config.stash[SIFT_REPORT_URL_STASH_KEY] = report_url
+        if _option_or_ini(config, _OPEN):
+            _maybe_open_report(report_url)
+
+    if quiet:
+        return
+
+    failed = bool(getattr(context, "any_failures", False))
+    status_word, status_markup = (
+        ("FAILED", {"red": True, "bold": True})
+        if failed
+        else ("PASSED", {"green": True, "bold": True})
+    )
+    # Offline results live only in the local log until replayed, so the status
+    # row calls that out instead of repeating the version (already in the header).
+    status_context = (
+        f"{_mode_label(config)} · not uploaded"
+        if offline
+        else f"{_mode_label(config)} · sift-stack-py {_sdk_version()}"
+    )
+
+    report = context.report
+
+    terminalreporter.write_sep(
+        "=", _report_panel_title(report, terminalreporter), cyan=True, bold=True
+    )
+
+    # Identity row: the test case (test path or pytest invocation).
+    if report.test_case:
+        _sift_kv(terminalreporter, "Test case", str(report.test_case))
+
+    # Status row: colored outcome, then compact mode context.
+    terminalreporter.write("  ")
+    terminalreporter.write(f"{'Status':<{_LABEL_WIDTH}}", bold=True)
+    terminalreporter.write(status_word, **status_markup)
+    terminalreporter.write_line(f"      {status_context}")
+
+    # Step + measurement tallies (green pass, red failure, yellow skip).
+    _write_count_row(
+        terminalreporter,
+        "Steps",
+        _step_count_segments(context.step_status_counts) or [("no steps", {})],
+    )
+    measurement_segments = _measurement_segments(context.measurement_counts)
+    if measurement_segments:
+        _write_count_row(terminalreporter, "Measurements", measurement_segments)
+
+    # Provenance row: test system and operator.
+    system = " · ".join(part for part in (report.test_system_name, report.system_operator) if part)
+    if system:
+        _sift_kv(terminalreporter, "System", system)
+
+    # Local log file (write-through backup online, sole sink offline).
+    if log_file is not None:
+        _sift_kv(terminalreporter, "Log file", str(log_file))
+
+    if offline:
+        if log_file is not None:
+            terminalreporter.write_sep("-", "to upload to Sift")
+            terminalreporter.write_line(f"  >> import-test-result-log {log_file}", cyan=True)
+        return
+
+    if not report_id:
+        # Incremental upload never mapped the report (the worker died before
+        # replaying the create), so there's no real report to link.
+        _sift_kv(
+            terminalreporter,
+            "Report",
+            f"not uploaded — replay with: import-test-result-log {log_file}",
+            yellow=True,
+        )
+    elif report_url is not None:
+        _sift_kv(terminalreporter, "Report", report_url, cyan=True)
+    else:
+        _sift_kv(
+            terminalreporter,
+            "Report",
+            f"id {report_id}  (set sift_report_url_base for a clickable link)",
+        )
+
+    if report_id and getattr(context, "replay_incomplete", False) and log_file is not None:
+        _sift_kv(
+            terminalreporter,
+            "",
+            f"may be incomplete — finish with: import-test-result-log {log_file}",
+            yellow=True,
+        )
+
+
 def _sift_enabled_for(node: pytest.Item | pytest.Collector, default: bool) -> bool:
     """Resolve the Sift gate for a node: sift_exclude > sift_include > default.
 
@@ -806,6 +1141,10 @@ def sift_client(pytestconfig: pytest.Config) -> SiftClient:
         )
     for env in missing:
         resolved[env] = _OFFLINE_DEFAULTS[env]
+    # Web-app origin for the report link: the sift_report_url_base CLI/ini option
+    # wins, then the SIFT_APP_URL env var, else host-based derivation in
+    # SiftClient.app_url.
+    report_url_base = _option_or_ini(pytestconfig, _REPORT_URL_BASE) or os.getenv("SIFT_APP_URL")
     # `or ""` is unreachable in practice since the `missing` check above guarantees
     # non-None values
     return SiftClient(
@@ -813,6 +1152,7 @@ def sift_client(pytestconfig: pytest.Config) -> SiftClient:
             api_key=resolved.get("SIFT_API_KEY") or "",
             grpc_url=resolved.get("SIFT_GRPC_URI") or "",
             rest_url=resolved.get("SIFT_REST_URI") or "",
+            app_url=report_url_base or None,
         )
     )
 

sift_client/sift_types/test_report.py

@@ -410,6 +410,38 @@ class TestMeasurement(BaseType[TestMeasurementProto, "TestMeasurement"], Simulat
     # Set by the low-level wrapper when this instance came from the simulate path
     _simulated: bool = False
 
+    def __str__(self) -> str:
+        """Human-readable form: ``[STATUS] name = value [unit] (bounds)``.
+
+        Used for failure messages, logs, and the REPL. The string omits whichever
+        parts aren't set (no unit, no bounds), and falls back to ``?`` if no
+        value type is populated. The status prefix reflects ``self.passed``.
+        """
+        status = "PASSED" if self.passed else "FAILED"
+        if self.numeric_value is not None:
+            value = f"{self.numeric_value}"
+            if self.unit:
+                value += f" {self.unit}"
+        elif self.string_value is not None:
+            value = repr(self.string_value)
+        elif self.boolean_value is not None:
+            value = str(self.boolean_value).lower()
+        else:
+            value = "?"
+        bounds = ""
+        nb = self.numeric_bounds
+        if nb is not None:
+            parts: list[str] = []
+            if nb.min is not None:
+                parts.append(f"min {nb.min}")
+            if nb.max is not None:
+                parts.append(f"max {nb.max}")
+            if parts:
+                bounds = f" ({', '.join(parts)})"
+        elif self.string_expected_value:
+            bounds = f" (expected {self.string_expected_value!r})"
+        return f"[{status}] {self.name} = {value}{bounds}"
+
     @classmethod
     def _from_proto(
         cls, proto: TestMeasurementProto, sift_client: SiftClient | None = None

sift_client/transport/base_connection.py

@@ -24,6 +24,7 @@ class SiftConnectionConfig:
         api_key: str,
         use_ssl: bool = True,
         cert_via_openssl: bool = False,
+        app_url: str | None = None,
     ):
         """Initialize the connection configuration.
 
@@ -33,12 +34,17 @@ class SiftConnectionConfig:
             api_key: The API key for authentication.
             use_ssl: Whether to use SSL/TLS for secure connections.
             cert_via_openssl: Whether to use OpenSSL for certificate validation.
+            app_url: The Sift web-app origin (e.g. ``https://app.siftstack.com``).
+                Set this for on-prem or custom deployments whose API host can't be
+                mapped to a frontend automatically. When unset, the web-app URL is
+                derived from ``rest_url`` for known hosts.
         """
         self.api_key = api_key
         self.grpc_url = grpc_url
         self.rest_url = rest_url
         self.use_ssl = use_ssl
         self.cert_via_openssl = cert_via_openssl
+        self.app_url = app_url
 
     def get_grpc_config(self):
         """Create and return a GrpcConfig with the current settings.

sift_client/util/test_results/context_manager.py

@@ -8,6 +8,7 @@ import subprocess
 import tempfile
 import traceback
 import warnings
+from collections import Counter
 from contextlib import AbstractContextManager, contextmanager
 from datetime import datetime, timezone
 from pathlib import Path
@@ -19,6 +20,7 @@ from sift_client.errors import SiftWarning
 from sift_client.sift_types.test_report import (
     ErrorInfo,
     NumericBounds,
+    TestMeasurement,
     TestMeasurementCreate,
     TestReport,
     TestReportCreate,
@@ -140,6 +142,19 @@ class ReportContext(AbstractContextManager):
     step_number_at_depth: dict[int, int]
     open_step_results: dict[str, bool]
     any_failures: bool
+    # Every step created in this report (including hierarchy/parametrize
+    # parents), retained after close so end-of-run summaries can tally final
+    # statuses. ``update`` mutates step instances in place, so these references
+    # reflect late status changes (e.g. a teardown-phase failure).
+    created_steps: list[TestStep]
+    # Every measurement recorded in this report, retained for end-of-run
+    # summaries. Appended in ``NewStep.measure``. A measurement's ``passed`` is
+    # fixed at creation, so the retained references stay accurate.
+    created_measurements: list[TestMeasurement]
+    # Set True in ``__exit__`` when the background replay worker timed out or
+    # exited non-zero, so callers (e.g. the pytest plugin footer) can flag that
+    # the uploaded report may be missing entries.
+    replay_incomplete: bool = False
     _import_proc: subprocess.Popen | None = None
     # Seconds to wait for the import worker subprocess to finish uploading
     # the JSONL backlog at session end before killing it. Tests substitute
@@ -184,6 +199,9 @@ class ReportContext(AbstractContextManager):
         self.step_number_at_depth = {}
         self.open_step_results = {}
         self.any_failures = False
+        self.created_steps = []
+        self.created_measurements = []
+        self.replay_incomplete = False
 
         if log_file is True:
             tmp = tempfile.NamedTemporaryFile(suffix=".jsonl", delete=False)
@@ -279,6 +297,7 @@ class ReportContext(AbstractContextManager):
             except subprocess.TimeoutExpired:
                 self._import_proc.kill()
                 self._import_proc.wait()
+                self.replay_incomplete = True
                 warnings.warn(
                     f"Sift import worker did not exit in "
                     f"{self._import_proc_timeout}s; killing it. "
@@ -289,6 +308,7 @@ class ReportContext(AbstractContextManager):
                 log_replay_instructions(self.log_file)
                 return True  # Ensures the session is marked as passed in pytest
             if self._import_proc.returncode != 0:
+                self.replay_incomplete = True
                 stderr_text = (
                     stderr_bytes.decode("utf-8", errors="replace").strip() if stderr_bytes else ""
                 )
@@ -311,6 +331,23 @@ class ReportContext(AbstractContextManager):
         """
         return self.report.is_simulated
 
+    @property
+    def step_status_counts(self) -> Counter[TestStatus]:
+        """Tally of every created step by its current status.
+
+        Includes hierarchy/parametrize parent steps. Read at the end of a run for
+        summaries; reflects late status changes since steps are mutated in place.
+        """
+        return Counter(step.status for step in self.created_steps)
+
+    @property
+    def measurement_counts(self) -> Counter[bool]:
+        """Tally of recorded measurements keyed by ``passed`` (True/False).
+
+        Read at the end of a run for summaries.
+        """
+        return Counter(m.passed for m in self.created_measurements)
+
     def new_step(
         self,
         name: str,
@@ -378,6 +415,8 @@ class ReportContext(AbstractContextManager):
         )
         self.step_stack.append(step)
         self.open_step_results[step.step_path] = True
+        # Retained for end-of-run tallies; never popped (unlike step_stack).
+        self.created_steps.append(step)
 
         return step
 
@@ -388,6 +427,10 @@ class ReportContext(AbstractContextManager):
             self.open_step_results[step.step_path] = False
             self.any_failures = True
 
+    def record_measurement(self, measurement: TestMeasurement) -> None:
+        """Retain a recorded measurement for end-of-run summaries."""
+        self.created_measurements.append(measurement)
+
     def mark_step_failed_after_close(self, step: TestStep):
         """Mark a step's parent as failed after the step has already been popped from the stack.
 
@@ -466,6 +509,9 @@ class NewStep(AbstractContextManager):
         # substep / ``report_outcome`` failures are intentionally not folded
         # in here (see ``measurements_passed`` vs ``passed``).
         self._failed_measurement_count = 0
+        # Out-of-bounds measurements recorded on this step, retained so
+        # ``fail_if_measurements_failed`` can name them in the failure message.
+        self._failed_measurements: list[TestMeasurement] = []
 
     def __enter__(self):
         """Enter the context manager to create a new step.
@@ -487,9 +533,7 @@ class NewStep(AbstractContextManager):
         """
         return self._failed_measurement_count == 0
 
-    def fail_if_measurements_failed(
-        self, message: str = "one or more measurements out of bounds"
-    ) -> None:
+    def fail_if_measurements_failed(self, message: str = "measurements out of bounds") -> None:
         """Fail the pytest test if any measurement on this step was out of bounds.
 
         Use instead of ``assert step.measurements_passed``: it fails via
@@ -497,12 +541,18 @@ class NewStep(AbstractContextManager):
         assertion message to ``error_info``. No-op when every measurement
         passed. Call once at the end of the test so every measurement is still
         recorded before the failure fires.
+
+        The failure message names each out-of-bounds measurement with its
+        recorded value and bounds. ``message`` is used as the header line.
         """
         if self.measurements_passed:
             return
         import pytest
 
-        pytest.fail(message, pytrace=False)
+        failed = self._failed_measurements
+        header = f"{message} ({len(failed)}):" if failed else message
+        body = [f"  - {m}" for m in failed]
+        pytest.fail("\n".join([header, *body]), pytrace=False)
 
     def update_step_from_result(
         self,
@@ -662,8 +712,10 @@ class NewStep(AbstractContextManager):
             create, log_file=self.report_context.log_file
         )
         self.report_context.record_step_outcome(measurement.passed, self.current_step)
+        self.report_context.record_measurement(measurement)
         if not measurement.passed:
             self._failed_measurement_count += 1
+            self._failed_measurements.append(measurement)
 
         return measurement.passed
 

{sift_stack_py-0.17.0.dev0.dist-info → sift_stack_py-0.17.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sift_stack_py
-Version: 0.17.0.dev0
+Version: 0.17.0.dev1
 Summary: Python client library for the Sift API
 Maintainer-email: Sift Software Engineers <engineering@siftstack.com>
 License: Copyright (c) 2024 Azimuth Industries Inc.

{sift_stack_py-0.17.0.dev0.dist-info → sift_stack_py-0.17.0.dev1.dist-info}/RECORD

@@ -330,20 +330,21 @@ sift/webhooks/v1/webhooks_pb2.pyi,sha256=nBxUmHlHRs4oBjiccaw_02e8voynjuvcAfBO98_
 sift/webhooks/v1/webhooks_pb2_grpc.py,sha256=AV2o51-Wabb6C6iTFZ7AQHqALi7ix2xfZeLuMON87FI,21905
 sift/webhooks/v1/webhooks_pb2_grpc.pyi,sha256=5Onwi3F0iuSlo1StR8FKI5TeaZlK3HGdViqXCjNd8hg,13061
 sift_client/__init__.py,sha256=BUYPbnSK-zM72XbCJVV2W7wQI9Q-ulmtuNLRvFoXLVE,3610
-sift_client/client.py,sha256=MtN3WGVmTPPqpi0Gp8ZRygzZSPGtB1M79LqDEBEEiUw,6732
+sift_client/client.py,sha256=4dej-vJgCRdpS2Hs-jY0BcTqzsgvxJdM_gKxST_GlNs,8221
 sift_client/config.py,sha256=cFZ4XtAlLIr-V91OUqMwMK2W5ZmyRW65_DU06fqoPUM,1008
 sift_client/errors.py,sha256=lwvdE53SnbJkKeWPRsuyjeLlYn7QFRHKOoE_SwJbYig,564
 sift_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sift_client/pytest_plugin.py,sha256=4A1Rq9Vr1TFtCPZC673f1SRSJ0b1rxgO-7CFg7sVBxU,45891
+sift_client/pytest_plugin.py,sha256=S2yafu5uaIVZoHxVpJkJmK6EFmwu9mlAiGTgf6e7foc,59255
 sift_client/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sift_client/_internal/gen_pyi.py,sha256=VQzcHMGAO8hzQiQ0twlxTDnex3QQLpe0ctitYSXorUU,10270
-sift_client/_internal/rest.py,sha256=fglfy_I8MwjIdPjyc_oygCSkz8GuWX0y8vGTgPdm4e0,2867
+sift_client/_internal/rest.py,sha256=L4f1k3IounQhzBRWa_2XuzSnkWvimYowwpczx3r1PXU,2838
 sift_client/_internal/sync_wrapper.py,sha256=H6zeFLPf5CczHC44KSBjM6Lge8KbV2dOS2qWRYCTNoE,5273
 sift_client/_internal/time.py,sha256=gt7I4IS8xqLBFwGBkSBeN4DohKIIOPEArCeH1YcYUe4,1492
+sift_client/_internal/urls.py,sha256=zxezIhdQsGs3dL0MRi2w9fhBsLkAKVIbcJBItxRIJvY,2136
 sift_client/_internal/grpc_transport/__init__.py,sha256=9reBbl6u_h9hoFCq6nNkQmxH5ce-8JA2s1iKpNl7_0g,506
 sift_client/_internal/grpc_transport/_retry.py,sha256=EMLJcrM_VSLz5zVQPMaMzRQBRMmTLzfxSm-X_JCZB18,2378
 sift_client/_internal/grpc_transport/keepalive.py,sha256=EfSo4Go9VnSB7cnv7f9FK2__6su1XoJlaAgEj-NEUF8,1036
-sift_client/_internal/grpc_transport/transport.py,sha256=wcpAqh67E1xxjJ_jsv0kSu4ZUDK_l5DZudRJ9Y8ZXU4,9363
+sift_client/_internal/grpc_transport/transport.py,sha256=mo69nu_JnbV4l6dEHWmBKNwWaSDvE_eqxQnRjSKkLfw,8837
 sift_client/_internal/grpc_transport/transport_test.py,sha256=6RLBcoSwFjYNJ2ZVfZbdsO9cFCb44vairaaK_o49N-k,7452
 sift_client/_internal/grpc_transport/_async_interceptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sift_client/_internal/grpc_transport/_async_interceptors/base.py,sha256=wicPGrT7XJDgxIur0cr0soISOBi_vzCwXIJv8_mVogs,2475
@@ -418,12 +419,12 @@ sift_client/sift_types/report.py,sha256=0YoKR6tHao20hLKvTb78n7vR1Rpu-lF8H4vFP7SM
 sift_client/sift_types/rule.py,sha256=pS6FSBFZIB9SHorpMm60AA7nKvOjVGv7BPYcyXEeNbU,13660
 sift_client/sift_types/run.py,sha256=LqTO4Jo_05bJ54aGVI9RNkZcZTKKM6bha6c7ZCHGP18,8668
 sift_client/sift_types/tag.py,sha256=yos_iqG63iI8rx6JWfr7SbUZ-6Y1Co1Lv44zgrsApyU,2111
-sift_client/sift_types/test_report.py,sha256=wdMUzS1tnG4dSTbpcUmAR_Q0i2llKOyY-OestqeNsjY,24958
+sift_client/sift_types/test_report.py,sha256=HYTlNrfLodLst-6Nll0Zpyi8AfeUHMZL9j3X0AUa-4E,26260
 sift_client/sift_types/_mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sift_client/sift_types/_mixins/file_attachments.py,sha256=QRXgKjZH6ONymwoc9SKftmoFN6oOwHVLynAqwz8Yzh4,3539
 sift_client/sift_types/_mixins/simulated.py,sha256=w93DOF_WYTBXgTGmskRftiMY1JvvYBx3ALPtKjxWhUQ,1289
 sift_client/transport/__init__.py,sha256=YQFaoQ24FZlLVRAstYCgSWkS64qkcd6J-RRwPL0Ds9A,423
-sift_client/transport/base_connection.py,sha256=_6LjtsLRplhG_SC3ORnBGNI_i1VqEKivtB09QdzFOpU,3149
+sift_client/transport/base_connection.py,sha256=bXBPK7B0hPKJEw6abhGDroswdQCaORSU-zz22HGUP60,3524
 sift_client/transport/grpc_transport.py,sha256=0YV4nfwaRfsbKjHbPhHd8jCl4wnbGIvhOMH-93sGTO4,6906
 sift_client/transport/rest_transport.py,sha256=PFh_n7wJyrRqnMJEsBx2gi4kUrShzEwwdDZKXz4tzsY,6320
 sift_client/util/__init__.py,sha256=u0EeqAVhIPdKpijEaYVNXPK8moS-G20ConTyrgaYtEw,51
@@ -432,7 +433,7 @@ sift_client/util/metadata.py,sha256=E9OC-3VKOhrLjggEO1WYnATNeJq_84CRyXCLmbAp5Vc,
 sift_client/util/util.py,sha256=kpqIb2oWtbU7OM0Y7PoFHVcP4FY0mF2sU55ji3NMzBs,2271
 sift_client/util/test_results/__init__.py,sha256=8nviro4Jl3D3jhtARZYbkxGyxqn4F7VdmWU5dkyYGUc,5797
 sift_client/util/test_results/bounds.py,sha256=0AGa83cE9sLmVuEEXvZhJLzbMor9CHKHEwaet0ejOng,5304
-sift_client/util/test_results/context_manager.py,sha256=FJWbTtVUf8mLfE0K_9WRBF8rAPfoVYyn44qUaJm4_3w,32931
+sift_client/util/test_results/context_manager.py,sha256=hYRSk73xdX6Ny6o3uVGugrz32Zgr0urRCDFmjYMfg_Q,35624
 sift_py/__init__.py,sha256=KyccGwcwQmcEHnuwMVZPT6AW6hSHCYSCvYPQYrfSSMs,31393
 sift_py/_rest_test.py,sha256=hdPD17XoJTd0mrB_q8-IiiwTWKZu-Bn2EPj0KfSUbmc,2251
 sift_py/error.py,sha256=YKH8QSIQQXeQAuuzxGuA4LLvn_NsVd-8mx2lGfCQAII,1386
@@ -563,9 +564,9 @@ sift_py/yaml/channel.py,sha256=fH4qy8qMOSpcov11Zf5g2golwUUJg1hTGTe5SWp13KM,6933
 sift_py/yaml/report_templates.py,sha256=ytaLHeCgDptmVadWS_aWL3XASn24mMz11b47gQwCiQY,2702
 sift_py/yaml/rule.py,sha256=BqJ-akCv-m05pJ1mX5D1cQiSdXhb_v3utt0gf68jYrY,12229
 sift_py/yaml/utils.py,sha256=s8SHkvEJDi24wNYVaEeZtk_ziyTUPMQI-s45fcZtx5M,3158
-sift_stack_py-0.17.0.dev0.dist-info/LICENSE,sha256=0wD7kHbRuEKXASAN5pEXM6LZAGebonVWcOSaY-kW_W8,1067
-sift_stack_py-0.17.0.dev0.dist-info/METADATA,sha256=hK1LA4SndgXxuXx8czC3AdsoqHIHWIInHaYdD_h8P4c,10436
-sift_stack_py-0.17.0.dev0.dist-info/WHEEL,sha256=BNRMDyzLkkcmlv0J8ppDQkk2VED33SesJDynr9ED1gc,91
-sift_stack_py-0.17.0.dev0.dist-info/entry_points.txt,sha256=0xoXN-qOSR2WmKV_zYQ6SUF2PhdBAyRvdV11GbsC0sY,91
-sift_stack_py-0.17.0.dev0.dist-info/top_level.txt,sha256=bUvXP5rbzCmAZs1nmollLqDEJK9xLChtWvcF0YHTjFE,25
-sift_stack_py-0.17.0.dev0.dist-info/RECORD,,
+sift_stack_py-0.17.0.dev1.dist-info/LICENSE,sha256=0wD7kHbRuEKXASAN5pEXM6LZAGebonVWcOSaY-kW_W8,1067
+sift_stack_py-0.17.0.dev1.dist-info/METADATA,sha256=vJbJQ_XA4wwE7iCg802HpYbt31468xwM5VitGWcakIc,10436
+sift_stack_py-0.17.0.dev1.dist-info/WHEEL,sha256=BNRMDyzLkkcmlv0J8ppDQkk2VED33SesJDynr9ED1gc,91
+sift_stack_py-0.17.0.dev1.dist-info/entry_points.txt,sha256=0xoXN-qOSR2WmKV_zYQ6SUF2PhdBAyRvdV11GbsC0sY,91
+sift_stack_py-0.17.0.dev1.dist-info/top_level.txt,sha256=bUvXP5rbzCmAZs1nmollLqDEJK9xLChtWvcF0YHTjFE,25
+sift_stack_py-0.17.0.dev1.dist-info/RECORD,,