sift-stack-py 0.17.0.dev0__tar.gz → 0.17.0.dev1__tar.gz

{sift_stack_py-0.17.0.dev0 → sift_stack_py-0.17.0.dev1}/PKG-INFO

@@ -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 → sift_stack_py-0.17.0.dev1}/lib/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_stack_py-0.17.0.dev0 → sift_stack_py-0.17.0.dev1}/lib/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_stack_py-0.17.0.dev1/lib/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_stack_py-0.17.0.dev0 → sift_stack_py-0.17.0.dev1}/lib/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_stack_py-0.17.0.dev0 → sift_stack_py-0.17.0.dev1}/lib/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_stack_py-0.17.0.dev0 → sift_stack_py-0.17.0.dev1}/lib/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_stack_py-0.17.0.dev0 → sift_stack_py-0.17.0.dev1}/lib/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.