add offline mode and noop sibling plugin

Adds --sift-test-results-offline (and matching ini key) to route every
create/update through the JSONL log file without contacting Sift. Skips
the session-start ping, skips the import worker subprocess, and
tolerates missing SIFT_API_KEY / SIFT_GRPC_URI / SIFT_REST_URI by
filling placeholders. Offline + log_file=false is rejected as a usage
error since the log file is the sole sink.

Adds sift_client.pytest_plugin_noop as a sibling plugin: matching
fixture names and method signatures, but measure* calls evaluate bounds
locally via the new value_passes_bounds() helper and nothing reaches
Sift. Useful when test code should keep working without any Sift
configuration at all.

ReportContext gains an offline=True parameter that suppresses the
import worker. Test suite conftest now picks the mode based on the
marker expression and presence of env vars: integration runs with a
real backend stay online with the log file disabled; everything else
forces offline.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: alexluck-sift

python/docs/examples/pytest_plugin.md

@@ -97,6 +97,7 @@ def sift_client() -> SiftClient:
 | `--sift-test-results-log-file=<path\|true\|false>` | temp file | Where the JSONL log of create/update calls goes. With a log file set, the plugin spawns an `import-test-result-log --incremental` worker that polls the file and replays entries against Sift while the run is in flight. Pass `false` to disable the file entirely; create/update calls then go straight to the API synchronously during tests. |
 | `--no-sift-test-results-git-metadata` | git metadata on | Skip capturing git repo/branch/commit on the report's metadata. |
 | `--sift-test-results-check-connection` | off | Make `report_context`, `step`, and `module_substep` no-op (yield `None`) when `client_has_connection` is `False`. Lets the same suite run locally without a Sift backend. |
+| `--sift-test-results-offline` | off | Route the run entirely through the JSONL log file without contacting Sift. The session-start ping is skipped, the import worker is not spawned, and the file is the sole sink. Replay it later with `import-test-result-log`. Incompatible with `--sift-test-results-log-file=false`. |
 
 These can be passed permanently via `addopts`:
 
@@ -115,6 +116,7 @@ CLI flags, when passed, override the ini values.
 | `sift_test_results_log_file` | string (`true` / `false` / `none` / path) | `--sift-test-results-log-file=<value>` |
 | `sift_test_results_git_metadata` | bool (default `true`) | `--no-sift-test-results-git-metadata` (sets to `false`) |
 | `sift_test_results_check_connection` | bool (default `false`) | `--sift-test-results-check-connection` |
+| `sift_test_results_offline` | bool (default `false`) | `--sift-test-results-offline` |
 
 The default `sift_client` fixture reads its two URIs from environment first
 and falls back to ini keys when the env vars are unset. `SIFT_API_KEY` is
@@ -620,19 +622,21 @@ without a reachable Sift server.
 
 ## Running offline
 
-The plugin supports two offline workflows, depending on whether you want a
-Sift report at all when the test environment can't reach Sift. The first
-turns the plugin into a no-op when the server is unreachable. The second
-keeps the plugin running normally and writes every create/update to a local
-JSONL file that you upload from a connected machine afterward.
+The plugin supports three offline workflows, depending on whether you want a
+Sift report at all when the test environment can't reach Sift, and whether
+you want the plugin to make any attempt to contact Sift.
 
 | Pattern | Flag | Runtime behavior | Follow-up |
 |---|---|---|---|
 | Skip when offline | `--sift-test-results-check-connection` | Fixtures yield `None`, no log file, no report. Pytest still reports pass/fail. | None. |
-| Capture locally, upload later | `--sift-test-results-log-file=<path>` | Plugin writes every create/update to the JSONL file. | `import-test-result-log <path>` from a connected machine. |
+| Explicit offline | `--sift-test-results-offline` | Plugin never contacts Sift; every create/update goes to a JSONL log file. No session-start ping, no import worker. | `import-test-result-log <path>` from a connected machine. |
+| Capture locally, upload later | `--sift-test-results-log-file=<path>` | Plugin runs in online mode but the worker subprocess dies on connect, leaving the JSONL file on disk. | `import-test-result-log <path>` from a connected machine. |
 
 Pattern 1 suits laptop dev and CI without Sift secrets. Pattern 2 suits
-field tests, vehicles on remote sites, and air-gapped labs.
+field tests, vehicles on remote sites, and air-gapped labs where you've
+decided up front that there is no Sift connection. Pattern 3 suits sites
+that *might* have a connection — let the run try, and pick up the log file
+if it doesn't.
 
 ### Pattern 1: skip when offline
 
@@ -716,14 +720,46 @@ def client_has_connection(sift_client) -> bool:
 The plugin only consults this fixture when `--sift-test-results-check-connection`
 is set, so an unused override has no effect on a normal run.
 
-### Pattern 2: capture locally, upload later
+### Pattern 2: explicit offline mode
+
+`--sift-test-results-offline` (or `sift_test_results_offline = true` in
+`pyproject.toml`) tells the plugin not to contact Sift at all. Every
+create/update is written to a JSONL log file; the session-start ping is
+skipped and the import worker subprocess is not spawned. Missing
+`SIFT_API_KEY` / `SIFT_GRPC_URI` / `SIFT_REST_URI` env vars are tolerated
+in this mode since no connection is attempted.
+
+```bash
+pytest --sift-test-results-offline --sift-test-results-log-file=./run.jsonl
+```
+
+```ini title="pytest.ini"
+[pytest]
+addopts = --sift-test-results-offline
+```
+
+Once you have connectivity, replay the file:
+
+```bash
+import-test-result-log ./run.jsonl
+```
+
+`--sift-test-results-offline` requires a log file (it's the only sink), so
+combining it with `sift_test_results_log_file = "false"` is a usage error.
+Pin the log path with `--sift-test-results-log-file=<path>` so the file is
+easy to find; otherwise the plugin creates a temp file and surfaces the
+path via a `logger.info` line at session start.
+
+### Pattern 3: capture locally, upload later
 
 This pattern keeps the plugin running normally even when Sift is
 unreachable. The plugin writes to the log file, the worker dies on connect,
 and the file is left on disk for you to upload later. Pin the log file path
 so you can find it afterward, and don't pass
 `--sift-test-results-check-connection`, which would suppress the logging
-this pattern relies on.
+this pattern relies on. Prefer Pattern 2 (`--sift-test-results-offline`)
+when you've decided in advance that the run is offline; this pattern is for
+the case where the run *might* connect.
 
 ```bash
 pytest --sift-test-results-log-file=./run.jsonl
@@ -752,12 +788,37 @@ The replay creates the report, steps, and measurements against Sift in one
 batch. See [Replaying a saved log file](#replaying-a-saved-log-file) for
 details on cleanup and the incremental flag.
 
-!!! warning "Pin the log path for Pattern 2"
+!!! warning "Pin the log path for Pattern 3"
     Without `--sift-test-results-log-file=<path>`, the plugin writes to a
     `tempfile.NamedTemporaryFile` and only surfaces the path via a
     `logger.info` line. Always pin a known path when you intend to replay
     the file later.
 
+## Running without the plugin: `pytest_plugin_noop`
+
+When you want test code that calls `step.measure(...)`, `step.substep(...)`,
+etc. to keep working without any Sift configuration, wire in
+`sift_client.pytest_plugin_noop` instead of the real plugin. It ships
+matching fixture names; `measure*` calls evaluate bounds locally and return
+the real pass/fail boolean, but nothing is sent to Sift and no log file is
+written.
+
+```python title="conftest.py"
+import os
+
+pytest_plugins = [
+    "sift_client.pytest_plugin"
+    if os.getenv("SIFT_ENABLED")
+    else "sift_client.pytest_plugin_noop"
+]
+```
+
+The no-op plugin doesn't read `SIFT_API_KEY` / `SIFT_GRPC_URI` /
+`SIFT_REST_URI` and never constructs a `SiftClient`, so it's safe to load in
+environments that aren't allowed to talk to Sift at all. Use it instead of
+Pattern 1 when you'd rather have tests pass through silently than `None`-guard
+every `step` call site.
+
 ## Replaying a saved log file
 
 When the worker doesn't finish cleanly the plugin will print a hint mentioning

python/lib/sift_client/_tests/conftest.py

@@ -79,5 +79,17 @@ def ci_pytest_tag(sift_client):
 
 
 def pytest_configure(config: pytest.Config) -> None:
-    """Enable the Sift connection-check mode for the fixtures used in this test suite since we run w/ mock client in non-integration tests."""
-    config.option.sift_test_results_check_connection = True
+    """Pick a plugin mode based on whether integration tests are being run.
+
+    Integration runs targeting a real backend stay online with the log file
+    disabled (writes go inline). Otherwise force offline mode so the autouse
+    plugin fixtures construct cleanly without contacting Sift.
+    """
+    is_integration_run = "integration" in (config.option.markexpr or "")
+    have_real_backend = all(
+        os.getenv(name) for name in ("SIFT_API_KEY", "SIFT_GRPC_URI", "SIFT_REST_URI")
+    )
+    if is_integration_run and have_real_backend:
+        config.option.sift_test_results_log_file = "false"
+    else:
+        config.option.sift_test_results_offline = True

python/lib/sift_client/_tests/test_pytest_plugin.py

@@ -216,10 +216,12 @@ def test_defaults_when_neither_set(self, pytester: pytest.Pytester) -> None:
             """
             from sift_client.pytest_plugin import (
                 _check_connection_enabled,
+                _offline_enabled,
                 _resolve_log_file,
             )
             print("RESOLVED:", _resolve_log_file(config))
             print("CHECK:", _check_connection_enabled(config))
+            print("OFFLINE:", _offline_enabled(config))
             print("INI_GIT:", config.getini("sift_test_results_git_metadata"))
             """,
         )
@@ -229,6 +231,111 @@ def test_defaults_when_neither_set(self, pytester: pytest.Pytester) -> None:
             [
                 "RESOLVED: True",
                 "CHECK: False",
+                "OFFLINE: False",
                 "INI_GIT: True",
             ]
         )
+
+
+class TestOfflineMode:
+    """``--sift-test-results-offline`` routes the run through the JSONL log file."""
+
+    def test_offline_runs_without_env_vars(
+        self, pytester: pytest.Pytester, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Offline mode tolerates missing env vars: placeholders are filled in."""
+        for name in ("SIFT_API_KEY", "SIFT_GRPC_URI", "SIFT_REST_URI"):
+            monkeypatch.delenv(name, raising=False)
+        _plugin_conftest(pytester)
+        pytester.makepyfile(
+            """
+            def test_in_bounds(step):
+                assert step.measure(name="v", value=5.0, bounds={"min": 4.8, "max": 5.2})
+
+            def test_out_of_bounds(step):
+                assert step.measure(name="v", value=10.0, bounds={"max": 5.2}) is False
+            """
+        )
+        result = pytester.runpytest("--sift-test-results-offline")
+        result.assert_outcomes(passed=2)
+
+    def test_offline_via_ini(
+        self, pytester: pytest.Pytester, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """The ``sift_test_results_offline`` ini key enables offline mode."""
+        for name in ("SIFT_API_KEY", "SIFT_GRPC_URI", "SIFT_REST_URI"):
+            monkeypatch.delenv(name, raising=False)
+        _plugin_conftest(pytester)
+        pytester.makepyprojecttoml(
+            """
+            [tool.pytest.ini_options]
+            sift_test_results_offline = true
+            """
+        )
+        pytester.makepyfile("def test_runs(step): step.measure(name='v', value=1.0)")
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+
+    def test_offline_with_log_file_false_is_rejected(self, pytester: pytest.Pytester) -> None:
+        """Offline mode + log_file disabled is a usage error (log file is the sink)."""
+        _plugin_conftest(pytester)
+        pytester.makepyprojecttoml(
+            """
+            [tool.pytest.ini_options]
+            sift_test_results_offline = true
+            sift_test_results_log_file = "false"
+            """
+        )
+        pytester.makepyfile("def test_should_not_run(): pass")
+        result = pytester.runpytest()
+        assert result.ret != 0
+        combined = "\n".join(result.outlines + result.errlines)
+        assert "incompatible" in combined, combined
+
+
+class TestNoopPlugin:
+    """The no-op sibling plugin keeps test code working without Sift configuration."""
+
+    def test_in_bounds_passes_out_of_bounds_fails(self, pytester: pytest.Pytester) -> None:
+        """Shim measure* evaluates bounds locally; pass/fail matches the real plugin."""
+        pytester.makeconftest('pytest_plugins = ["sift_client.pytest_plugin_noop"]')
+        pytester.makepyfile(
+            """
+            def test_passes_in_bounds(step):
+                assert step.measure(name="v", value=5.0, bounds={"min": 4.8, "max": 5.2})
+
+            def test_fails_out_of_bounds(step):
+                assert step.measure(name="v", value=99.0, bounds={"max": 5.2}) is False
+
+            def test_substep_and_report_outcome(step):
+                with step.substep(name="inner") as inner:
+                    assert inner.report_outcome(name="ok", result=True) is True
+
+            def test_string_bounds(step):
+                assert step.measure(name="fw", value="1.0", bounds="1.0") is True
+                assert step.measure(name="fw", value="1.0", bounds="2.0") is False
+
+            def test_measure_avg(step):
+                assert step.measure_avg(
+                    name="bus", values=[4.97, 5.01, 5.03], bounds={"min": 4.9, "max": 5.1}
+                ) is True
+
+            def test_measure_all_outlier(step):
+                assert step.measure_all(
+                    name="p", values=[10.1, 10.2, 99.9], bounds={"max": 11.0}
+                ) is False
+            """
+        )
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=6)
+
+    def test_noop_does_not_require_credentials(
+        self, pytester: pytest.Pytester, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """The noop plugin never reads SIFT_* env vars; runs cleanly without them."""
+        for name in ("SIFT_API_KEY", "SIFT_GRPC_URI", "SIFT_REST_URI"):
+            monkeypatch.delenv(name, raising=False)
+        pytester.makeconftest('pytest_plugins = ["sift_client.pytest_plugin_noop"]')
+        pytester.makepyfile("def test_runs(step): step.measure(name='v', value=1.0)")
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)

python/lib/sift_client/_tests/util/conftest.py

@@ -1,6 +1,3 @@
-import pytest
-
-
-def pytest_configure(config: pytest.Config) -> None:
-    """Configure the pytest configuration to disable the Sift test results log file."""
-    config.option.sift_test_results_log_file = False
+# Plugin mode (offline vs online, log-file disable) is set by the parent
+# conftest based on the marker expression and env vars. No util-specific
+# overrides are needed.