dsh-labscript 0.2.7 → 0.3.0

package/python/bridge.py

@@ -114,6 +114,23 @@ def shot_executed(path):
     except Exception:
         return None
 
+
+def executed_prefix(shots):
+    """How many shot h5 files already hold acquisition data (binary search).
+
+    labscript compiles and submits shots in file order, so executed shots are a prefix
+    of the sorted file list. Opening a handful of files keeps this cheap even when the
+    run folder is a network share.
+    """
+    low, high = 0, len(shots)
+    while low < high:
+        middle = (low + high) // 2
+        if shot_executed(shots[middle]) is True:
+            low = middle + 1
+        else:
+            high = middle
+    return low
+
 # ---------------------------------------------------------------- scan expr
 
 _ALLOWED_CALLS = {"arange", "linspace", "array", "logspace"}
@@ -194,6 +211,28 @@ def eval_panel_value(raw):
         return str(raw)
 
 
+def axis_length(value):
+    """Length of the axis runmanager expands from this global, or None.
+
+    Heuristic: runmanager's automatic expansion turns list/array globals into axes
+    ("outer") and passes tuples through whole, so a tuple is not an axis. Expansion
+    settings (none / zip group) are not visible from runmanager.remote, so a list that
+    was switched to "none" still looks like an axis here. The panel's n_shots is the
+    authoritative shot count; this is only a hint.
+    """
+    if isinstance(value, (str, bytes, dict, tuple)):
+        return None
+    if not hasattr(value, "__len__"):
+        return None
+    ndim = getattr(value, "ndim", None)
+    if ndim is not None:
+        return int(value.size) if ndim >= 1 else None
+    try:
+        return int(len(value))
+    except Exception:
+        return None
+
+
 def raw_repr(value):
     if isinstance(value, bool):
         return "True" if value else "False"
@@ -280,18 +319,39 @@ class LabscriptBackend(object):
             from runmanager.remote import Client
         except Exception as exc:
             raise BridgeError("BACKEND_UNAVAILABLE", "labscript python environment not importable: " + str(exc))
+        # Anything left unset is resolved by runmanager.remote.Client from labscript's
+        # labconfig ([servers] runmanager, [ports] runmanager, [timeouts]
+        # communication_timeout), the same way the runmanager GUI does it. Explicit
+        # config always wins.
         rm = self.config.get("runmanager") or {}
-        host = rm.get("host") or "127.0.0.1"
-        port = int(rm.get("port") or 42523)
-        timeout = float(rm.get("timeoutS") or 10)
+        kwargs = {}
+        if rm.get("host"):
+            kwargs["host"] = rm["host"]
+        if rm.get("port"):
+            kwargs["port"] = int(rm["port"])
+        if rm.get("timeoutS"):
+            kwargs["timeout"] = float(rm["timeoutS"])
+        try:
+            client = Client(**kwargs)
+        except Exception as exc:
+            raise BridgeError("BACKEND_UNAVAILABLE", "cannot create a runmanager client: " + type(exc).__name__ + ": " + str(exc))
         try:
-            client = Client(host=host, port=port, timeout=timeout)
             client.say_hello()
         except Exception as exc:
-            raise BridgeError("BACKEND_UNAVAILABLE", "runmanager not reachable at " + host + ":" + str(port) + ": " + str(exc))
+            raise BridgeError("BACKEND_UNAVAILABLE", "runmanager not reachable at " + str(getattr(client, "host", "?")) + ":" + str(getattr(client, "port", "?")) + ": " + str(exc))
         self._client = client
         return client
 
+    def endpoint(self):
+        """Where this client points, and whether the values came from config or labconfig."""
+        rm = self.config.get("runmanager") or {}
+        source = "config" if (rm.get("host") or rm.get("port")) else "labconfig"
+        try:
+            client = self.client()
+            return str(client.host) + ":" + str(client.port) + " (" + source + ", timeout " + str(client.timeout) + "s)"
+        except Exception as exc:
+            return "<unknown> (" + source + "): " + str(exc)
+
     def version(self):
         try:
             return str(self.client().get_version())
@@ -302,7 +362,11 @@ class LabscriptBackend(object):
         return dict(self.client().get_globals(raw=raw))
 
     def set_globals(self, values, raw=False):
-        return dict(self.client().set_globals(values, raw=raw))
+        # runmanager's set_globals is a side-effect RPC: its handler returns None, so
+        # never feed the reply to dict(). Report what was requested; the caller reads
+        # the panel back to verify.
+        written = self.client().set_globals(values, raw=raw)
+        return dict(written) if isinstance(written, dict) else dict(values)
 
     def n_shots(self):
         return int(self.client().n_shots())
@@ -316,6 +380,13 @@ class LabscriptBackend(object):
         except Exception:
             return None
 
+    def shuffle(self):
+        # Older runmanager versions have no get_shuffle; report unknown instead of failing.
+        try:
+            return bool(self.client().get_shuffle())
+        except Exception:
+            return None
+
     def labscript_file(self):
         try:
             return self.client().get_labscript_file()
@@ -394,7 +465,9 @@ class MockBackend(object):
         panel = self.read_panel()
         if raw:
             return dict(panel)
-        return dict((k, jsonable(eval_panel_value(v))) for k, v in panel.items())
+        # Keep Python types (tuple vs list matters to the expansion rules); callers
+        # jsonable() values before they leave the bridge.
+        return dict((k, eval_panel_value(v)) for k, v in panel.items())
 
     def set_globals(self, values, raw=False):
         panel = self.read_panel()
@@ -404,17 +477,21 @@ class MockBackend(object):
         return dict((k, panel[k]) for k in values)
 
     def n_shots(self):
-        import numpy as np
         total = 1
         for value in self.get_globals(raw=False).values():
-            arr = np.asarray(value) if hasattr(value, "__len__") and not isinstance(value, str) else None
-            if arr is None or arr.ndim == 0:
+            length = axis_length(value)
+            if length is None or length <= 0:
                 continue
-            total *= max(1, int(arr.size))
+            total *= length
         return int(total)
 
     def error_in_globals(self):
-        return False
+        # Simulator switch: mock.errorInGlobals makes the mock panel report an evaluation
+        # error, so the GLOBALS_ERROR refusal path can be tested without real hardware.
+        return bool((self.config.get("mock") or {}).get("errorInGlobals"))
+
+    def shuffle(self):
+        return bool((self.config.get("mock") or {}).get("shuffle"))
 
     def run_shots(self):
         return True
@@ -431,11 +508,8 @@ class MockBackend(object):
         values = self.get_globals(raw=False)
         arrays = {}
         for key, value in values.items():
-            if isinstance(value, str):
-                continue
-            arr = np.asarray(value)
-            if arr.ndim >= 1 and arr.size > 1:
-                arrays[key] = arr
+            if (axis_length(value) or 0) > 1:
+                arrays[key] = np.asarray(value).ravel()
         total = 1
         for arr in arrays.values():
             total *= int(arr.size)
@@ -544,6 +618,10 @@ class HttpSimBackend(object):
     def run_shots(self):
         return True
 
+    def shuffle(self):
+        snap = self.snapshot()
+        return bool(snap.get("shuffle")) if "shuffle" in snap else None
+
     def labscript_file(self):
         return self.snapshot().get("labscript_file")
 
@@ -927,13 +1005,8 @@ def cmd_status(config, args):
     scan_axes = {}
     n_shots_from_arrays = 1
     for name, value in panel_values.items():
-        if isinstance(value, str) or not hasattr(value, "__len__"):
-            continue
-        try:
-            size = int(len(value))
-        except Exception:
-            continue
-        if size <= 1:
+        size = axis_length(value)
+        if size is None or size <= 1:
             continue
         scan_axes[str(name)] = size
         n_shots_from_arrays *= size
@@ -952,6 +1025,7 @@ def cmd_status(config, args):
         "n_shots": backend.n_shots(),
         "error_in_globals": backend.error_in_globals(),
         "run_shots": backend.run_shots(),
+        "shuffle": backend.shuffle() if hasattr(backend, "shuffle") else None,
         "panel_history": panel_history_info(config),
     }
     if raw:
@@ -988,21 +1062,25 @@ def cmd_set(config, args):
     snap = snapshot_panel(backend, config, "set", {"keys": sorted(values.keys()), "raw": raw, "note": args.get("note")}, touched=values.keys())
     try:
         written = backend.set_globals(values, raw=raw)
-    except BridgeError as exc:
-        detail = dict(exc.detail or {})
-        detail["snapshot"] = snap
-        detail["hint"] = "set_globals failed after the panel snapshot; the panel may be partially written. Use labs_restore to undo."
-        raise BridgeError(exc.code, exc.message, detail)
     except Exception as exc:
-        raise BridgeError("SET_FAILED", "set_globals failed: " + type(exc).__name__ + ": " + str(exc), {
-            "snapshot": snap,
-            "hint": "the panel may be partially written; use labs_restore to undo",
-        })
+        detail = dict(getattr(exc, "detail", None) or {})
+        detail["snapshot"] = snap
+        # A failed write can still have landed (runmanager writes each key in turn),
+        # so report what the panel holds now instead of guessing in the hint.
+        try:
+            now = backend.get_globals(raw=True)
+            detail["landed"] = dict((k, jsonable(now.get(k))) for k in values)
+        except Exception:
+            pass
+        detail["hint"] = "the write may have landed partially or not at all: read the keys back with labs_status before retrying, and only labs_restore if they are wrong"
+        raise BridgeError(getattr(exc, "code", None) or "SET_FAILED", "set_globals failed: " + type(exc).__name__ + ": " + str(exc), detail)
     readback = backend.get_globals(raw=False)
     raw_readback = backend.get_globals(raw=True)
     missing = [k for k in values if k not in readback]
     out = {
-        "written": jsonable(written),
+        # Report what was asked for even if a backend returns something else (runmanager's
+        # RPC returns nothing); the readback below carries the truth from the panel.
+        "written": jsonable(written) if isinstance(written, dict) else dict((k, jsonable(v)) for k, v in values.items()),
         "readback": dict((k, jsonable(readback.get(k))) for k in values),
         "raw_readback": dict((k, jsonable(raw_readback.get(k))) for k in values),
         "missing": missing,
@@ -1050,24 +1128,31 @@ def wait_for_run(config, run_folder, expected, timeout_s):
     poll = float(engage_cfg.get("pollS") or 1.0)
     settle = float(engage_cfg.get("settleS") or 2.0)
     stall = float(engage_cfg.get("stallS") or 20.0)
+    # labscript writes each shot h5 before compiling it, so a healthy compilation keeps
+    # adding files. When nothing has appeared for this long the compile almost certainly
+    # aborted; returning a diagnosis beats blocking for the full timeout_s.
+    no_shot = float(engage_cfg.get("noShotS") or 25.0)
+    want = int(expected or 0)
     start = time.time()
+    last_progress = start
     stable_since = None
     compiled_since = None
     last_count = -1
     last_size = -1
-    last_executed = None
+    shots = []
 
-    def result(complete, timed_out, diagnosis, count, executed, elapsed, hint=None):
+    def result(complete, timed_out, diagnosis, elapsed, hint=None):
         payload = {
             "run_folder": run_folder,
             "mapped_run_folder": folder,
             "folder_exists": os.path.isdir(folder),
             "expected_n_shots": expected,
-            "n_h5": count,
+            "n_h5": len(shots),
+            "n_executed": executed_prefix(shots),
             "complete": complete,
             "timed_out": timed_out,
             "diagnosis": diagnosis,
-            "executed": executed,
+            "executed": shot_executed(shots[-1]) if shots else None,
             "elapsed": round(elapsed, 1),
         }
         if hint:
@@ -1078,8 +1163,10 @@ def wait_for_run(config, run_folder, expected, timeout_s):
         shots = sorted(glob.glob(os.path.join(folder, "**", "*.h5"), recursive=True))
         count = len(shots)
         total = sum(os.path.getsize(p) for p in shots) if shots else 0
+        if count != last_count or total != last_size:
+            last_progress = time.time()
         ready = False
-        if count >= (expected or 0) and count == last_count and total == last_size and shots:
+        if count >= (want or 0) and count == last_count and total == last_size and shots:
             ready = shot_ready(shots[-1])
         executed = None
         if ready:
@@ -1089,7 +1176,12 @@ def wait_for_run(config, run_folder, expected, timeout_s):
             if stable_since is None:
                 stable_since = time.time()
             elif time.time() - stable_since >= settle:
-                return result(True, False, "complete", count, True, time.time() - start)
+                hint = None
+                if want and len(shots) != want:
+                    hint = ("finished with " + str(len(shots)) + " shot files for expected_n_shots=" + str(want) +
+                            ": the panel's n_shots changed after submit, or shots were re-run (BLACS Repeat all / "
+                            "Repeat last re-executes existing shot files and does not create new ones).")
+                return result(True, False, "complete", time.time() - start, hint)
         else:
             stable_since = None
             if ready and executed is False:
@@ -1097,28 +1189,45 @@ def wait_for_run(config, run_folder, expected, timeout_s):
                     compiled_since = time.time()
                 elif time.time() - compiled_since >= stall:
                     return result(
-                        False, False, "compiled_not_executed", count, False, time.time() - start,
-                        "shots were compiled but show no acquisition data after " + str(int(stall)) +
-                        " s: BLACS may be paused / the queue may not be running, or the run is still being programmed. Check BLACS and the panel, then labs_abort if needed.")
+                        False, False, "compiled_not_executed", time.time() - start,
+                        "shot files exist but show no acquisition data after " + str(int(stall)) + " s: BLACS may be "
+                        "paused, or it kept the shot out of the queue (its connection table must be a subset of the "
+                        "lab connection table) or a device group failed to program within 5 minutes (the queue then "
+                        "pauses and puts that shot back at its head), or the run is still being programmed. Check the "
+                        "BLACS GUI and the panel, then labs_abort if needed.")
             else:
                 compiled_since = None
         last_count = count
         last_size = total
-        last_executed = executed
+        quiet = time.time() - last_progress
+        if want and count < want and quiet >= no_shot:
+            if count == 0:
+                diagnosis = "no_shots"
+                hint = ("no shot h5 appeared in " + str(int(no_shot)) + " s: the compilation probably aborted "
+                        "(runmanager shows the error) or BLACS is not running. Check runmanager, call labs_wait "
+                        "again to keep waiting, or labs_abort.")
+            else:
+                diagnosis = "compile_stalled"
+                hint = ("compilation stopped at " + str(count) + " of " + str(want) + " shot h5 files and "
+                        "nothing changed for " + str(int(no_shot)) + " s: it probably aborted (runmanager shows "
+                        "the error). Check runmanager, call labs_wait again to keep waiting, or labs_abort.")
+            return result(False, False, diagnosis, time.time() - start, hint)
         if time.time() - start >= timeout:
             if count == 0:
                 diagnosis = "no_shots"
                 hint = "no shot h5 appeared: check that the run was accepted, that BLACS is running, and that pathMap points at the run folder."
-            elif count < (expected or 0):
+            elif count < want:
                 diagnosis = "compiling"
                 hint = "only " + str(count) + " of " + str(expected) + " shots appeared before the timeout; the run may still be compiling or blocked."
             elif executed is False:
                 diagnosis = "compiled_not_executed"
-                hint = "shots were compiled but no acquisition data was found: BLACS may be paused or not executing the queue."
+                hint = ("shot files exist but no acquisition data was found: BLACS may be paused, may have refused the "
+                        "shot (connection table not a subset of the lab connection table) or re-queued it after a device "
+                        "programming timeout. Check the BLACS GUI.")
             else:
                 diagnosis = "partial"
                 hint = "shots appeared but the run was not confirmed complete before the timeout."
-            return result(False, True, diagnosis, count, executed, time.time() - start, hint)
+            return result(False, True, diagnosis, time.time() - start, hint)
         time.sleep(poll)
 
 
@@ -1146,7 +1255,20 @@ def cmd_progress(config, args):
     expected = int(args.get("expected_n_shots") or 0)
     folder = map_path(config, run_folder)
     shots = sorted(glob.glob(os.path.join(folder, "**", "*.h5"), recursive=True)) if folder else []
-    return {"run_folder": run_folder, "mapped_run_folder": folder, "folder_exists": bool(folder) and os.path.isdir(folder), "n_h5": len(shots), "expected_n_shots": expected, "complete": bool(expected and len(shots) >= expected)}
+    # n_h5 counts files, which labscript writes before compiling each shot; n_executed
+    # counts the shots that actually acquired data. A run is only complete when the
+    # last shot has acquisition data, not merely when the file count matches.
+    executed = executed_prefix(shots)
+    complete = bool(expected and len(shots) >= expected and executed == len(shots))
+    return {
+        "run_folder": run_folder,
+        "mapped_run_folder": folder,
+        "folder_exists": bool(folder) and os.path.isdir(folder),
+        "n_h5": len(shots),
+        "n_executed": executed,
+        "expected_n_shots": expected,
+        "complete": complete,
+    }
 
 
 
@@ -1453,7 +1575,7 @@ def cmd_doctor(config, args):
             probe = LabscriptBackend(config)
             client = probe.client()
             version = client.get_version() if hasattr(client, "get_version") else "unknown"
-            _add_check(checks, "runmanager", "ok", str(version))
+            _add_check(checks, "runmanager", "ok", str(version) + " at " + probe.endpoint())
             try:
                 _add_check(checks, "panel", "ok", "n_shots=" + str(probe.n_shots()) + ", run_shots=" + str(probe.run_shots()) + ", error_in_globals=" + str(probe.error_in_globals()))
             except Exception as exc:

package/python/tests/run_tests.py

@@ -8,6 +8,8 @@ import os
 import shutil
 import sys
 import tempfile
+import time
+import types
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, os.path.dirname(HERE))
@@ -277,6 +279,273 @@ def test_wait_diagnosis_compiled_not_executed():
         shutil.rmtree(tmp, ignore_errors=True)
 
 
+def test_axis_heuristic_ignores_tuples_and_dicts():
+    """runmanager does not expand tuples, so the scan-axes hint must not count them."""
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-axis-")
+    try:
+        cfg = make_config(tmp)
+        out = bridge.cmd_set(cfg, {"values": {"pulse_shape": "(0.1, 0.2, 0.3)"}, "raw": True})
+        assert out["missing"] == [], out
+        status = bridge.cmd_status(cfg, {})
+        assert "pulse_shape" not in status["scan_axes"], status["scan_axes"]
+        assert status["n_shots"] == 1, status["n_shots"]
+        assert status["n_shots_from_arrays"] == 1, status["n_shots_from_arrays"]
+        # a list/array global is an axis, a dict is not
+        bridge.cmd_set(cfg, {"values": {"freq": "np.arange(0.5, 6.7, 0.2)", "shape": "{'a': 1, 'b': 2}"}, "raw": True})
+        status = bridge.cmd_status(cfg, {})
+        assert status["scan_axes"].get("freq") == 31, status["scan_axes"]
+        assert "shape" not in status["scan_axes"], status["scan_axes"]
+        assert status["n_shots"] == 31, status["n_shots"]
+        assert status["n_shots_from_arrays"] == 31, status["n_shots_from_arrays"]
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_mock_error_in_globals_blocks_engage():
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-mock-error-")
+    try:
+        cfg = make_config(tmp)
+        assert bridge.cmd_status(cfg, {})["error_in_globals"] is False
+        cfg["mock"]["errorInGlobals"] = True
+        assert bridge.cmd_status(cfg, {})["error_in_globals"] is True
+        try:
+            bridge.cmd_engage(cfg, {})
+        except bridge.BridgeError as exc:
+            assert exc.code == "GLOBALS_ERROR", exc.code
+        else:
+            raise AssertionError("expected GLOBALS_ERROR")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_mock_reports_shuffle():
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-mock-shuffle-")
+    try:
+        cfg = make_config(tmp)
+        assert bridge.cmd_status(cfg, {})["shuffle"] is False
+        cfg["mock"]["shuffle"] = True
+        assert bridge.cmd_status(cfg, {})["shuffle"] is True
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_real_client_uses_labconfig_defaults():
+    """Unset host/port/timeout must be resolved by runmanager.remote from labconfig."""
+    class FakeClient(object):
+        last = None
+
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+            self.host = kwargs.get("host") or "localhost"
+            self.port = kwargs.get("port") or 42523
+            self.timeout = kwargs.get("timeout") or 60
+            FakeClient.last = self
+
+        def say_hello(self):
+            return "hello"
+
+        def get_shuffle(self):
+            return True
+
+    class NoShuffleClient(FakeClient):
+        def get_shuffle(self):
+            raise AttributeError("get_shuffle")
+
+    fake_remote = types.ModuleType("runmanager.remote")
+    fake_remote.Client = FakeClient
+    fake_package = types.ModuleType("runmanager")
+    fake_package.remote = fake_remote
+    saved = dict((name, sys.modules.get(name)) for name in ("runmanager", "runmanager.remote"))
+    sys.modules["runmanager"] = fake_package
+    sys.modules["runmanager.remote"] = fake_remote
+    try:
+        bare = bridge.LabscriptBackend({})
+        client = bare.client()
+        assert client.kwargs == {}, client.kwargs
+        assert bare.shuffle() is True
+        explicit = bridge.LabscriptBackend({"runmanager": {"host": "10.0.0.5", "port": 43000, "timeoutS": 25}})
+        assert explicit.client().kwargs == {"host": "10.0.0.5", "port": 43000, "timeout": 25.0}
+        assert "10.0.0.5" in explicit.endpoint() and "config" in explicit.endpoint()
+        fake_remote.Client = NoShuffleClient
+        assert bridge.LabscriptBackend({}).shuffle() is None
+    finally:
+        for name, module in saved.items():
+            if module is None:
+                sys.modules.pop(name, None)
+            else:
+                sys.modules[name] = module
+
+
+def test_wait_reports_extra_shot_files():
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-extra-shots-")
+    try:
+        cfg = make_config(tmp)
+        cfg["engage"] = {"timeoutS": 5, "pollS": 0.05, "settleS": 0.1}
+        run_dir = os.path.join(tmp, "extra_run")
+        os.makedirs(run_dir, exist_ok=True)
+        for index in range(4):
+            write_shot(os.path.join(run_dir, "shot_000%d.h5" % index), executed=True)
+        result = bridge.wait_for_run(cfg, run_dir, 2, 4)
+        assert result["complete"] is True, result
+        assert result["n_h5"] == 4, result
+        assert "Repeat all" in result["hint"], result
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def write_shot(path, executed):
+    """Write a shot h5 like labscript does: globals first, acquisition data later."""
+    import h5py
+    with h5py.File(path, "w") as handle:
+        handle.create_group("globals")
+        if executed:
+            label = handle.create_group("images/camera/label")
+            label.create_dataset("frame", data=[1.0, 2.0])
+
+
+def test_wait_reports_stalled_compilation_early():
+    """A compile that dies after one shot h5 must not block for the whole timeout."""
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-stalled-")
+    try:
+        cfg = make_config(tmp)
+        cfg["engage"] = {"timeoutS": 10, "pollS": 0.05, "settleS": 0.1, "noShotS": 0.3}
+        run_dir = os.path.join(tmp, "stalled_run")
+        os.makedirs(run_dir, exist_ok=True)
+        write_shot(os.path.join(run_dir, "shot_0000.h5"), executed=False)
+        started = time.time()
+        result = bridge.wait_for_run(cfg, run_dir, 64, 10)
+        elapsed = time.time() - started
+        assert result["diagnosis"] == "compile_stalled", result
+        assert result["timed_out"] is False, result
+        assert result["n_h5"] == 1, result
+        assert result["n_executed"] == 0, result
+        assert elapsed < 3.0, elapsed
+        assert "aborted" in result["hint"], result
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_wait_reports_no_shots_early():
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-noshots-")
+    try:
+        cfg = make_config(tmp)
+        cfg["engage"] = {"timeoutS": 10, "pollS": 0.05, "settleS": 0.1, "noShotS": 0.3}
+        run_dir = os.path.join(tmp, "empty_run")
+        os.makedirs(run_dir, exist_ok=True)
+        started = time.time()
+        result = bridge.wait_for_run(cfg, run_dir, 64, 10)
+        elapsed = time.time() - started
+        assert result["diagnosis"] == "no_shots", result
+        assert result["timed_out"] is False, result
+        assert result["n_h5"] == 0 and result["n_executed"] == 0, result
+        assert elapsed < 3.0, elapsed
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_progress_separates_files_from_executed_shots():
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-progress-exec-")
+    try:
+        cfg = make_config(tmp)
+        compiled = os.path.join(tmp, "compiled_run")
+        os.makedirs(compiled, exist_ok=True)
+        write_shot(os.path.join(compiled, "shot_0000.h5"), executed=True)
+        write_shot(os.path.join(compiled, "shot_0001.h5"), executed=False)
+        write_shot(os.path.join(compiled, "shot_0002.h5"), executed=False)
+        out = bridge.cmd_progress(cfg, {"run_folder": compiled, "expected_n_shots": 3})
+        assert out["n_h5"] == 3, out
+        assert out["n_executed"] == 1, out
+        assert out["complete"] is False, out
+        done = os.path.join(tmp, "done_run")
+        os.makedirs(done, exist_ok=True)
+        for index in range(2):
+            write_shot(os.path.join(done, "shot_000%d.h5" % index), executed=True)
+        finished = bridge.cmd_progress(cfg, {"run_folder": done, "expected_n_shots": 2})
+        assert finished["complete"] is True, finished
+        assert finished["n_executed"] == 2, finished
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_real_backend_set_globals_survives_none_reply():
+    """runmanager's set_globals returns None; the write must still be reported."""
+    class FakeClient(object):
+        def __init__(self):
+            self.calls = []
+
+        def set_globals(self, values, raw=False):
+            self.calls.append((dict(values), raw))
+            return None
+
+    client = FakeClient()
+    backend = bridge.LabscriptBackend({})
+    backend._client = client
+    written = backend.set_globals({"do_acquire": True, "amplitude": 0.5})
+    assert written == {"do_acquire": True, "amplitude": 0.5}, written
+    assert client.calls == [({"do_acquire": True, "amplitude": 0.5}, False)], client.calls
+
+
+def test_cmd_set_accepts_backend_that_returns_none():
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-set-none-")
+    try:
+        cfg = make_config(tmp)
+        original = bridge.make_backend
+
+        def make(config):
+            backend = bridge.MockBackend(config)
+
+            def set_globals(values, raw=False):
+                bridge.MockBackend.set_globals(backend, values, raw=raw)
+                return None
+
+            backend.set_globals = set_globals
+            return backend
+
+        bridge.make_backend = make
+        try:
+            out = bridge.cmd_set(cfg, {"values": {"amplitude": 0.71}, "note": "None-returning client"})
+        finally:
+            bridge.make_backend = original
+        assert out["missing"] == [], out
+        assert out["readback"]["amplitude"] == 0.71, out
+        assert out["written"] == {"amplitude": 0.71}, out
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def test_cmd_set_failure_reports_what_landed():
+    tmp = tempfile.mkdtemp(prefix="dsh-labscript-set-partial-")
+    try:
+        cfg = make_config(tmp)
+        original = bridge.make_backend
+
+        def make(config):
+            backend = bridge.MockBackend(config)
+
+            def set_globals(values, raw=False):
+                if "amplitude" in values:
+                    bridge.MockBackend.set_globals(backend, {"amplitude": values["amplitude"]}, raw=raw)
+                raise ValueError("Global nope not found in any active group")
+
+            backend.set_globals = set_globals
+            return backend
+
+        bridge.make_backend = make
+        try:
+            bridge.cmd_set(cfg, {"values": {"amplitude": 0.71, "nope": 1}})
+        except bridge.BridgeError as exc:
+            assert exc.code == "SET_FAILED", exc.code
+            assert "not found" in exc.message, exc.message
+            assert exc.detail["snapshot"]["name"].endswith(".json"), exc.detail
+            assert exc.detail["landed"]["amplitude"] == "0.71", exc.detail
+            assert "labs_status" in exc.detail["hint"], exc.detail
+        else:
+            raise AssertionError("expected SET_FAILED")
+    finally:
+        bridge.make_backend = original
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
 def test_doctor_mock():
     tmp = tempfile.mkdtemp(prefix="dsh-labscript-doctor-")
     try: