feat(scheduler)!: background blocks, beamline-state gating and action registry
CI for debye_bec / test (pull_request) Failing after 45s
CI for debye_bec / test (push) Failing after 47s

Restructure the Scheduler widget and extend its functionality:

- New schedule table: line, status, command, report, pause on failure,
  pause on state, wait for completion. Items running while a background
  item (wait_for_completion=False) is busy are indented with a guide line.
- New execution loop (executor.py) supporting background items and the
  "Wait until parent has completed" item.
- Pause on state: embed BEC's BeamlineStateManager (scan-interlock
  controls hidden) and gate items on all beamline states being VALID or
  WARNING; running gated scans are cancelled and repeated after recovery.
  Replaces the custom signal guard.
- Replace eval of command strings with a JSON-serialisable function
  registry (actions.py).
- Add a delay item (hours/minutes/seconds), interruptible by "Pause now".
- Add wait for completion / pause on state options to the item dialog;
  remove the free-form "Other" page.
- Remove Microsoft Teams notifications.
- Fix: failures without "pause on failure" no longer stop the schedule,
  start/stop notifications respect the enabled flag, remote updates are
  no longer ignored after renaming a schedule.
- Split the package into models, actions, executor, state monitor and
  table modules; update docstrings; add unit tests.

BREAKING CHANGE: schedules are stored as action + params instead of
command strings. Old schedules in Redis are logged and replaced by an
empty schedule; old JSON files can no longer be loaded. The RPC methods
add_item/edit_item now take action and params instead of command, kind
and form_state.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
hitz_sandClaude Opus 5.5 committed 2026-11-12 14:42:37 +01:00
1 parent 02f60b8de0
commit 9862fb30a1
21 files changed
+3925 -2513

No files matched your search

+65 -43
View File
@@ -145,103 +145,125 @@ class ScanControlXAS(RPCBase):
class Scheduler(RPCBase):
"""Schedule, persist and execute a sequence of BEC scan/device commands."""
"""Schedule, persist and execute a sequence of BEC actions."""
_IMPORT_MODULE = "debye_bec.bec_widgets.widgets.scheduler.scheduler"
@rpc_call
def run_schedule(self, first_item: "int" = 0):
def run_schedule(self, first_item: "int" = 0, retry_unfinished: "bool" = False) -> "None":
"""
Run the schedule, continuing from wherever it last left off.
Start (or continue) executing the schedule.
Already COMPLETED items are skipped. Does nothing if the schedule is already running.
Args:
first_item: Index of the item to start with; items above it are ignored.
retry_unfinished: If True, FAILED and ABORTED items are executed again.
"""
@rpc_call
def abort_schedule(self):
def pause_schedule(self) -> "None":
"""
Request that the schedule stop after the current item.
Pause after the currently running item(s) have finished.
"""
@rpc_call
def reset_schedule(self):
def abort_schedule(self) -> "None":
"""
Clear all execution state and start the schedule over from item 1.
Pause now: cancel running scans/moves, interrupt delays and stop the schedule.
"""
@rpc_call
def reset_schedule(self) -> "None":
"""
Mark all items PENDING again and clear their execution state (not while running).
"""
@rpc_call
def get_status(self) -> "dict":
"""
RPC-exposed: current schedule state, e.g. for another widget or a script.
The complete schedule (definition and execution state) as a JSON-compatible dict.
"""
@rpc_call
def add_item(
self,
command: "str",
action: "str",
params: "dict | None" = None,
index: "int | None" = None,
kind: "str" = "custom",
form_state: "dict | None" = None,
wait_for_completion: "bool" = True,
pause_on_failure: "bool" = False,
pause_on_state: "bool" = False,
) -> "str":
"""
RPC-exposed: insert a new, PENDING command into the schedule.
Safe to call while the schedule is running.
Insert a new PENDING item.
Args:
command: command text, evaluated the same way as the existing
items (against `scans`/`dev`) once the schedule runs.
index: position to insert at (0 = first). Clamped so the item
can never land before something already running or
finished. Defaults to appending at the end.
kind/form_state: optional structured description of how
`command` was built (see `schedule_item.ScheduleItem`),
used to reopen the Edit dialog pre-filled. Leave as
defaults for a plain, hand-typed command.
action: Registered action name, e.g. "scan", "move", "delay", "wait_for_parent".
params: JSON-serialisable parameters of the action, e.g.
`{"device": "samx", "value": 1.0, "relative": False}` for "move" or
`{"seconds": 60}` for "delay".
index: Insert position (0 = first). Clamped so the item never lands before an item
that has already started. Defaults to the end.
wait_for_completion: If False, the following items start while this one runs.
pause_on_failure: Pause the schedule if this item fails.
pause_on_state: Only start while all beamline states are VALID/WARNING.
Returns:
The new item's item_id.
The id of the new item.
Raises:
ValueError: Unknown action.
TypeError: Parameters are not JSON-serialisable.
"""
@rpc_call
def edit_item(
self,
item_id: "str",
command: "str",
kind: "str" = "custom",
form_state: "dict | None" = None,
pause_on_failure: "bool" = True,
):
action: "str",
params: "dict | None" = None,
wait_for_completion: "bool" = True,
pause_on_failure: "bool" = False,
pause_on_state: "bool" = False,
) -> "None":
"""
RPC-exposed: change the command of an item that has not started
yet. Raises `RuntimeError` for an item that is already
running/finished.
Replace the definition of an item that has not started yet (see `add_item` for the
arguments).
Raises:
RuntimeError: The item has already started or finished.
"""
@rpc_call
def delete_item(self, item_id: "str"):
def delete_item(self, item_id: "str") -> "None":
"""
RPC-exposed: remove an item that has not started yet. Raises
`RuntimeError` for an item that is already running/finished.
Remove an item that has not started yet.
Raises:
RuntimeError: The item has already started or finished.
"""
@rpc_call
def move_item(self, item_id: "str", new_index: "int"):
def move_item(self, item_id: "str", new_index: "int") -> "None":
"""
RPC-exposed: move an item that has not started yet to a new
position (0 = first, but never before something already
running/finished). Raises `RuntimeError` for an item that is
already running/finished.
Move an item that has not started yet to `new_index` (never before an item that has
already started).
Raises:
RuntimeError: The item has already started or finished.
"""
@rpc_call
def move_item_up(self, item_id: "str"):
def move_item_up(self, item_id: "str") -> "None":
"""
RPC-exposed: swap an item with the one directly before it.
Swap an item with the one above it.
"""
@rpc_call
def move_item_down(self, item_id: "str"):
def move_item_down(self, item_id: "str") -> "None":
"""
RPC-exposed: swap an item with the one directly after it.
Swap an item with the one below it.
"""
@@ -0,0 +1,512 @@
"""
Function registry of the Scheduler widget.
A schedule item never stores executable code. It stores the *name* of a registered action plus
JSON-serialisable parameters (`ScheduleItem.action` / `ScheduleItem.params`). At execution time
the executor looks the action up in `ACTIONS` and calls its `run` function with an
`ExecutionContext` (BEC shortcuts and beamline helpers) and the stored parameters. This replaces
the former `eval` of command strings: only registered, reviewed functions can ever be executed,
and a schedule stays saveable as plain JSON.
Adding a new item type means:
1. writing a `run(ctx, **params)` function (and a `describe(params, beamline)` function for the
"Command" column),
2. registering both with `register_action(ActionSpec(...))`,
3. adding a page to `item_dialog.ScheduleItemDialog` that produces the parameters.
"""
from __future__ import annotations
import threading
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, Callable, Literal
if TYPE_CHECKING: # pragma: no cover
from .models import ScheduleItem
ActionCategory = Literal["scan", "move", "device", "delay", "control"]
#: Registry key of the "Wait until parent has completed" control item.
WAIT_FOR_PARENT = "wait_for_parent"
#: Registry key of the delay item.
DELAY = "delay"
class ActionInterrupted(Exception):
"""Raised by an action that was interrupted by an abort of the schedule."""
@dataclass
class ExecutionContext:
"""
Everything an action may need at execution time.
Attributes:
scans: BEC scan shortcut (`client.scans`).
dev: BEC device container (`client.device_manager.devices`).
digital_twin: `DigitalTwinCore` instance, if available at this beamline.
auto_gain: `AutoGainCore` instance, if available at this beamline.
beamline: Beamline name, e.g. "x01da".
abort_event: Set when the schedule is aborted or the widget is closed; long-running local
actions (e.g. delays) must return early when it is set.
"""
scans: Any
dev: Any
digital_twin: Any = None
auto_gain: Any = None
beamline: str | None = None
abort_event: threading.Event = field(default_factory=threading.Event)
@dataclass(frozen=True)
class ActionSpec:
"""
Description of one registered schedule action.
Attributes:
name: Registry key, stored in `ScheduleItem.action` (and therefore in Redis/JSON). Never
rename the key of an existing action, or saved schedules can no longer be loaded.
label: Human-readable name, e.g. for the item dialog.
category: Used for notification filtering and execution rules:
"scan" and "move" submit requests to the BEC scan server, "device" covers other
device actions and beamline tools, "delay" is a local wait and "control" items only
steer the schedule itself.
run: `run(ctx, **params) -> handle`. May block until done, or return a handle with
`wait()` (and optionally `cancel()`), e.g. a BEC `ScanReport`. `None` for control
actions, which are handled by the executor itself.
describe: `describe(params, beamline) -> str`, the text of the "Command" column.
report: Optional `report(handle, item, ctx) -> str | None`, the text of the "Report"
column after a successful execution. Defaults to `default_report`.
cancellable: True if the returned handle supports `cancel()` (e.g. scans/moves), so that
the item can be interrupted when the schedule is aborted or a beamline state trips.
"""
name: str
label: str
category: ActionCategory
run: Callable[..., Any] | None
describe: Callable[[dict, str | None], str]
report: Callable[[Any, "ScheduleItem", ExecutionContext], str | None] | None = None
cancellable: bool = False
ACTIONS: dict[str, ActionSpec] = {}
def register_action(spec: ActionSpec) -> ActionSpec:
"""
Add an action to the registry.
Args:
spec: The action to register.
Returns:
The registered spec (so this can be used inline).
Raises:
ValueError: If an action with the same name is already registered.
"""
if spec.name in ACTIONS:
raise ValueError(f"A schedule action named {spec.name!r} is already registered.")
ACTIONS[spec.name] = spec
return spec
def get_action(name: str) -> ActionSpec:
"""
Look up a registered action.
Raises:
KeyError: If no action with this name is registered.
"""
try:
return ACTIONS[name]
except KeyError:
raise KeyError(f"Unknown schedule action {name!r}.") from None
def run_action(ctx: ExecutionContext, action: str, params: dict) -> Any:
"""
Execute a registered action - the single dispatch point used by the executor.
Args:
ctx: Execution context.
action: Registry key of the action.
params: Keyword arguments for the action's `run` function.
Returns:
Whatever the action returns (e.g. a `ScanReport` to wait on), or None.
Raises:
KeyError: If the action is not registered.
ValueError: If the action is a control action that cannot be run directly.
"""
spec = get_action(action)
if spec.run is None:
raise ValueError(f"Schedule action {action!r} is handled by the executor.")
return spec.run(ctx, **params)
def describe_item(item: "ScheduleItem", beamline: str | None) -> str:
"""
Text for the "Command" column of an item. Never raises: an unknown action or malformed
parameters fall back to a generic representation.
"""
spec = ACTIONS.get(item.action)
if spec is None:
return f"Unknown action '{item.action}' {item.params}"
try:
return spec.describe(item.params, beamline)
except Exception: # pylint: disable=broad-except
return f"{spec.label} {item.params}"
def default_report(handle: Any, item: "ScheduleItem", _ctx: ExecutionContext) -> str | None:
"""Fallback "Report" text: the scan number, or a short summary of a returned value."""
if item.scan_number is not None:
return f"Scan #{item.scan_number} done"
if handle is None or hasattr(handle, "wait"):
return "Done"
text = str(handle)
return text if len(text) <= 120 else text[:117] + "..."
def format_duration(seconds: float) -> str:
"""Format a duration as e.g. "1 h 05 min 00 s" / "2 min 30 s" / "12 s"."""
seconds = max(0, int(round(seconds)))
hours, rest = divmod(seconds, 3600)
minutes, secs = divmod(rest, 60)
if hours:
return f"{hours} h {minutes:02d} min {secs:02d} s"
if minutes:
return f"{minutes} min {secs:02d} s"
return f"{secs} s"
def _format_call(name: str, args: list, kwargs: dict) -> str:
parts = [repr(a) for a in args]
parts += [f"{key}={value!r}" for key, value in kwargs.items()]
return f"{name}({', '.join(parts)})"
# ---------------------------------------------------------------------------------------------- #
# Scan
# ---------------------------------------------------------------------------------------------- #
def _run_scan(ctx: ExecutionContext, scan_name: str, args: list | None = None, kwargs=None):
scan = getattr(ctx.scans, scan_name, None)
if scan is None or scan_name.startswith("_"):
raise ValueError(f"Scan {scan_name!r} is not available in this BEC session.")
return scan(*(args or []), **(kwargs or {}))
def _describe_scan(params: dict, _beamline: str | None) -> str:
scan_name = params["scan_name"]
kwargs = params.get("kwargs") or {}
if scan_name == "xas_simple_scan":
metadata = kwargs.get("metadata") or {}
return (
f"XAS simple scan from {kwargs.get('start')} eV to {kwargs.get('stop')} eV, "
f"{kwargs.get('scan_time')} s per spectrum, measure {kwargs.get('scan_duration')} s"
f"\nComment: {metadata.get('comment', '')}, "
f"Sample Name: {metadata.get('sample_name', '')}"
)
return _format_call(f"scans.{scan_name}", params.get("args") or [], kwargs)
register_action(
ActionSpec(
name="scan",
label="Scan",
category="scan",
run=_run_scan,
describe=_describe_scan,
cancellable=True,
)
)
# ---------------------------------------------------------------------------------------------- #
# Move
# ---------------------------------------------------------------------------------------------- #
def _run_move(ctx: ExecutionContext, device: str, value: float, relative: bool = False, **_):
return ctx.dev[device].move(value, relative=relative)
def _describe_move(params: dict, _beamline: str | None) -> str:
units = params.get("units", "")
if params.get("relative"):
return f"Move {params['device']} by {params['value']:+g} {units}".rstrip()
return f"Move {params['device']} to {params['value']:g} {units}".rstrip()
def _report_move(_handle, item: "ScheduleItem", ctx: ExecutionContext) -> str | None:
device = item.params["device"]
try:
position = ctx.dev[device].position
return f"Moved to {position:g} {item.params.get('units', '')}".rstrip()
except Exception: # pylint: disable=broad-except
return "Done"
register_action(
ActionSpec(
name="move",
label="Move",
category="move",
run=_run_move,
describe=_describe_move,
report=_report_move,
cancellable=True,
)
)
# ---------------------------------------------------------------------------------------------- #
# Digital twin (X01DA / X10DA)
# ---------------------------------------------------------------------------------------------- #
def _run_digital_twin(ctx: ExecutionContext, config: dict):
if ctx.digital_twin is None:
raise RuntimeError("The digital twin is not available at this beamline.")
result = ctx.digital_twin.move_with_config(config)
if isinstance(result, dict) and not result.get("success", True):
details = {key: result[key] for key in ("failures", "aborted") if result.get(key)}
raise RuntimeError(f"Beamline alignment did not complete: {details}")
def _describe_digital_twin(params: dict, beamline: str | None) -> str:
config = params["config"]
monochromatic = config["mo1_mode"] == "Monochromatic"
text = (
f"Align beamline for {config['energy']:.0f} eV"
if monochromatic
else "Align beamline for pink beam"
)
text += (
f"\nFE: {config['h_acc'] * 1e3:.3f} mrad x {config['v_acc'] * 1e3:.3f} mrad"
f"\nCM: {config['cm_stripe']} at {config['cm_pitch'] * 1e3:.3f} mrad"
)
if monochromatic:
text += f"\nMO1: {config['mo1_xtal']}"
text += f"\nFM: {config['fm_stripe']} at {config['fm_rotx'] * 1e3:.3f} mrad"
if beamline == "x01da":
text += f"\nES1: {config['ot_es1_trz']:.0f} mm"
text += f"\nSMPL_TRZ: {config['es1man_trz']:.3f} mm"
if beamline == "x01da":
text += f"\nSMPL-XRD: {config['smpl_to_xrd']:.3f} mm"
return text
register_action(
ActionSpec(
name="digital_twin",
label="Digital Twin",
category="device",
run=_run_digital_twin,
describe=_describe_digital_twin,
report=lambda *_: "Beamline aligned",
)
)
# ---------------------------------------------------------------------------------------------- #
# Auto-gain (X01DA / X10DA)
# ---------------------------------------------------------------------------------------------- #
def _run_auto_gain(ctx: ExecutionContext, config: dict):
if ctx.auto_gain is None:
raise RuntimeError("Auto-gain is not available at this beamline.")
return ctx.auto_gain.start(
element=config["element"],
edge=config["edge"],
amplifier=config["all_amplifiers"],
link_ic0_ic1=config["link_ic0_ic1"],
comp_ring_current=config["compensate_ring_current"],
prohibited_gains=config["prohibited_gains"],
)
def _describe_auto_gain(params: dict, _beamline: str | None) -> str:
config = params["config"]
text = f"Auto-configure gains for {config['element']}, {config['edge']}-edge"
text += f"\nfor devices {config['all_amplifiers']}"
if config["link_ic0_ic1"]:
text += "\nLink IC0 and IC1 gains"
if config["compensate_ring_current"]:
text += "\nCalculate for 400 mA ring current"
if config["prohibited_gains"]:
prohibited = ", ".join(
f"{amp}: [" + ", ".join(f"{gain:.0e}" for gain in gains) + "]"
for amp, gains in config["prohibited_gains"].items()
)
text += f"\nProhibited gains: {{{prohibited}}}"
return text
def _report_auto_gain(handle, _item, _ctx) -> str | None:
if isinstance(handle, dict) and handle:
return "Gains: " + ", ".join(
f"{key}={value:.0e}" if isinstance(value, (int, float)) else f"{key}={value}"
for key, value in handle.items()
)
return "Done"
register_action(
ActionSpec(
name="auto_gain",
label="Auto Gain",
category="device",
run=_run_auto_gain,
describe=_describe_auto_gain,
report=_report_auto_gain,
)
)
# ---------------------------------------------------------------------------------------------- #
# Absorber
# ---------------------------------------------------------------------------------------------- #
ABSORBER_ACTIONS = ("Open", "Force open", "Close")
def _run_absorber(ctx: ExecutionContext, action: str):
absorber = ctx.dev["abs"]
if action == "Open":
return absorber.open()
if action == "Force open":
return absorber.open(force=True)
if action == "Close":
return absorber.close()
raise ValueError(f"Unknown absorber action {action!r}.")
register_action(
ActionSpec(
name="absorber",
label="Absorber",
category="device",
run=_run_absorber,
describe=lambda params, _bl: f"{params['action']} absorber",
)
)
# ---------------------------------------------------------------------------------------------- #
# Ionization chamber gas filling
# ---------------------------------------------------------------------------------------------- #
def _run_ic_fill(
ctx: ExecutionContext,
chamber: str,
gas1: str,
conc1: float,
gas2: str,
conc2: float,
pressure: float,
):
return ctx.dev[chamber.lower()].fill(
gas1=gas1, conc1=conc1, gas2=gas2, conc2=conc2, pressure=pressure, wait=True
)
register_action(
ActionSpec(
name="ic_fill",
label="Ionization Chamber",
category="device",
run=_run_ic_fill,
describe=lambda p, _bl: (
f"Fill {p['chamber']} with {p['conc1']:g} % {p['gas1']} and {p['conc2']:g} % "
f"{p['gas2']} to {p['pressure']:g} bar"
),
)
)
# ---------------------------------------------------------------------------------------------- #
# Reference foil changer
# ---------------------------------------------------------------------------------------------- #
def _run_reffoil(ctx: ExecutionContext, foil: str):
return ctx.dev["reffoilchanger"].insert(ref=foil, wait=True)
register_action(
ActionSpec(
name="reffoil",
label="Reference foil changer",
category="device",
run=_run_reffoil,
describe=lambda params, _bl: f"Insert {params['foil']} reference foil",
)
)
# ---------------------------------------------------------------------------------------------- #
# Temperature controller
# ---------------------------------------------------------------------------------------------- #
def _run_temperature_controller(ctx: ExecutionContext, config: dict):
return ctx.dev["univ_temp_cont"].load_config(config=config)
def _describe_temperature_controller(params: dict, _beamline: str | None) -> str:
config = params["config"]
match config["power_mode"]:
case "Standby":
return "Switch temperature controller to standby"
case "Configuration":
return "Switch temperature controller to configuration mode"
case _:
return (
f"Set temperature controller to {config['target_setpoint']} °C"
f"\nwith ramp rate of {config['ramp_rate']} {config['ramp_rate_unit']}"
)
register_action(
ActionSpec(
name="temperature_controller",
label="Temperature Controller",
category="device",
run=_run_temperature_controller,
describe=_describe_temperature_controller,
)
)
# ---------------------------------------------------------------------------------------------- #
# Delay
# ---------------------------------------------------------------------------------------------- #
def _run_delay(ctx: ExecutionContext, seconds: float):
# Event.wait instead of time.sleep, so that aborting the schedule interrupts the delay.
if ctx.abort_event.wait(timeout=max(0.0, float(seconds))):
raise ActionInterrupted("Delay interrupted.")
register_action(
ActionSpec(
name=DELAY,
label="Delay",
category="delay",
run=_run_delay,
describe=lambda params, _bl: f"Delay for {format_duration(params['seconds'])}",
report=lambda _h, item, _c: f"Waited {format_duration(item.params['seconds'])}",
)
)
# ---------------------------------------------------------------------------------------------- #
# Wait until parent has completed (control item, executed by the executor itself)
# ---------------------------------------------------------------------------------------------- #
register_action(
ActionSpec(
name=WAIT_FOR_PARENT,
label="Wait until parent has completed",
category="control",
run=None,
describe=lambda _params, _bl: "Wait until parent has completed",
report=lambda *_: "Parent completed",
)
)
#: Actions that always block until done; "wait for completion" cannot be switched off for them.
ALWAYS_WAIT_ACTIONS = frozenset({DELAY, WAIT_FOR_PARENT})
@@ -1,11 +0,0 @@
from __future__ import annotations
from enum import Enum
class ScheduleItemStatus(str, Enum):
PENDING = "pending"
RUNNING = "running"
COMPLETED = "completed"
FAILED = "failed"
ABORTED = "aborted"
@@ -0,0 +1,442 @@
"""
Execution engine of the Scheduler widget.
`ScheduleExecutor.run` is executed on a worker thread (started by the widget through
`BECWidget.submit_task`). It never touches Qt widgets: all state changes are written to the
shared `Schedule` under the widget's lock, persisted to Redis through `persist_locked`, and the
GUI is told to redraw through `emit_changed` (which emits a Qt signal, marshalled onto the GUI
thread).
Execution rules
---------------
- Items run top to bottom. The next item is re-derived after every step
(`schedule_logic.pick_next_runnable`), so PENDING items can be added, edited, moved or deleted
while the schedule runs.
- `wait_for_completion=True` (default): the item is run and waited for before continuing.
- `wait_for_completion=False` ("background item"): the item is started on its own thread and the
schedule continues with the items of its block (see `schedule_logic`). Before an item outside
that block starts, and at a "Wait until parent has completed" item, the executor waits for the
background item to complete. Children keep running if the parent finishes first.
- `pause_on_state=True`: before the item starts, the executor waits until all beamline states
are VALID or WARNING. If a state turns INVALID while such an item is a running scan, the scan
is cancelled, the item is reset to PENDING and repeated once the states have recovered. Other
item types are not interrupted.
- `pause_on_failure=True`: a failure of the item pauses the schedule after the current step;
otherwise the schedule continues with the next item.
- "Pause after current item" lets running items finish; "Pause now" (abort) additionally cancels
running scans/moves and interrupts delays.
- Closing the widget stops the loop without cancelling anything server-side; the widget
reconciles the persisted state with the BEC queue when it is opened again.
"""
from __future__ import annotations
import threading
import time
import traceback
from dataclasses import dataclass, field
from typing import Any, Callable, Literal
from bec_lib.logger import bec_logger
from .actions import (
WAIT_FOR_PARENT,
ActionInterrupted,
ActionSpec,
ExecutionContext,
default_report,
get_action,
run_action,
)
from .models import ItemStatus, ScheduleItem
from .schedule_logic import block_parents, index_of, pick_next_runnable
logger = bec_logger.logger
RunOutcome = Literal["finished", "aborted", "paused", "paused_on_failure", "widget_closed"]
_ACTIVE_QUEUE_STATES = ("PENDING", "RUNNING")
_POLL_INTERVAL = 0.2
def is_queue_item_active(queue_item: Any) -> bool:
"""True if a BEC queue item is still pending or running server-side."""
return str(getattr(queue_item, "status", "")).upper() in _ACTIVE_QUEUE_STATES
@dataclass
class _Execution:
"""Bookkeeping of one item that is currently being executed."""
item: ScheduleItem
spec: ActionSpec
handle: Any = None
interrupted: bool = False # cancelled because a beamline state tripped -> repeat later
done: threading.Event = field(default_factory=threading.Event)
class ScheduleExecutor:
"""
Runs the items of a schedule (see the module docstring for the rules).
Args:
lock: The widget's lock guarding the schedule.
get_items: Returns the live list of schedule items. Only called while holding `lock`.
persist_locked: Writes the schedule to Redis; only called while holding `lock`.
emit_changed: Thread-safe "please redraw" callback.
context: Execution context handed to the registered actions.
state_monitor: Object with `is_ok()`, `wait_until_ok(should_abort)` and
`blocking_states()` (normally a `BeamlineStateMonitor`).
notify_item: Called (without lock) with an item after it COMPLETED, FAILED or ABORTED.
get_queue_storage: Returns BEC's queue storage; used to re-attach to requests that are
still running from a previous widget session.
closing: Set by the widget when it is being closed.
"""
def __init__(
self,
*,
lock: threading.Lock,
get_items: Callable[[], list[ScheduleItem]],
persist_locked: Callable[[], None],
emit_changed: Callable[[], None],
context: ExecutionContext,
state_monitor: Any,
notify_item: Callable[[ScheduleItem], None],
get_queue_storage: Callable[[], Any],
closing: threading.Event,
) -> None:
self._lock = lock
self._get_items = get_items
self._persist_locked = persist_locked
self._emit_changed = emit_changed
self._ctx = context
self._state_monitor = state_monitor
self._notify_item = notify_item
self._get_queue_storage = get_queue_storage
self._closing = closing
self._abort = threading.Event()
self._pause = threading.Event()
self._paused_on_failure = False
self._foreground: _Execution | None = None
self._background: _Execution | None = None
self._attempted: set[str] = set()
# ------------------------------------------------------------------------------------------ #
# Control (called from the GUI thread)
# ------------------------------------------------------------------------------------------ #
def request_pause(self) -> None:
"""Stop after the running item(s) have finished ("Pause after current item")."""
self._pause.set()
def request_abort(self) -> None:
"""Stop now: cancel running scans/moves and interrupt delays ("Pause now")."""
self._abort.set()
self._ctx.abort_event.set()
for execution in (self._foreground, self._background):
if execution is not None and not execution.done.is_set():
self._cancel(execution)
def notify_closing(self) -> None:
"""The widget is closing: interrupt local waits, but do not cancel server-side work."""
self._ctx.abort_event.set()
def on_states_tripped(self) -> None:
"""
A beamline state became INVALID: cancel running scans that have `pause_on_state` set.
They are reset to PENDING and repeated once the states have recovered.
"""
for execution in (self._foreground, self._background):
if execution is None or execution.done.is_set():
continue
if not (execution.item.pause_on_state and execution.spec.cancellable):
continue
if execution.spec.category != "scan":
continue
logger.info(f"Beamline state tripped: interrupting scan item {execution.item.item_id}")
execution.interrupted = True
self._cancel(execution)
def active_item_ids(self) -> set[str]:
"""Ids of the items currently executed by this executor."""
return {
execution.item.item_id
for execution in (self._foreground, self._background)
if execution is not None and not execution.done.is_set()
}
# ------------------------------------------------------------------------------------------ #
# Main loop (worker thread)
# ------------------------------------------------------------------------------------------ #
def run(self, first_item_id: str | None = None, retry_unfinished: bool = False) -> RunOutcome:
"""
Execute the schedule until it is finished, paused, aborted or the widget is closed.
Args:
first_item_id: Start with this item; items above it are ignored. None starts at the
top (already COMPLETED items are always skipped).
retry_unfinished: Run FAILED and ABORTED items again (once each).
Returns:
Why the run ended.
"""
self._abort.clear()
self._pause.clear()
self._ctx.abort_event.clear()
self._paused_on_failure = False
self._attempted = set()
self._background = None
self._foreground = None
outcome: RunOutcome = "finished"
while True:
outcome = self._stop_reason()
if outcome != "finished":
break
if self._background is not None and self._background.done.is_set():
self._background = None
with self._lock:
items = self._get_items()
first_index = index_of(items, first_item_id) or 0
item = pick_next_runnable(
items,
retry_unfinished=retry_unfinished,
first_index=first_index,
active_ids=self.active_item_ids(),
attempted_ids=self._attempted,
)
in_background_block = False
if item is not None and self._background is not None:
parent = block_parents(items)[index_of(items, item.item_id)]
in_background_block = (
parent is not None
and items[parent].item_id == self._background.item.item_id
)
if item is None:
break
if self._background is not None and not in_background_block:
# Leaving the block of the running background item: wait for it first.
self._join_background()
continue
if item.status == ItemStatus.RUNNING:
self._reattach(item)
continue
if item.action == WAIT_FOR_PARENT:
self._run_wait_for_parent(item)
continue
if item.pause_on_state and not self._wait_for_states(item):
continue
execution = self._start(item)
if item.wait_for_completion:
self._foreground = execution
self._execute(execution)
self._foreground = None
else:
self._background = execution
threading.Thread(
target=self._execute,
args=(execution,),
name=f"scheduler-background-{item.item_id}",
daemon=True,
).start()
if outcome != "widget_closed":
self._join_background()
if self._closing.is_set():
return "widget_closed"
if outcome == "finished":
# The loop may also have ended because a pause/abort happened while joining.
outcome = self._stop_reason()
return outcome
def _stop_reason(self) -> RunOutcome:
if self._closing.is_set():
return "widget_closed"
if self._abort.is_set():
return "aborted"
if self._pause.is_set():
return "paused_on_failure" if self._paused_on_failure else "paused"
return "finished"
def _should_stop_waiting(self) -> bool:
return self._closing.is_set() or self._abort.is_set() or self._pause.is_set()
# ------------------------------------------------------------------------------------------ #
# Steps
# ------------------------------------------------------------------------------------------ #
def _start(self, item: ScheduleItem) -> _Execution:
spec = get_action(item.action)
with self._lock:
item.reset_execution()
item.status = ItemStatus.RUNNING
item.started_at = time.time()
self._attempted.add(item.item_id)
self._persist_locked()
self._emit_changed()
return _Execution(item=item, spec=spec)
def _execute(self, execution: _Execution) -> None:
"""Run one item to completion and record the outcome. Runs on a worker thread."""
item, spec = execution.item, execution.spec
final_status: ItemStatus | None = None
try:
handle = run_action(self._ctx, item.action, item.params)
execution.handle = handle
request_id = getattr(getattr(handle, "request", None), "requestID", None)
if request_id is not None:
with self._lock:
item.request_id = request_id
self._persist_locked()
if execution.interrupted or self._abort.is_set():
self._cancel(execution)
wait = getattr(handle, "wait", None)
if callable(wait):
wait()
if self._closing.is_set():
return # leave RUNNING; reconciled when the widget is opened again
scan_id, scan_number = _scan_info(handle) if request_id else (None, None)
with self._lock:
item.scan_id, item.scan_number = scan_id, scan_number
if execution.interrupted:
self._requeue(item)
elif self._abort.is_set() and spec.cancellable:
with self._lock:
item.status = ItemStatus.ABORTED
item.report = "Aborted"
else:
report = (spec.report or default_report)(handle, item, self._ctx)
with self._lock:
item.status = ItemStatus.COMPLETED
item.report = report
except Exception as exc: # pylint: disable=broad-except
if self._closing.is_set():
return
if execution.interrupted:
self._requeue(item)
elif self._abort.is_set() or isinstance(exc, ActionInterrupted):
with self._lock:
item.status = ItemStatus.ABORTED
item.report = "Aborted"
else:
error = traceback.format_exc()
logger.error(f"Schedule item {item.action} {item.params} failed:\n{error}")
with self._lock:
item.status = ItemStatus.FAILED
item.error = error
item.report = _last_line(error)
if item.pause_on_failure:
self._paused_on_failure = True
self._pause.set()
finally:
if not self._closing.is_set():
with self._lock:
if item.status != ItemStatus.PENDING:
item.finished_at = time.time()
final_status = item.status
self._persist_locked()
execution.done.set()
self._emit_changed()
if final_status in (ItemStatus.COMPLETED, ItemStatus.FAILED, ItemStatus.ABORTED):
self._notify_item(item)
def _requeue(self, item: ScheduleItem) -> None:
with self._lock:
item.reset_execution()
item.report = "Interrupted by beamline state, will be repeated"
logger.info(f"Schedule item {item.item_id} re-queued after beamline state trip")
def _run_wait_for_parent(self, item: ScheduleItem) -> None:
self._start(item)
self._join_background()
if self._closing.is_set():
return
with self._lock:
if self._abort.is_set():
item.status = ItemStatus.ABORTED
item.report = "Aborted"
else:
item.status = ItemStatus.COMPLETED
item.report = get_action(WAIT_FOR_PARENT).report(None, item, self._ctx)
item.finished_at = time.time()
self._persist_locked()
self._emit_changed()
def _join_background(self) -> None:
"""Wait until the running background item (if any) has finished."""
execution = self._background
if execution is None:
return
while not execution.done.wait(timeout=_POLL_INTERVAL):
if self._closing.is_set():
return
self._background = None
def _wait_for_states(self, item: ScheduleItem) -> bool:
"""Wait until all beamline states are OK. False if paused/aborted/closed meanwhile."""
if self._state_monitor.is_ok():
return True
with self._lock:
blocking = ", ".join(self._state_monitor.blocking_states())
item.report = f"Waiting for beamline states: {blocking}"
self._persist_locked()
self._emit_changed()
ok = self._state_monitor.wait_until_ok(should_abort=self._should_stop_waiting)
with self._lock:
item.report = None
self._persist_locked()
self._emit_changed()
return ok
def _reattach(self, item: ScheduleItem) -> None:
"""Follow a request that is still RUNNING from a previous widget session."""
if not item.request_id:
with self._lock:
item.status = ItemStatus.ABORTED
item.report = "Interrupted (widget was closed)"
item.finished_at = time.time()
self._persist_locked()
self._emit_changed()
return
queue_storage = self._get_queue_storage()
while not self._should_stop_waiting():
queue_item = queue_storage.find_queue_item_by_requestID(item.request_id)
if queue_item is None or not is_queue_item_active(queue_item):
with self._lock:
item.status = ItemStatus.COMPLETED
item.report = item.report or "Done"
item.finished_at = time.time()
self._persist_locked()
self._emit_changed()
return
time.sleep(0.5)
@staticmethod
def _cancel(execution: _Execution) -> None:
cancel = getattr(execution.handle, "cancel", None)
if not callable(cancel):
return
try:
cancel()
except Exception: # pylint: disable=broad-except
logger.exception(f"Failed to cancel schedule item {execution.item.item_id}")
def _scan_info(handle: Any) -> tuple[str | None, int | None]:
try:
scan = handle.scan
except Exception: # pylint: disable=broad-except
return None, None
if scan is None:
return None, None
return getattr(scan, "scan_id", None), getattr(scan, "scan_number", None)
def _last_line(text: str) -> str:
lines = text.strip().splitlines()
return lines[-1] if lines else text
@@ -1,188 +0,0 @@
"""
A small, self-contained utility for "if signal X drops below A, pause; once
it's back above B, resume" (hysteresis) behavior - e.g. auto-pausing scans
while the beam current is too low.
This module knows nothing about schedules, scans, or the rest of this
plugin. It only monitors one BEC device's live readback value
(`MessageEndpoints.device_readback`, the same endpoint the device server
publishes for every monitored device) and emits Qt signals when the value
crosses one of the two configured thresholds. `schedule_widget.py` is the
only place that connects those signals to schedule-specific behavior
(aborting/deferring a scan item) - see its module docstring for how.
"""
from __future__ import annotations
import threading
import time
from bec_lib.endpoints import MessageEndpoints
from bec_lib.logger import bec_logger
from pydantic import BaseModel
from qtpy.QtCore import QObject, Signal
logger = bec_logger.logger
MIN_UPDATE_INTERVAL = 1
class GuardSettings(BaseModel):
"""Persisted configuration for one `SignalGuard`."""
enabled: bool = False
device_name: str | None = None
pause_below: float | None = None
resume_above: float | None = None
class SignalGuard(QObject):
"""
Monitors one device's readback value and reports hysteresis-based
pause/resume crossings.
- `paused` fires the first time the value drops below `pause_below`
(not again while it stays low).
- `resumed` fires the first time it then climbs back above
`resume_above` (not again while it stays high).
A value sitting between the two thresholds never re-triggers either
signal - that gap is the point of using two thresholds instead of one,
so a value oscillating right at a single cutoff wouldn't cause rapid
pause/resume flapping.
Callbacks from `RedisConnector.register()` run on a background
(Redis-listener) thread, not the Qt GUI thread; `paused`/`resumed` are
Qt signals, so connecting to them with the default (auto) connection
type safely marshals delivery onto whatever thread the receiver lives
on - no extra locking needed on the receiving end.
"""
value_update = Signal(float)
paused = Signal(float)
resumed = Signal(float)
def __init__(self, connector, parent=None, dev=None):
super().__init__(parent)
self.dev = dev
self._connector = connector
self._lock = threading.Lock()
self._clear_event = threading.Event()
self._clear_event.set() # not blocking until configured/proven otherwise
self.enabled = False
self.device_name: str | None = None
self.pause_below: float | None = None
self.resume_above: float | None = None
self.current_value: float | None = None
self.units: str = ""
self.prec: int = 3
self._subscribed_endpoint = None
self.last_val_update = time.time()
def configure(self, settings: GuardSettings):
"""(Re)configure and (re)subscribe. Safe to call repeatedly, e.g. after editing settings."""
self._unsubscribe()
self.enabled = settings.enabled
self.device_name = settings.device_name
self.pause_below = settings.pause_below
self.resume_above = settings.resume_above
self.current_value = None
self._clear_event.set()
if (
self.enabled
and self.device_name
and self.pause_below is not None
and self.resume_above is not None
):
self._subscribed_endpoint = MessageEndpoints.device_readback(self.device_name)
self._connector.register(topics=self._subscribed_endpoint, cb=self._on_readback)
description = self.dev[self.device_name].describe()[self.device_name]
self.units = description["units"]
self.prec = description["precision"]
def _unsubscribe(self):
if self._subscribed_endpoint is not None:
try:
self._connector.unregister(topics=self._subscribed_endpoint, cb=self._on_readback)
except Exception: # pylint: disable=broad-except
logger.exception(
f"Failed to unsubscribe SignalGuard from {self._subscribed_endpoint}"
)
self._subscribed_endpoint = None
def _on_readback(self, msg):
device_msg = getattr(msg, "value", None)
if device_msg is None:
return
value = _extract_value(device_msg, self.device_name)
if value is None:
return
crossed_pause = crossed_resume = False
with self._lock:
self.current_value = value
if self._clear_event.is_set():
if value < self.pause_below:
self._clear_event.clear()
crossed_pause = True
elif value > self.resume_above:
self._clear_event.set()
crossed_resume = True
if crossed_pause:
logger.info(
f"SignalGuard: {self.device_name} dropped to {value} (below {self.pause_below}) - pausing."
)
self.paused.emit(value)
elif crossed_resume:
logger.info(
f"SignalGuard: {self.device_name} recovered to {value} (above {self.resume_above}) - resuming."
)
self.resumed.emit(value)
current_time = time.time()
if current_time - self.last_val_update > MIN_UPDATE_INTERVAL:
self.last_val_update = current_time
self.value_update.emit(value)
def is_clear(self) -> bool:
"""True if not currently blocking (disabled, or value above the resume threshold)."""
return (not self.enabled) or self._clear_event.is_set()
def wait_until_clear(self, should_abort, poll_interval: float = 0.5) -> bool:
"""
Blocks the calling (non-GUI) thread until `is_clear()` becomes
True, checking `should_abort()` between polls so an operator abort
can still interrupt the wait. Returns True if it cleared, False if
`should_abort()` returned True first.
"""
if self.is_clear():
return True
while not should_abort():
if self._clear_event.wait(timeout=poll_interval):
return True
return False
def cleanup(self):
self._unsubscribe()
def _extract_value(device_msg, device_name: str | None):
"""
`DeviceMessage.signals` is keyed by signal name, e.g. {"beam_current":
{"value": ..., "timestamp": ...}, ...}. For a simple scalar device the
primary signal is usually named after the device itself; fall back to
the first signal found if not (e.g. a differently-named primary signal
on a compound device).
"""
signals = getattr(device_msg, "signals", None) or {}
if device_name in signals:
return signals[device_name].get("value")
for signal in signals.values():
if "value" in signal:
return signal["value"]
return None
@@ -1,94 +0,0 @@
"""Small settings dialog for `guard.GuardSettings` - kept separate from the guard logic itself."""
from __future__ import annotations
from qtpy.QtWidgets import (
QCheckBox,
QComboBox,
QDialog,
QDialogButtonBox,
QDoubleSpinBox,
QFormLayout,
QLabel,
QMessageBox,
QVBoxLayout,
)
from .guard import GuardSettings
_DSPIN_RANGE = (-1e12, 1e12)
class GuardSettingsDialog(QDialog):
"""Configure (or disable) the auto-pause/resume guard for scan items."""
def __init__(self, settings: GuardSettings, device_names: list[str], parent=None):
super().__init__(parent)
self.setWindowTitle("Auto-pause on signal")
layout = QVBoxLayout(self)
info_label = QLabel(
"If enabled, the currently running scan is aborted as soon as the chosen "
"signal drops below the pause value, and automatically restarted once it "
"rises back above the resume value. Only scan items are affected - device "
"moves and custom/RPC commands are never interrupted by this."
)
info_label.setWordWrap(True)
layout.addWidget(info_label)
form = QFormLayout()
layout.addLayout(form)
self.enabled_check = QCheckBox("Enable auto-pause")
self.enabled_check.setChecked(settings.enabled)
form.addRow("", self.enabled_check)
self.device_combo = QComboBox()
self.device_combo.addItems(device_names)
if settings.device_name:
idx = self.device_combo.findText(settings.device_name)
if idx >= 0:
self.device_combo.setCurrentIndex(idx)
form.addRow("Signal (device)", self.device_combo)
self.pause_below_spin = QDoubleSpinBox()
self.pause_below_spin.setDecimals(4)
self.pause_below_spin.setRange(*_DSPIN_RANGE)
if settings.pause_below is not None:
self.pause_below_spin.setValue(settings.pause_below)
form.addRow("Pause below", self.pause_below_spin)
self.resume_above_spin = QDoubleSpinBox()
self.resume_above_spin.setDecimals(4)
self.resume_above_spin.setRange(*_DSPIN_RANGE)
if settings.resume_above is not None:
self.resume_above_spin.setValue(settings.resume_above)
form.addRow("Resume above", self.resume_above_spin)
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttons.accepted.connect(self._on_accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
def _on_accept(self):
if self.enabled_check.isChecked():
if not self.device_combo.currentText():
QMessageBox.warning(self, "Missing input", "Select a device to monitor.")
return
if self.resume_above_spin.value() <= self.pause_below_spin.value():
QMessageBox.warning(
self,
"Invalid thresholds",
"'Resume above' must be greater than 'Pause below' (hysteresis gap).",
)
return
self.accept()
def result_settings(self) -> GuardSettings:
"""Valid after `exec_()` returns `QDialog.Accepted`."""
return GuardSettings(
enabled=self.enabled_check.isChecked(),
device_name=self.device_combo.currentText() or None,
pause_below=self.pause_below_spin.value(),
resume_above=self.resume_above_spin.value(),
)
@@ -0,0 +1,102 @@
"""
Hide the scan-interlock controls of BEC's stock `BeamlineStateManager`.
The Scheduler embeds `bec_widgets`' own `BeamlineStateManager` unchanged, so that beamline states
are created, edited and removed exactly as everywhere else in BEC. The Scheduler, however, pauses
its items based on the states itself ("pause on state") and does not use the BEC scan interlock.
To avoid confusion, the interlock-related controls are hidden:
- the "Scan interlock" toggle in the manager's toolbar, and
- the per-state "watched by scan interlock" lock button (and the interlock-only "Trigger
ScanInterlock on WARNING state" checkbox in the state's settings panel).
There is no public API for this, so this module touches private attributes of
`BeamlineStateManager` / `BeamlineStatePill`. It is deliberately kept in one place and fails
soft: if `bec_widgets` renames those attributes, the controls simply stay visible and a warning
is logged.
"""
from __future__ import annotations
from bec_lib.logger import bec_logger
from bec_widgets.widgets.services.beamline_states.beamline_state_manager import BeamlineStateManager
# pylint: disable=no-name-in-module # qtpy re-exports are not visible to pylint
from qtpy.QtCore import QTimer
logger = bec_logger.logger
_TOOLBAR_ACTIONS = ("scan_interlock", "scan_interlock_spacer")
_PILL_WIDGETS = ("_interlock_button", "_interlock_warning_checkbox")
def hide_scan_interlock_controls(manager: BeamlineStateManager) -> None:
"""
Hide the scan-interlock controls of `manager` once.
Pills are created lazily, so use `install_scan_interlock_hiding` to keep them hidden.
"""
toolbar = getattr(manager, "_toolbar", None)
for name in _TOOLBAR_ACTIONS:
try:
action = toolbar.components.get_action(name).action
action.setVisible(False)
_hide_toolbar_entry_of(toolbar, action)
except Exception: # pylint: disable=broad-except
logger.warning(
f"Scheduler: could not hide BeamlineStateManager toolbar action {name!r}"
)
try:
toolbar.update_separators() # drop the separator left in front of the hidden button
except Exception: # pylint: disable=broad-except
pass
for pill in list(getattr(manager, "_state_pills", {}).values()):
for attr in _PILL_WIDGETS:
widget = getattr(pill, attr, None)
if widget is None:
logger.warning(f"Scheduler: BeamlineStatePill has no attribute {attr!r} to hide")
continue
widget.setVisible(False)
def _hide_toolbar_entry_of(toolbar, action) -> None:
"""
Hide the toolbar entry that displays `action`.
Actions with a text label are not added to the toolbar directly: the toolbar holds a
`QToolButton` (with `action` as its default action, or the widget itself for widget actions)
wrapped in its own `QWidgetAction`. That wrapper must be hidden for the button to disappear.
"""
for entry in toolbar.actions():
widget = toolbar.widgetForAction(entry)
if widget is None:
continue
default_action = getattr(widget, "defaultAction", lambda: None)()
if widget is action or default_action is action:
entry.setVisible(False)
def install_scan_interlock_hiding(manager: BeamlineStateManager) -> None:
"""
Hide the scan-interlock controls now and every time the manager (re)creates state pills.
Pills are persistent editors of the manager's list model, created when rows are inserted;
hiding is therefore deferred to the next event-loop iteration, after the editors exist.
"""
def _schedule_hide(*_):
QTimer.singleShot(0, manager, lambda: hide_scan_interlock_controls(manager))
model = getattr(manager, "_model", None)
if model is None:
logger.warning(
"Scheduler: BeamlineStateManager has no '_model'; interlock hiding is partial"
)
else:
model.rowsInserted.connect(_schedule_hide)
model.modelReset.connect(_schedule_hide)
model.layoutChanged.connect(_schedule_hide)
model.dataChanged.connect(_schedule_hide)
hide_scan_interlock_controls(manager)
_schedule_hide()
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,170 @@
"""
Persisted data model of the Scheduler widget.
Everything in here is a plain pydantic model. The whole `Schedule` document is stored in Redis as
the `.value` payload of a `bec_lib.messages.VariableMessage` (see `endpoints.schedule`) and can be
saved to / loaded from a JSON file. All fields must therefore stay JSON-serialisable; in
particular, a `ScheduleItem` describes *what* to run as a registry key (`action`) plus plain
parameters (`params`) - never as executable code (see `actions.py`).
"""
from __future__ import annotations
import uuid
from enum import Enum
from typing import Any
from pydantic import AliasChoices, BaseModel, ConfigDict, Field, ValidationError, field_validator
class ItemStatus(str, Enum):
"""Execution status of one schedule item."""
PENDING = "pending"
RUNNING = "running"
COMPLETED = "completed"
FAILED = "failed"
ABORTED = "aborted"
class NotificationTarget(str, Enum):
"""BEC messaging service used to send schedule notifications."""
SCILOG = "scilog"
SIGNAL = "signal"
class NotificationSettings(BaseModel):
"""Per-schedule notification preferences (see `notifications.py` for the send logic)."""
model_config = ConfigDict(extra="ignore", populate_by_name=True)
enabled: bool = False
notify_scan: bool = True
notify_move: bool = True
# Device actions and beamline tools (digital twin, auto-gain, ...). Older schedules stored
# this flag as "notify_rpc".
notify_device: bool = Field(
default=True, validation_alias=AliasChoices("notify_device", "notify_rpc")
)
target: NotificationTarget = NotificationTarget.SCILOG
events: list[ItemStatus] = Field(default_factory=list)
signal_number: str | None = None # a phone number, or a pre-registered Signal scope
@field_validator("target", mode="before")
@classmethod
def _map_legacy_target(cls, value: Any) -> Any:
"""Map targets that are no longer supported (e.g. the removed "teams") to SciLog."""
valid = {target.value for target in NotificationTarget}
if isinstance(value, NotificationTarget):
return value
if not isinstance(value, str) or value not in valid:
return NotificationTarget.SCILOG
return value
class ScheduleItem(BaseModel):
"""
One entry of the schedule: what to run, how to run it, and its execution bookkeeping.
Attributes:
item_id: Stable unique id, used to address the item from the UI and over RPC.
action: Key of the action in the function registry (`actions.ACTIONS`).
params: JSON-serialisable keyword arguments passed to the action.
status: Current execution status.
wait_for_completion: If False, the item is started and the schedule immediately
continues with the following items ("background item"). The following items are
shown indented until a "Wait until parent has completed" item, the next background
item or the end of the schedule.
pause_on_failure: Pause the schedule if this item fails.
pause_on_state: Only start this item while all beamline states are VALID or WARNING.
A gated scan that is running when a state becomes INVALID is cancelled and repeated
once the states have recovered.
report: Short human-readable result, shown in the "Report" column.
request_id / scan_id / scan_number: Set for items that submit a request to the BEC
scan server; used to re-attach to a still-running request after a widget restart.
error: Full traceback of the last failure.
started_at / finished_at: Unix timestamps of the last execution.
"""
model_config = ConfigDict(extra="ignore")
item_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
action: str
params: dict[str, Any] = Field(default_factory=dict)
status: ItemStatus = ItemStatus.PENDING
wait_for_completion: bool = True
pause_on_failure: bool = False
pause_on_state: bool = False
report: str | None = None
request_id: str | None = None
scan_id: str | None = None
scan_number: int | None = None
error: str | None = None
started_at: float | None = None
finished_at: float | None = None
def reset_execution(self) -> None:
"""Clear all execution bookkeeping and mark the item PENDING again."""
self.status = ItemStatus.PENDING
self.report = None
self.request_id = None
self.scan_id = None
self.scan_number = None
self.error = None
self.started_at = None
self.finished_at = None
def definition(self) -> dict[str, Any]:
"""The user-defined part of the item (no id, no execution state), e.g. for copy/paste."""
return {
"action": self.action,
"params": dict(self.params),
"wait_for_completion": self.wait_for_completion,
"pause_on_failure": self.pause_on_failure,
"pause_on_state": self.pause_on_state,
}
class Schedule(BaseModel):
"""The full persisted state of one named schedule."""
model_config = ConfigDict(extra="ignore")
schedule_name: str
items: list[ScheduleItem] = Field(default_factory=list)
is_running: bool = False
notes: str = ""
notifications: NotificationSettings = Field(default_factory=NotificationSettings)
def is_legacy_schedule(data: Any) -> bool:
"""
True if `data` looks like a schedule written by the old, eval-based Scheduler widget
(items described by a `command` string instead of an `action` registry key).
"""
if not isinstance(data, dict):
return False
items = data.get("items") or []
return any(
isinstance(item, dict) and "command" in item and "action" not in item for item in items
)
def schedule_from_document(data: Any) -> tuple[Schedule | None, str | None]:
"""
Validate a persisted schedule document (from Redis or a JSON file) without raising.
Returns:
`(schedule, None)` if the document is valid, otherwise `(None, problem)` where `problem`
is a short human-readable description, e.g. "an old schedule format".
"""
if is_legacy_schedule(data):
return None, "an old schedule format"
try:
return Schedule.model_validate(data), None
except (ValidationError, TypeError, KeyError, AttributeError) as exc:
return None, f"an invalid schedule ({exc.__class__.__name__})"
@@ -1,12 +1,10 @@
"""
Settings dialog for `notifications.NotificationSettings` - kept separate
from the send logic itself (`notifications.py`).
"""
"""Settings dialog for the schedule notifications (`models.NotificationSettings`)."""
from __future__ import annotations
from bec_lib.logger import bec_logger
# pylint: disable=no-name-in-module # qtpy re-exports are not visible to pylint
from qtpy.QtWidgets import (
QButtonGroup,
QCheckBox,
QComboBox,
QDialog,
@@ -15,21 +13,18 @@ from qtpy.QtWidgets import (
QLabel,
QMessageBox,
QPushButton,
QRadioButton,
QVBoxLayout,
)
from .enums import ScheduleItemStatus
from .notifications import NotificationSettings, NotificationTarget, send_notification
logger = bec_logger.logger
from .models import ItemStatus, NotificationSettings, NotificationTarget
from .notifications import send_notification
def _service_state(client, name: str) -> tuple[bool, list[str]]:
"""
Best-effort read of a messaging service's enabled/scopes state (see
the module docstring in notifications.py for why this is the only
introspection available). Never raises - a client without `messaging`
set up yet just looks like "not enabled, no scopes".
Best-effort read of a messaging service's enabled flag and registered scopes. BEC offers no
public accessor for this, hence the private attributes. Never raises.
"""
messaging = getattr(client, "messaging", None)
service = getattr(messaging, name, None) if messaging is not None else None
@@ -38,8 +33,21 @@ def _service_state(client, name: str) -> tuple[bool, list[str]]:
return bool(getattr(service, "_enabled", False)), sorted(getattr(service, "_scopes", set()))
def _dim_label(text: str) -> QLabel:
label = QLabel(text)
label.setStyleSheet("color: gray;")
label.setWordWrap(True)
return label
class NotificationSettingsDialog(QDialog):
"""Choose whether/where/for-which-item-types finish/fail notifications are sent."""
"""Choose whether, where and for which items/events notifications are sent."""
_EVENTS = (
(ItemStatus.COMPLETED, "Completed"),
(ItemStatus.ABORTED, "Aborted"),
(ItemStatus.FAILED, "Failed"),
)
def __init__(self, settings: NotificationSettings, client, parent=None):
super().__init__(parent)
@@ -48,12 +56,12 @@ class NotificationSettingsDialog(QDialog):
self.setMinimumWidth(380)
layout = QVBoxLayout(self)
info_label = QLabel(
"Sends a message through the selected BEC messaging service whenever a "
"schedule item finishes or fails."
info = QLabel(
"Sends a message through the selected BEC messaging service when the schedule "
"starts or stops, and when an item finishes."
)
info_label.setWordWrap(True)
layout.addWidget(info_label)
info.setWordWrap(True)
layout.addWidget(info)
self.enabled_check = QCheckBox("Send notifications")
self.enabled_check.setChecked(settings.enabled)
@@ -65,51 +73,34 @@ class NotificationSettingsDialog(QDialog):
self.scan_check.setChecked(settings.notify_scan)
self.move_check = QCheckBox("Movements")
self.move_check.setChecked(settings.notify_move)
self.rpc_check = QCheckBox("RPC / custom commands")
self.rpc_check.setChecked(settings.notify_rpc)
for check in (self.scan_check, self.move_check, self.rpc_check):
self.device_check = QCheckBox("Device actions and beamline tools")
self.device_check.setChecked(settings.notify_device)
for check in (self.scan_check, self.move_check, self.device_check):
kind_layout.addWidget(check)
layout.addWidget(kind_box)
target_box = QGroupBox("Send via")
target_layout = QVBoxLayout(target_box)
self.scilog_check = QCheckBox("SciLog")
self.teams_check = QCheckBox("Microsoft Teams")
self.signal_check = QCheckBox("Signal Messenger")
for check in (self.scilog_check, self.teams_check, self.signal_check):
target_layout.addWidget(check)
layout.addWidget(target_box)
event_box = QGroupBox("Send on")
event_box = QGroupBox("Send when an item is")
event_layout = QVBoxLayout(event_box)
self.completed_check = QCheckBox("Completed")
self.aborted_check = QCheckBox("Aborted")
self.failed_check = QCheckBox("Failed")
for check in (self.completed_check, self.aborted_check, self.failed_check):
self._event_checks: dict[ItemStatus, QCheckBox] = {}
for status, label in self._EVENTS:
check = QCheckBox(label)
check.setChecked(status in settings.events)
event_layout.addWidget(check)
self._event_checks[status] = check
layout.addWidget(event_box)
# Teams: contact/channel can only be a scope an admin has already
# registered for the deployment - there's no way to address an
# arbitrary Teams user from the client, so this is a dropdown, not
# free text (see notifications.py's module docstring).
self.teams_box = QGroupBox("Teams settings")
teams_layout = QVBoxLayout(self.teams_box)
teams_enabled, teams_scopes = _service_state(client, "teams")
self.teams_combo = QComboBox()
self.teams_combo.addItems(teams_scopes)
self.teams_combo.setEnabled(teams_enabled)
teams_layout.addWidget(QLabel("Contact or channel"))
teams_layout.addWidget(self.teams_combo)
if not teams_enabled:
teams_layout.addWidget(_dim_label("Teams messaging is not enabled for this session."))
elif not teams_scopes:
teams_layout.addWidget(_dim_label("No Teams contacts/channels are registered."))
layout.addWidget(self.teams_box)
target_box = QGroupBox("Send via")
target_layout = QVBoxLayout(target_box)
self.scilog_radio = QRadioButton("SciLog")
self.signal_radio = QRadioButton("Signal Messenger")
self._target_group = QButtonGroup(self)
for radio in (self.scilog_radio, self.signal_radio):
self._target_group.addButton(radio)
target_layout.addWidget(radio)
layout.addWidget(target_box)
# Signal: a raw phone number works directly (BEC normalizes it -
# see the docs), so this is an editable combo box: type a number,
# or pick a pre-registered scope if any exist.
# Signal: a raw phone number works directly, so this is an editable combo box offering
# any pre-registered scopes as suggestions.
self.signal_box = QGroupBox("Signal settings")
signal_layout = QVBoxLayout(self.signal_box)
signal_enabled, signal_scopes = _service_state(client, "signal")
@@ -117,115 +108,64 @@ class NotificationSettingsDialog(QDialog):
self.signal_combo.setEditable(True)
self.signal_combo.addItems(signal_scopes)
self.signal_combo.setEnabled(signal_enabled)
signal_layout.addWidget(QLabel("Phone number or contact"))
self.signal_combo.setEditText("")
self.signal_combo.setEditText(settings.signal_number or "")
self.signal_combo.lineEdit().setPlaceholderText("e.g. +41791234567")
signal_layout.addWidget(QLabel("Phone number or contact"))
signal_layout.addWidget(self.signal_combo)
if not signal_enabled:
signal_layout.addWidget(_dim_label("Signal messaging is not enabled for this session."))
layout.addWidget(self.signal_box)
# pre-fill from the persisted settings
{
NotificationTarget.SCILOG: self.scilog_check,
NotificationTarget.TEAMS: self.teams_check,
NotificationTarget.SIGNAL: self.signal_check,
}.get(settings.target, self.scilog_check).setChecked(True)
for event in settings.events:
{
ScheduleItemStatus.COMPLETED: self.completed_check,
ScheduleItemStatus.ABORTED: self.aborted_check,
ScheduleItemStatus.FAILED: self.failed_check,
}.get(event).setChecked(True)
if settings.teams_scope:
idx = self.teams_combo.findText(settings.teams_scope)
if idx >= 0:
self.teams_combo.setCurrentIndex(idx)
if settings.signal_number:
self.signal_combo.setEditText(settings.signal_number)
self.scilog_check.toggled.connect(lambda *_: self._sync_target_widgets(self.scilog_check))
self.teams_check.toggled.connect(lambda *_: self._sync_target_widgets(self.teams_check))
self.signal_check.toggled.connect(lambda *_: self._sync_target_widgets(self.signal_check))
if settings.target == NotificationTarget.SIGNAL:
self.signal_radio.setChecked(True)
else:
self.scilog_radio.setChecked(True)
self.signal_radio.toggled.connect(self._sync_target_widgets)
self.test_btn = QPushButton("Send test message")
self.test_btn.clicked.connect(self._on_test_clicked)
layout.addWidget(self.test_btn)
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttons = QDialogButtonBox(
QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
self._sync_target_widgets()
def _sync_target_widgets(self, current_button: QCheckBox = None):
if current_button is None:
for button in [self.scilog_check, self.teams_check, self.signal_check]:
if button.isChecked():
current_button = button
break
if current_button.isChecked():
for button in [self.scilog_check, self.teams_check, self.signal_check]:
if button != current_button:
button.setChecked(False)
if current_button == self.teams_check:
self.teams_box.setVisible(True)
self.signal_box.setVisible(False)
elif current_button == self.signal_check:
self.teams_box.setVisible(False)
self.signal_box.setVisible(True)
else:
self.teams_box.setVisible(False)
self.signal_box.setVisible(False)
self.layout().activate()
self.adjustSize()
def _sync_target_widgets(self, *_) -> None:
self.signal_box.setVisible(self.signal_radio.isChecked())
self.layout().activate()
self.adjustSize()
def _current_settings(self) -> NotificationSettings:
if self.scilog_check.isChecked():
target = NotificationTarget.SCILOG
elif self.teams_check.isChecked():
target = NotificationTarget.TEAMS
elif self.signal_check.isChecked():
target = NotificationTarget.SIGNAL
else:
raise ValueError(f"Target {target} not supported")
events = []
if self.completed_check.isChecked():
events.append(ScheduleItemStatus.COMPLETED)
if self.aborted_check.isChecked():
events.append(ScheduleItemStatus.ABORTED)
if self.failed_check.isChecked():
events.append(ScheduleItemStatus.FAILED)
target = (
NotificationTarget.SIGNAL
if self.signal_radio.isChecked()
else NotificationTarget.SCILOG
)
return NotificationSettings(
enabled=self.enabled_check.isChecked(),
notify_scan=self.scan_check.isChecked(),
notify_move=self.move_check.isChecked(),
notify_rpc=self.rpc_check.isChecked(),
notify_device=self.device_check.isChecked(),
target=target,
events=events,
teams_scope=self.teams_combo.currentText().strip() or None,
events=[status for status, check in self._event_checks.items() if check.isChecked()],
signal_number=self.signal_combo.currentText().strip() or None,
)
def _on_test_clicked(self):
settings = self._current_settings()
def _on_test_clicked(self) -> None:
try:
send_notification(self._client, settings, "Test message from the BEC schedule widget.")
send_notification(
self._client, self._current_settings(), "Test message from the BEC Scheduler."
)
except Exception as exc: # pylint: disable=broad-except
QMessageBox.critical(self, "Test message failed", str(exc))
return
QMessageBox.information(self, "Test message sent", "The test message was sent.")
def result_settings(self) -> NotificationSettings:
"""Valid after `exec_()` returns `QDialog.Accepted`."""
"""The edited settings; valid after `exec_()` returned `QDialog.Accepted`."""
return self._current_settings()
def _dim_label(text: str) -> QLabel:
label = QLabel(text)
label.setStyleSheet("color: gray;")
label.setWordWrap(True)
return label
@@ -1,158 +1,113 @@
"""
A small, self-contained "tell the user when something finished/failed"
feature, independent of scheduling/execution logic.
"Tell the user when something finished/failed" - independent of the scheduling logic.
Sends through BEC's own `client.messaging` container
(`bec_lib.messaging_services.MessagingContainer`, exposed as `bec.messaging`
in the IPython client) - the same mechanism documented at
https://bec.readthedocs.io/latest/how-to/general/send-messages-to-signal.html
and
Messages are sent through BEC's own messaging services (`client.messaging`), see
https://bec.readthedocs.io/latest/how-to/general/send-messages-to-signal.html and
https://bec.readthedocs.io/latest/how-to/general/send-messages-to-scilog.html:
bec.messaging.signal.new("Beamline checks completed.").send(scope="+41791234567")
bec.messaging.scilog.new("Beamline checks completed.").send()
bec.messaging.teams.new("Beamline checks completed.").send(scope=<registered scope>)
bec.messaging.signal.new("Beamline checks completed.").send(scope="+41791234567")
Notes on each service, read directly from `bec_lib.messaging_services`
rather than assumed:
- **SciLog** needs no scope: it posts to the logbook of the currently active pgroup.
- **Signal** accepts a raw phone number as scope (BEC normalises it, defaulting to the Swiss
country code) or the name of a pre-registered scope.
- **SciLog** needs no `scope` - it posts to the logbook of the currently
active pgroup automatically.
- **Signal** accepts a raw phone number as `scope` (BEC normalizes it,
defaulting to the Swiss country code for numbers without one - see the
docs above) *or* a pre-registered scope name for a group.
- **Teams** is a plain `MessagingService` with no Teams-specific methods:
a contact/channel can only be addressed by a `scope` an admin has
already registered for the deployment (`service._scopes`) - there is no
way to address an arbitrary Teams user/email directly from the client.
This is why the Teams UI in `notification_dialog.py` is a dropdown of
known scopes rather than free text, while Signal's is free text (with
any registered scopes offered as suggestions).
`client.messaging.<service>._enabled` / `._scopes` are the only
introspection available (no public accessor exists at the time of
writing) - used here and in the dialog to grey out a target that isn't
configured for the current session instead of only failing at send time.
The settings model (`NotificationSettings`) lives in `models.py`, as it is persisted with the
schedule.
"""
from __future__ import annotations
from enum import Enum
from typing import Literal
from bec_lib.logger import bec_logger
from pydantic import BaseModel
from .enums import ScheduleItemStatus
from .actions import ACTIONS
from .models import NotificationSettings, NotificationTarget, ScheduleItem
logger = bec_logger.logger
ScheduleState = Literal[
"started", "finished", "aborted", "paused", "paused_on_failure", "widget_closed"
]
class NotificationTarget(str, Enum):
SCILOG = "scilog"
TEAMS = "teams"
SIGNAL = "signal"
_STATE_TEXT: dict[str, str] = {
"started": "has started",
"finished": "has finished",
"aborted": "was aborted",
"paused": "was paused",
"paused_on_failure": "was paused because an item failed",
"widget_closed": "has stopped prematurely because the widget was closed",
}
class NotificationSettings(BaseModel):
"""Persisted per-schedule notification preferences."""
enabled: bool = False
notify_scan: bool = True
notify_move: bool = True
# "custom" is what this plugin calls the free-text tab (see
# item_dialog.py) - it covers RPC calls to other widgets as well as
# any hand-typed command, so it's exposed to the user as "RPC".
notify_rpc: bool = True
target: NotificationTarget = NotificationTarget.SCILOG
events: list[ScheduleItemStatus] = []
teams_scope: str | None = None # a pre-registered Teams scope (channel/contact)
signal_number: str | None = None # a phone number, or a pre-registered Signal scope
def _enabled_for_kind(settings: NotificationSettings, kind: str) -> bool:
if not settings.enabled:
return False
def _enabled_for_category(settings: NotificationSettings, category: str) -> bool:
return {
"scan": settings.notify_scan,
"move": settings.notify_move,
"custom": settings.notify_rpc,
}.get(kind, False)
"device": settings.notify_device,
}.get(category, False)
def send_notification(client, settings: NotificationSettings, text: str) -> None:
"""
Send `text` through whichever service `settings.target` selects.
Send `text` through the service selected by `settings.target`.
Raises on failure (no target selected, missing Teams scope/Signal
number, the target service not enabled for this session, ...) -
callers that want a fire-and-forget send should catch around this.
`notify_item_finished` does; the dialog's "Send test message" button
deliberately does not, so the operator sees exactly what went wrong.
Raises:
ValueError: If the target is not configured (e.g. no Signal number).
Exception: Whatever the BEC messaging service raises. Callers that want a
fire-and-forget send must catch it; the dialog's "Send test message" button
deliberately does not, so the operator sees what went wrong.
"""
if settings.target == NotificationTarget.SCILOG:
client.messaging.scilog.new(text).send()
elif settings.target == NotificationTarget.TEAMS:
if not settings.teams_scope:
raise ValueError("No Teams contact/channel selected.")
client.messaging.teams.new(text).send(scope=settings.teams_scope)
elif settings.target == NotificationTarget.SIGNAL:
if not settings.signal_number:
raise ValueError("No Signal phone number/contact set.")
client.messaging.signal.new(text).send(scope=settings.signal_number)
else:
raise ValueError("No notification target selected.")
raise ValueError(f"Unsupported notification target {settings.target!r}.")
def notify_item_finished(
client,
kind: str,
command: str,
scan_number: str,
final_status: ScheduleItemStatus,
settings: NotificationSettings,
error: str | None = None,
):
client, settings: NotificationSettings, item: ScheduleItem, description: str
) -> None:
"""
Sends a message if notifications are enabled for `kind` and a target
is configured. Never raises - a notification failing to send should
not affect schedule execution.
Send a message about a finished schedule item, if notifications are enabled for the item's
category and final status. Never raises.
Args:
client: BEC client.
settings: Notification settings of the schedule.
item: The finished item (COMPLETED, FAILED or ABORTED).
description: Human-readable description of the item (the "Command" column text).
"""
if not _enabled_for_kind(settings, kind):
spec = ACTIONS.get(item.action)
if not settings.enabled or spec is None or not _enabled_for_category(settings, spec.category):
return
if final_status not in settings.events:
if item.status not in settings.events:
return
status_word = final_status.name
text = f"**BEC Scheduler Widget**\nStatus: {kind} {status_word}"
if scan_number is not None:
text = text + f"\nScan number: {scan_number}"
text = text + f"\n\nCommand: {command}"
if error:
text += f"\n\n{error.strip().splitlines()[-1]}"
text = f"**BEC Scheduler**\n{spec.label} {item.status.name.lower()}"
if item.scan_number is not None:
text += f"\nScan number: {item.scan_number}"
text += f"\n\n{description}"
if item.report:
text += f"\n\n{item.report}"
_send_safe(client, settings, text)
try:
send_notification(client, settings, text)
except Exception: # pylint: disable=broad-except
logger.exception(f"Failed to send schedule notification via {settings.target.value}")
def notify_schedule_state(
client, settings: NotificationSettings, schedule_name: str, state: ScheduleState
) -> None:
"""Send a message when the schedule starts or stops (if notifications are on). Never raises."""
if not settings.enabled:
return
text = f'**BEC Scheduler**\nSchedule "{schedule_name}" {_STATE_TEXT.get(state, state)}'
_send_safe(client, settings, text)
def notify_schedule_state(client, settings, schedule_name, state):
"""
Sends a message if notifications are enabled and a schedule is started or stopped.
Never raises - a notification failing to send should not affect schedule execution.
"""
text = f'**BEC Scheduler Widget**\nSchedule "{schedule_name}" '
if state == "started":
text = text + "has started"
elif state == "aborted":
text = text + "was aborted"
elif state == "widget_closed":
text = text + "has finished prematurely because widget was closed"
elif state == "finished":
text = text + "has finished"
else:
logger.warning(f"Unknown schedule state {state}")
def _send_safe(client, settings: NotificationSettings, text: str) -> None:
try:
send_notification(client, settings, text)
except Exception: # pylint: disable=broad-except
@@ -1,159 +0,0 @@
from bec_widgets.utils.colors import get_accent_colors
from qtpy.QtCore import QModelIndex, QSize, Qt, Signal
# pylint: disable=E0611
from qtpy.QtGui import QKeySequence
from qtpy.QtWidgets import QHeaderView, QPushButton, QStyle, QStyledItemDelegate, QTableView
_ROW_MARGIN = 2 # total vertical padding (top+bottom) added around the text block
class _MultilineTextDelegate(QStyledItemDelegate):
"""
Paints and sizes a cell whose DisplayRole text may contain literal
'\\n' line breaks (schedule item labels are built with explicit line
breaks, e.g. the digital-twin config summary). The base
QStyledItemDelegate only reliably shows a single line, so without this
a multi-line label got clipped once rows stopped auto-sizing the way
QListWidgetItem used to. `sizeHint()` reports the full multi-line
height so the view's ResizeToContents row mode can actually fit it.
Selection is painted here with `option.palette.highlight()` - the
same approach BecLogTableView's `_LogCellDelegate` uses - so the row
gets the theme's native (blue) highlight color instead of whatever a
stylesheet might otherwise hardcode.
"""
def paint(self, painter, option, index):
painter.save()
if option.state & QStyle.StateFlag.State_Selected:
painter.fillRect(option.rect, option.palette.highlight())
painter.setPen(option.palette.highlightedText().color())
else:
painter.setPen(option.palette.text().color())
painter.setFont(option.font)
text = index.data(Qt.ItemDataRole.DisplayRole) or ""
rect = option.rect.adjusted(4, _ROW_MARGIN // 2, -4, -(_ROW_MARGIN // 2))
# painter.drawText(rect, int(Qt.TextFlag.TextWordWrap), text)
painter.drawText(
rect,
int(
Qt.TextFlag.TextWordWrap
| Qt.AlignmentFlag.AlignLeft
| Qt.AlignmentFlag.AlignVCenter
),
text,
)
painter.restore()
def sizeHint(self, option, index):
text = index.data(Qt.ItemDataRole.DisplayRole) or ""
lines = text.count("\n") + 1
height = option.fontMetrics.lineSpacing() * lines + _ROW_MARGIN
width = super().sizeHint(option, index).width()
return QSize(width, height)
class MyTableView(QTableView):
deletePressed = Signal()
emptySpaceClicked = Signal()
copyPressed = Signal()
pastePressed = Signal()
# Column layout is fixed: 0 = status icon, 1 = text (stretches), 2 = pause-on-failure icon.
TEXT_COLUMN = 1
def __init__(self, parent=None, status_col_width: int = 60, pause_col_width: int = 130):
super().__init__(parent)
self._status_col_width = status_col_width
self._pause_col_width = pause_col_width
self.setSelectionBehavior(QTableView.SelectionBehavior.SelectRows)
self.setSelectionMode(QTableView.SelectionMode.SingleSelection)
self.setEditTriggers(QTableView.EditTrigger.NoEditTriggers)
self.setShowGrid(False)
self.setWordWrap(True)
self.setItemDelegateForColumn(self.TEXT_COLUMN, _MultilineTextDelegate(self))
self.verticalHeader().hide()
# ResizeToContents (not Fixed) so a row grows to fit however many
# lines its text cell reports via the delegate's sizeHint above -
# this is what lets multi-line item text show in full again.
self.verticalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
# No `:selected` rule here on purpose - leaving it out lets Qt fall
# back to the palette highlight color (blue) for selected rows,
# matching BecLogTableView instead of a hardcoded dark gray.
# self.setStyleSheet("""
# QTableView::item {
# border-bottom: 1px solid #444444;
# padding: 4px;
# }
# """)
def configure_columns(self):
header = self.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed)
header.setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
header.setSectionResizeMode(2, QHeaderView.ResizeMode.Fixed)
header.resizeSection(0, self._status_col_width)
header.resizeSection(2, self._pause_col_width)
header.setStretchLastSection(False)
header.setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Delete and self.currentIndex().isValid():
self.deletePressed.emit()
event.accept()
return
if event.matches(QKeySequence.StandardKey.Copy) and self.currentIndex().isValid():
self.copyPressed.emit()
event.accept()
return
if event.matches(QKeySequence.StandardKey.Paste):
self.pastePressed.emit()
event.accept()
return
super().keyPressEvent(event)
def mousePressEvent(self, event):
if (
event.button() == Qt.LeftButton
and not self.indexAt(event.position().toPoint()).isValid()
):
self.clearSelection()
self.setCurrentIndex(QModelIndex())
self.emptySpaceClicked.emit()
return
super().mousePressEvent(event)
class MyButton(QPushButton):
def __init__(self, text="", color="default", parent=None):
self.color = color
super().__init__(text, parent)
self.apply_theme()
def apply_theme(self):
if self.isEnabled():
colors = get_accent_colors()
color = getattr(colors, self.color).name()
self.setStyleSheet(f"QPushButton {{ background-color: {color}; color: white; }}")
else:
self.setStyleSheet(
"QPushButton {{background-color: rgb(120, 120, 120); color: white;}}"
)
def setEnabled(self, enable: bool = True):
super().setEnabled(enable)
self.apply_theme()
@@ -1,70 +0,0 @@
"""
Plain (non-BECMessage) data model for one schedule entry and the schedule
as a whole.
These are ordinary pydantic models used only client-side, for validation
and convenience. They are never sent over Redis as their own type - only
ever as the `.value` payload of a `bec_lib.messages.VariableMessage` (see
`endpoints.schedule` for why).
"""
from __future__ import annotations
from enum import Enum
from typing import Literal
from pydantic import BaseModel, Field
from .enums import ScheduleItemStatus
from .guard import GuardSettings
from .notifications import NotificationSettings
# Which tab of the Add/Edit dialog built `command`, and therefore how to
# re-open that dialog pre-filled with the same values for editing. "custom"
# covers hand-typed text (including RPC calls to other widgets), which has
# no structured `form_state` to restore beyond the raw text itself.
ScheduleItemKind = Literal["scan", "move", "custom"]
class ScheduleItem(BaseModel):
"""A single command in the schedule, plus its execution bookkeeping."""
item_id: str
command: str
status: ScheduleItemStatus = ScheduleItemStatus.PENDING
# How `command` was produced, and (for "scan"/"move") the structured
# inputs behind it, so the Add/Edit dialog can be reopened pre-filled
# instead of asking the user to re-type everything. `command` itself
# remains the single source of truth actually evaluated at execution
# time - `kind`/`form_state` only drive the UI.
kind: ScheduleItemKind = "custom"
form_state: dict | None = None
pause_on_failure: bool
# Bookkeeping used to reconnect to a submission that is still (or was)
# in flight on the BEC scan/device server, after this widget has been
# closed and reopened.
request_id: str | None = None
scan_id: str | None = None
scan_number: int | None = None
error: str | None = None
started_at: float | None = None
finished_at: float | None = None
class Schedule(BaseModel):
"""The full, persisted state of one schedule-widget instance."""
schedule_name: str
items: list[ScheduleItem] = Field(default_factory=list)
is_running: bool = False
notes: str = ""
# Settings for two independent, optional features (see notifications.py
# and guard.py) - persisted here alongside the schedule itself so they
# survive a widget restart too, but their *logic* lives entirely in
# those separate modules; this is just where their settings are stored.
notifications: NotificationSettings = Field(default_factory=NotificationSettings)
guard: GuardSettings = Field(default_factory=GuardSettings)
@@ -1,35 +1,99 @@
"""
Pure bookkeeping over a list of `ScheduleItem`s - no Qt, no locking, no I/O.
Kept separate from `schedule_widget.py` for the same reason `guard.py` and
`notifications.py` are: it's testable on its own, and the widget should
only be responsible for Qt/orchestration, not figuring out which item runs
next.
Pure bookkeeping over a list of `ScheduleItem`s - no Qt, no locking, no I/O - so that it can be
unit-tested on its own. Callers (the widget and the executor) hold their own lock while calling
these functions.
The one invariant everything here assumes and preserves: at any moment, a
schedule's items form a (possibly empty) prefix that is no longer PENDING
(RUNNING - at most one, the one currently executing - COMPLETED, FAILED or
ABORTED), followed by a suffix that is entirely PENDING. `ScheduleWidget`
is responsible for only ever mutating the PENDING suffix (see its module
docstring) and for calling these functions while holding its lock; nothing
here does its own locking.
Two concepts are handled here:
**Protected prefix.** Items are executed from top to bottom. Everything before the first PENDING
item has already started or finished (RUNNING, COMPLETED, FAILED, ABORTED) and must not be
moved, edited or deleted; new items can never be inserted before it. Because of background items
(see below), several items of that prefix may be RUNNING at the same time.
**Blocks.** An item with `wait_for_completion=False` ("background item") is started and the
schedule immediately continues with the following items, which form its *block* and are shown
indented. A block ends
- with a "Wait until parent has completed" item (which belongs to the block, as its last child),
- implicitly right before the next background item (no nesting), or
- at the end of the schedule.
The block structure is derived from the item order every time it is needed and never stored, so
moving, adding or deleting items automatically updates which block an item belongs to.
"""
from __future__ import annotations
from typing import Literal
from enum import Enum
from bec_lib.logger import bec_logger
from .actions import WAIT_FOR_PARENT
from .models import ItemStatus, ScheduleItem
from .schedule_item import ScheduleItem, ScheduleItemStatus
logger = bec_logger.logger
class BlockRole(str, Enum):
"""Position of an item relative to the block structure (used for drawing guide lines)."""
NONE = "none" # not part of a block
PARENT = "parent" # background item that opens a block
PARENT_EMPTY = "parent_empty" # background item without any children
CHILD = "child" # inside a block
LAST_CHILD = "last_child" # last item of a block
def opens_block(item: ScheduleItem) -> bool:
"""True if the item is a background item, i.e. starts a block of following items."""
return not item.wait_for_completion and item.action != WAIT_FOR_PARENT
def block_parents(items: list[ScheduleItem]) -> list[int | None]:
"""
For every item, the index of the background item whose block it belongs to.
Returns:
A list with one entry per item: the index of its parent, or None if the item is not
inside a block. Background items themselves are never inside a block.
"""
parents: list[int | None] = []
current: int | None = None
for idx, item in enumerate(items):
if opens_block(item):
current = idx
parents.append(None)
elif current is not None:
parents.append(current)
if item.action == WAIT_FOR_PARENT:
current = None
else:
parents.append(None)
return parents
def item_depths(items: list[ScheduleItem]) -> list[int]:
"""Indentation level of every item: 1 inside a block, 0 otherwise."""
return [0 if parent is None else 1 for parent in block_parents(items)]
def block_roles(items: list[ScheduleItem]) -> list[BlockRole]:
"""The `BlockRole` of every item, e.g. for drawing the block guide lines in the table."""
parents = block_parents(items)
roles: list[BlockRole] = []
for idx, item in enumerate(items):
next_parent = parents[idx + 1] if idx + 1 < len(items) else None
if opens_block(item):
roles.append(BlockRole.PARENT if next_parent == idx else BlockRole.PARENT_EMPTY)
elif parents[idx] is not None:
last = next_parent != parents[idx]
roles.append(BlockRole.LAST_CHILD if last else BlockRole.CHILD)
else:
roles.append(BlockRole.NONE)
return roles
def protected_prefix_length(items: list[ScheduleItem]) -> int:
"""How many items, from the start, are no longer PENDING."""
"""Number of leading items that are no longer PENDING (see module docstring)."""
count = 0
for item in items:
if item.status != ScheduleItemStatus.PENDING:
if item.status != ItemStatus.PENDING:
count += 1
else:
break
@@ -37,39 +101,53 @@ def protected_prefix_length(items: list[ScheduleItem]) -> int:
def index_of(items: list[ScheduleItem], item_id: str | None) -> int | None:
"""Index of the item with `item_id`, or None if there is no such item."""
if item_id is None:
return None
for i, item in enumerate(items):
for idx, item in enumerate(items):
if item.item_id == item_id:
return i
return idx
return None
def pick_next_runnable(
items: list[ScheduleItem], repeat_aborted_item, first_item: int = 0
) -> ScheduleItem | Literal["stop"] | None:
items: list[ScheduleItem],
retry_unfinished: bool = False,
first_index: int = 0,
active_ids: frozenset[str] | set[str] = frozenset(),
attempted_ids: frozenset[str] | set[str] = frozenset(),
) -> ScheduleItem | None:
"""
What the execution loop should do next: always re-derived from scratch
(never a remembered index/object) so edits made to the PENDING suffix
between calls are picked up correctly.
Decide which item the execution loop should handle next.
Returns the next item to run/attach to, the string `"stop"` if an
earlier item failed/was aborted (execution stays parked there until the
operator intervenes), or `None` if every item is COMPLETED.
This is always re-derived from the current list (never a remembered index), so edits to the
PENDING part of the schedule between two calls are picked up.
Args:
items: The schedule items.
retry_unfinished: If True, FAILED and ABORTED items are run again (once per run, see
`attempted_ids`); otherwise they are skipped.
first_index: Items before this index are ignored ("run from selection").
active_ids: Ids of items that are currently being executed by this executor (e.g. a
running background item); they are skipped.
attempted_ids: Ids of items already started during the current run. A FAILED/ABORTED
item is only retried if it has not been attempted in this run yet, so a failing
item cannot be retried in an endless loop.
Returns:
The next PENDING item, a RUNNING item that is not owned by this executor (left over
from a previous widget session; the caller should re-attach to it), a FAILED/ABORTED
item if `retry_unfinished` is set, or None if nothing is left to do.
"""
logger.info(
f"pick next runnable, repeat abort item is {repeat_aborted_item} and first item is {first_item}"
)
for idx, item in enumerate(items):
logger.info(f"item: {item}")
if idx < first_item:
if idx < first_index or item.item_id in active_ids:
continue
if item.status == ScheduleItemStatus.COMPLETED:
continue
if item.status == ScheduleItemStatus.ABORTED:
if not repeat_aborted_item:
continue
if item.status == ScheduleItemStatus.FAILED:
return "stop"
return item # PENDING, RUNNING or ABORTED if repeat_aborted_item is set (reconciled as still active)
if item.status in (ItemStatus.PENDING, ItemStatus.RUNNING):
return item
if (
retry_unfinished
and item.status in (ItemStatus.FAILED, ItemStatus.ABORTED)
and item.item_id not in attempted_ids
):
return item
return None
@@ -0,0 +1,397 @@
"""
Table model and view showing a schedule.
Columns: line number | status | command | report | pause on failure | pause on state |
wait for completion. All columns except "Command" and "Report" have a fixed width; those two
share the remaining width 50/50.
Items inside the block of a background item (`wait_for_completion=False`) are indented in the
"Command" column, and a vertical guide line connects them with their parent, so it is visible
which items run while the parent is still busy (see `schedule_logic` for the block rules).
"""
from __future__ import annotations
import time
from bec_qthemes import material_icon
from bec_widgets.utils.colors import get_accent_colors
# pylint: disable=no-name-in-module # qtpy re-exports are not visible to pylint
from qtpy.QtCore import QAbstractTableModel, QModelIndex, QRect, QSize, Qt, Signal
from qtpy.QtGui import QKeySequence, QPen
from qtpy.QtWidgets import QHeaderView, QStyle, QStyledItemDelegate, QTableView
from .actions import ACTIONS, DELAY, describe_item, format_duration
from .models import ItemStatus, ScheduleItem
from .schedule_logic import BlockRole, block_roles, item_depths
# Qt virtual overrides (rowCount, data, paint, sizeHint, ...) keep Qt's names and docs.
# pylint: disable=invalid-name,missing-function-docstring,too-many-return-statements
ICON_SIZE = 20
INDENT_WIDTH = 24 # px per indentation level in the "Command" column
_ROW_MARGIN = 6 # total vertical padding (top + bottom) of a text cell
_STATUS_ICONS = {
ItemStatus.PENDING: ("hourglass", "#919090"),
ItemStatus.RUNNING: ("cycle", "#2980b9"),
ItemStatus.COMPLETED: ("check", "#27ae60"),
ItemStatus.FAILED: ("warning", "#e74c3c"),
ItemStatus.ABORTED: ("cancel", "#e6d922"),
}
#: Custom data roles
DepthRole = Qt.ItemDataRole.UserRole + 1
BlockRoleRole = Qt.ItemDataRole.UserRole + 2
class ScheduleTableModel(QAbstractTableModel):
"""
Read-only table model over a snapshot of `Schedule.items`.
The widget calls `set_items()` with a fresh copy whenever the schedule changes (a full model
reset - schedules are short, and this keeps the model free of locking). Display text comes
from the action registry (`actions.describe_item`), block indentation from
`schedule_logic.item_depths`.
"""
COL_LINE = 0
COL_STATUS = 1
COL_COMMAND = 2
COL_REPORT = 3
COL_PAUSE_ON_FAILURE = 4
COL_PAUSE_ON_STATE = 5
COL_WAIT = 6
HEADERS = (
"Line",
"Status",
"Command",
"Report",
"Pause on failure",
"Pause on state",
"Wait for completion",
)
ICON_COLUMNS = (COL_STATUS, COL_PAUSE_ON_FAILURE, COL_PAUSE_ON_STATE, COL_WAIT)
def __init__(self, parent=None, beamline: str | None = None):
super().__init__(parent)
self._items: list[ScheduleItem] = []
self._depths: list[int] = []
self._roles: list[BlockRole] = []
self._beamline = beamline
# The status icon of the selected row is drawn white (on the selection colour). Kept
# here rather than read from the view so it survives a model reset.
self._selected_item_id: str | None = None
# ---- Qt model API ---- #
def rowCount(self, parent: QModelIndex = QModelIndex()) -> int: # noqa: N802
return 0 if parent.isValid() else len(self._items)
def columnCount(self, parent: QModelIndex = QModelIndex()) -> int: # noqa: N802
return 0 if parent.isValid() else len(self.HEADERS)
def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole): # noqa: N802
if orientation != Qt.Orientation.Horizontal:
return None
if role == Qt.ItemDataRole.DisplayRole:
return self.HEADERS[section]
if role == Qt.ItemDataRole.TextAlignmentRole:
if section in (self.COL_COMMAND, self.COL_REPORT):
return int(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
return int(Qt.AlignmentFlag.AlignCenter)
return None
def data(self, index: QModelIndex, role=Qt.ItemDataRole.DisplayRole):
if not index.isValid():
return None
row, col = index.row(), index.column()
item = self._items[row]
if role == Qt.ItemDataRole.DisplayRole:
if col == self.COL_LINE:
return str(row + 1)
if col == self.COL_COMMAND:
return describe_item(item, self._beamline)
if col == self.COL_REPORT:
return self._report_text(item)
return None
if role == Qt.ItemDataRole.DecorationRole:
return self._icon(item, col)
if role == Qt.ItemDataRole.ToolTipRole:
return self._tooltip(item, col)
if role == Qt.ItemDataRole.TextAlignmentRole and col == self.COL_LINE:
return int(Qt.AlignmentFlag.AlignCenter)
if role == DepthRole:
return self._depths[row]
if role == BlockRoleRole:
return self._roles[row]
return None
# ---- content ---- #
def set_items(self, items: list[ScheduleItem], selected_item_id: str | None = None) -> None:
"""
Replace the displayed items (full model reset).
Args:
items: Snapshot of the schedule items.
selected_item_id: Item whose status icon is drawn for the selected row.
"""
self.beginResetModel()
self._selected_item_id = selected_item_id
self._items = list(items)
self._depths = item_depths(self._items)
self._roles = block_roles(self._items)
self.endResetModel()
def set_selected_item_id(self, item_id: str | None) -> None:
"""Remember the selected item and repaint the status icons (no full reset)."""
self._selected_item_id = item_id
self._emit_column_changed(self.COL_STATUS, [Qt.ItemDataRole.DecorationRole])
def refresh_live_cells(self) -> None:
"""Repaint the report of running delays (remaining time). Called once per second."""
if any(item.status == ItemStatus.RUNNING and item.action == DELAY for item in self._items):
self._emit_column_changed(self.COL_REPORT, [Qt.ItemDataRole.DisplayRole])
def item_id(self, row: int) -> str | None:
"""Id of the item in `row`, or None."""
return self._items[row].item_id if 0 <= row < len(self._items) else None
def row_of(self, item_id: str | None) -> int | None:
"""Row of the item with `item_id`, or None."""
for row, item in enumerate(self._items):
if item.item_id == item_id:
return row
return None
def _emit_column_changed(self, column: int, roles: list) -> None:
if self._items:
self.dataChanged.emit(
self.index(0, column), self.index(len(self._items) - 1, column), roles
)
# ---- cell content helpers ---- #
@staticmethod
def _report_text(item: ScheduleItem) -> str:
if item.status == ItemStatus.RUNNING and item.action == DELAY and item.started_at:
remaining = item.params.get("seconds", 0) - (time.time() - item.started_at)
return f"{format_duration(remaining)} remaining"
if item.status == ItemStatus.RUNNING and not item.report:
return "Running..."
return item.report or ""
def _icon(self, item: ScheduleItem, col: int):
if col == self.COL_STATUS:
name, color = _STATUS_ICONS[item.status]
if item.item_id == self._selected_item_id:
color = "#FFFFFF"
return _pixmap(name, color)
if col == self.COL_PAUSE_ON_FAILURE and item.pause_on_failure:
return _pixmap("pause_circle", "#e6d922")
if col == self.COL_PAUSE_ON_STATE and item.pause_on_state:
return _pixmap("shield", "#2980b9")
if col == self.COL_WAIT and ACTIONS.get(item.action) is not None:
if ACTIONS[item.action].category == "control":
return None
if item.wait_for_completion:
return _pixmap("hourglass_bottom", "#919090")
return _pixmap("call_split", get_accent_colors().highlight.name())
return None
@staticmethod
def _tooltip(item: ScheduleItem, col: int) -> str | None:
if col == ScheduleTableModel.COL_STATUS:
return item.status.name.capitalize()
if col == ScheduleTableModel.COL_REPORT and item.error:
return item.error
if col == ScheduleTableModel.COL_PAUSE_ON_FAILURE:
return "Pauses the schedule if this item fails" if item.pause_on_failure else None
if col == ScheduleTableModel.COL_PAUSE_ON_STATE:
if item.pause_on_state:
return (
"Waits for all beamline states to be valid before starting;\n"
"running scans are interrupted and repeated if a state becomes invalid"
)
return None
if col == ScheduleTableModel.COL_WAIT:
if not item.wait_for_completion:
return "Runs in the background: the following (indented) items start right away"
return "The schedule waits for this item to complete"
return None
def _pixmap(name: str, color: str):
return material_icon(name, size=(ICON_SIZE, ICON_SIZE), color=color, convert_to_pixmap=True)
def _paint_background(painter, option) -> None:
if option.state & QStyle.StateFlag.State_Selected:
painter.fillRect(option.rect, option.palette.highlight())
painter.setPen(option.palette.highlightedText().color())
else:
painter.setPen(option.palette.text().color())
class _TextDelegate(QStyledItemDelegate):
"""
Paints multi-line text (labels contain explicit line breaks) and reports the full multi-line
height, so the view's ResizeToContents row mode can fit it. If `indent` is True, the text is
indented by the item's block depth and the block guide line is drawn.
Selection is painted with the palette highlight colour, like `BecLogTableView`.
"""
def __init__(self, parent=None, indent: bool = False):
super().__init__(parent)
self._indent = indent
def paint(self, painter, option, index):
painter.save()
_paint_background(painter, option)
painter.setFont(option.font)
text_pen = painter.pen()
rect = option.rect.adjusted(6, _ROW_MARGIN // 2, -6, -(_ROW_MARGIN // 2))
if self._indent:
depth = index.data(DepthRole) or 0
self._paint_guide(painter, option.rect, index.data(BlockRoleRole))
rect.setLeft(rect.left() + depth * INDENT_WIDTH)
painter.setPen(text_pen)
text = index.data(Qt.ItemDataRole.DisplayRole) or ""
flags = (
Qt.TextFlag.TextWordWrap | Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter
)
painter.drawText(rect, int(flags), text)
painter.restore()
@staticmethod
def _paint_guide(painter, rect: QRect, role: BlockRole | None) -> None:
if role in (None, BlockRole.NONE, BlockRole.PARENT_EMPTY):
return
pen = QPen(get_accent_colors().highlight)
pen.setWidth(2)
painter.setPen(pen)
x = rect.left() + 10
mid = rect.center().y()
if role == BlockRole.PARENT:
painter.drawLine(x, mid + 4, x, rect.bottom())
else:
bottom = mid if role == BlockRole.LAST_CHILD else rect.bottom()
painter.drawLine(x, rect.top(), x, bottom)
painter.drawLine(x, mid, x + INDENT_WIDTH - 8, mid)
def sizeHint(self, option, index): # noqa: N802
text = index.data(Qt.ItemDataRole.DisplayRole) or ""
lines = text.count("\n") + 1
height = option.fontMetrics.lineSpacing() * lines + _ROW_MARGIN
return QSize(super().sizeHint(option, index).width(), max(height, ICON_SIZE + _ROW_MARGIN))
class _CenteredIconDelegate(QStyledItemDelegate):
"""Paints the DecorationRole pixmap centred in the cell."""
def paint(self, painter, option, index):
painter.save()
_paint_background(painter, option)
pixmap = index.data(Qt.ItemDataRole.DecorationRole)
if pixmap is not None:
x = option.rect.center().x() - ICON_SIZE // 2
y = option.rect.center().y() - ICON_SIZE // 2
painter.drawPixmap(x, y, pixmap)
painter.restore()
class _CenteredTextDelegate(QStyledItemDelegate):
"""Paints short single-line text centred in the cell (line numbers)."""
def paint(self, painter, option, index):
painter.save()
_paint_background(painter, option)
painter.drawText(
option.rect, int(Qt.AlignmentFlag.AlignCenter), index.data(Qt.ItemDataRole.DisplayRole)
)
painter.restore()
class ScheduleTableView(QTableView):
"""
Table view for a `ScheduleTableModel`: single row selection, fixed-width icon columns,
"Command" and "Report" sharing the remaining width, plus keyboard shortcuts.
Signals:
deletePressed: The Delete key was pressed on a selected row.
copyPressed / pastePressed: The standard copy/paste shortcut was pressed.
emptySpaceClicked: The user clicked below the last row (clears the selection).
"""
deletePressed = Signal()
emptySpaceClicked = Signal()
copyPressed = Signal()
pastePressed = Signal()
FIXED_WIDTHS = {
ScheduleTableModel.COL_LINE: 50,
ScheduleTableModel.COL_STATUS: 60,
ScheduleTableModel.COL_PAUSE_ON_FAILURE: 120,
ScheduleTableModel.COL_PAUSE_ON_STATE: 110,
ScheduleTableModel.COL_WAIT: 145,
}
def __init__(self, parent=None):
super().__init__(parent)
self.setSelectionBehavior(QTableView.SelectionBehavior.SelectRows)
self.setSelectionMode(QTableView.SelectionMode.SingleSelection)
self.setEditTriggers(QTableView.EditTrigger.NoEditTriggers)
self.setShowGrid(False)
self.setWordWrap(True)
self.verticalHeader().hide()
# ResizeToContents so that a row grows with the number of text lines of its cells.
self.verticalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
self.setItemDelegateForColumn(ScheduleTableModel.COL_LINE, _CenteredTextDelegate(self))
self.setItemDelegateForColumn(
ScheduleTableModel.COL_COMMAND, _TextDelegate(self, indent=True)
)
self.setItemDelegateForColumn(ScheduleTableModel.COL_REPORT, _TextDelegate(self))
icon_delegate = _CenteredIconDelegate(self)
for col in ScheduleTableModel.ICON_COLUMNS:
self.setItemDelegateForColumn(col, icon_delegate)
def configure_columns(self) -> None:
"""Apply the column sizing; call after `setModel()`."""
header = self.horizontalHeader()
header.setStretchLastSection(False)
for col, width in self.FIXED_WIDTHS.items():
header.setSectionResizeMode(col, QHeaderView.ResizeMode.Fixed)
header.resizeSection(col, width)
# Both stretch columns get the same stretch factor -> the leftover width is shared 50/50.
header.setSectionResizeMode(ScheduleTableModel.COL_COMMAND, QHeaderView.ResizeMode.Stretch)
header.setSectionResizeMode(ScheduleTableModel.COL_REPORT, QHeaderView.ResizeMode.Stretch)
def keyPressEvent(self, event): # noqa: N802
if event.key() == Qt.Key.Key_Delete and self.currentIndex().isValid():
self.deletePressed.emit()
event.accept()
return
if event.matches(QKeySequence.StandardKey.Copy) and self.currentIndex().isValid():
self.copyPressed.emit()
event.accept()
return
if event.matches(QKeySequence.StandardKey.Paste):
self.pastePressed.emit()
event.accept()
return
super().keyPressEvent(event)
def mousePressEvent(self, event): # noqa: N802
if (
event.button() == Qt.MouseButton.LeftButton
and not self.indexAt(event.position().toPoint()).isValid()
):
self.clearSelection()
self.setCurrentIndex(QModelIndex())
self.emptySpaceClicked.emit()
return
super().mousePressEvent(event)
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,190 @@
"""
Watch all BEC beamline states on behalf of the Scheduler ("pause on state").
Beamline states are created, edited and deleted with BEC's own `BeamlineStateManager` widget,
which the Scheduler embeds. This module only *reads* them: it follows
`MessageEndpoints.available_beamline_states()` to learn which states exist, subscribes to
`MessageEndpoints.beamline_state(name)` of each of them through the `BECDispatcher`, and keeps
track of whether all of them are acceptable (VALID or WARNING).
Dispatcher callbacks run on the Qt GUI thread. The schedule executor runs on a worker thread and
only uses the thread-safe `is_ok()` / `wait_until_ok()` methods, backed by a `threading.Event`.
"""
from __future__ import annotations
import threading
from typing import Any, Callable
from bec_lib.endpoints import MessageEndpoints
from bec_lib.logger import bec_logger
from bec_widgets.utils.error_popups import SafeSlot
# pylint: disable=no-name-in-module # qtpy re-exports are not visible to pylint
from qtpy.QtCore import QObject, Signal
logger = bec_logger.logger
#: Beamline state statuses that do not pause gated schedule items.
OK_STATUSES = frozenset({"valid", "warning"})
def _state_name(state: Any) -> str | None:
"""Name of a `BeamlineStateConfig` (object or plain dict)."""
if isinstance(state, dict):
return state.get("name")
return getattr(state, "name", None)
class BeamlineStateMonitor(QObject):
"""
Aggregates the status of all beamline states.
Signals:
tripped(): At least one state left VALID/WARNING (was OK before).
recovered(): All states are VALID/WARNING again (was not OK before).
statuses_changed(): Any status changed, or a state was added/removed.
A state whose status is still unknown (e.g. right after creation, or if its device is not
reachable) counts as not OK, so that gated items never start on unverified conditions.
Without any beamline states, the monitor is always OK.
"""
tripped = Signal()
recovered = Signal()
statuses_changed = Signal()
def __init__(self, client, bec_dispatcher, parent: QObject | None = None) -> None:
super().__init__(parent)
self._client = client
self._dispatcher = bec_dispatcher
self._lock = threading.Lock()
self._statuses: dict[str, str] = {}
self._ok_event = threading.Event()
self._ok_event.set()
self._dispatcher.connect_slot(
self._on_available_states, MessageEndpoints.available_beamline_states()
)
msg = self._client.connector.get_last(
MessageEndpoints.available_beamline_states(), key="data"
)
if msg is not None:
self._on_available_states(msg.content, msg.metadata)
# ------------------------------------------------------------------------------------------ #
# Thread-safe queries (used by the executor's worker thread)
# ------------------------------------------------------------------------------------------ #
def is_ok(self) -> bool:
"""True if every beamline state is VALID or WARNING (or no states exist)."""
return self._ok_event.is_set()
def wait_until_ok(self, should_abort: Callable[[], bool], poll_interval: float = 0.5) -> bool:
"""
Block the calling (non-GUI) thread until `is_ok()` is True.
Args:
should_abort: Polled between waits; the wait ends early if it returns True.
poll_interval: Seconds between two `should_abort` checks.
Returns:
True if the states became OK, False if `should_abort()` returned True first.
"""
while not should_abort():
if self._ok_event.wait(timeout=poll_interval):
return True
return False
def statuses(self) -> dict[str, str]:
"""A copy of the current `{state name: status}` mapping."""
with self._lock:
return dict(self._statuses)
def blocking_states(self) -> list[str]:
"""Names of the states that currently prevent gated items from running."""
with self._lock:
return sorted(
name for name, status in self._statuses.items() if status not in OK_STATUSES
)
def summary(self) -> str:
"""One-line, human-readable summary, e.g. for a status label."""
statuses = self.statuses()
if not statuses:
return "No beamline states defined"
blocking = self.blocking_states()
if not blocking:
return f"All {len(statuses)} beamline state(s) OK"
return f"Not OK: {', '.join(blocking)} - items with 'pause on state' will wait"
# ------------------------------------------------------------------------------------------ #
# Dispatcher callbacks (GUI thread)
# ------------------------------------------------------------------------------------------ #
@SafeSlot(dict, dict)
def _on_available_states(self, content: dict, _metadata: dict | None = None) -> None:
names = {name for state in content.get("states", []) if (name := _state_name(state))}
with self._lock:
known = set(self._statuses)
for name in known - names:
self._dispatcher.disconnect_slot(
self._on_state_update, MessageEndpoints.beamline_state(name)
)
with self._lock:
self._statuses.pop(name, None)
for name in names - known:
with self._lock:
self._statuses[name] = "unknown"
self._dispatcher.connect_slot(
self._on_state_update, MessageEndpoints.beamline_state(name)
)
last = self._client.connector.get_last(
MessageEndpoints.beamline_state(name), key="data"
)
if last is not None:
self._set_status(name, last.content.get("status"))
self._evaluate()
@SafeSlot(dict, dict)
def _on_state_update(self, content: dict, _metadata: dict | None = None) -> None:
name = content.get("name")
if not name:
return
with self._lock:
if name not in self._statuses:
return # update of a state that was just removed
self._set_status(name, content.get("status"))
self._evaluate()
def _set_status(self, name: str, status: Any) -> None:
with self._lock:
self._statuses[name] = str(status or "unknown").lower()
def _evaluate(self) -> None:
with self._lock:
ok = all(status in OK_STATUSES for status in self._statuses.values())
was_ok = self._ok_event.is_set()
if ok:
self._ok_event.set()
else:
self._ok_event.clear()
self.statuses_changed.emit()
if was_ok and not ok:
logger.info(f"Scheduler: beamline state(s) not OK: {self.blocking_states()}")
self.tripped.emit()
elif ok and not was_ok:
logger.info("Scheduler: all beamline states OK again.")
self.recovered.emit()
def cleanup(self) -> None:
"""Disconnect all dispatcher subscriptions and release waiting threads."""
self._dispatcher.disconnect_slot(
self._on_available_states, MessageEndpoints.available_beamline_states()
)
with self._lock:
names = list(self._statuses)
self._statuses.clear()
for name in names:
self._dispatcher.disconnect_slot(
self._on_state_update, MessageEndpoints.beamline_state(name)
)
self._ok_event.set()
@@ -0,0 +1,35 @@
"""Small reusable Qt widgets of the Scheduler."""
from __future__ import annotations
from bec_widgets.utils.colors import get_accent_colors
# pylint: disable=no-name-in-module # qtpy re-exports are not visible to pylint
from qtpy.QtWidgets import QPushButton
class AccentButton(QPushButton):
"""
Push button filled with one of BEC's accent colours ("default", "success", "warning",
"emergency", ...), greyed out while disabled.
"""
def __init__(self, text: str = "", color: str = "default", parent=None):
self.color = color
super().__init__(text, parent)
self.apply_theme()
def apply_theme(self) -> None:
"""Re-apply the colours, e.g. after a theme change."""
if self.isEnabled():
color = getattr(get_accent_colors(), self.color).name()
self.setStyleSheet(f"QPushButton {{ background-color: {color}; color: white; }}")
else:
self.setStyleSheet(
"QPushButton { background-color: rgb(120, 120, 120); color: white; }"
)
def setEnabled(self, enable: bool = True) -> None: # noqa: N802 pylint: disable=invalid-name
"""Enable/disable the button and update its colours."""
super().setEnabled(enable)
self.apply_theme()
@@ -0,0 +1,284 @@
"""Tests for the Scheduler's execution loop (`ScheduleExecutor`) with fake BEC handles."""
# pylint: disable=missing-function-docstring,missing-class-docstring
import threading
import time
from unittest import mock
import pytest
from debye_bec.bec_widgets.widgets.scheduler.actions import ExecutionContext
from debye_bec.bec_widgets.widgets.scheduler.executor import ScheduleExecutor
from debye_bec.bec_widgets.widgets.scheduler.models import ItemStatus, ScheduleItem
TIMEOUT = 5
class FakeHandle:
"""Mimics a BEC ScanReport: `wait()` blocks until released, `cancel()` makes it raise."""
def __init__(self, release: threading.Event | None = None):
self.release = release or threading.Event()
if release is None:
self.release.set()
self.cancelled = threading.Event()
self.request = None
def wait(self):
while not self.release.wait(0.01):
if self.cancelled.is_set():
raise RuntimeError("cancelled")
if self.cancelled.is_set():
raise RuntimeError("cancelled")
def cancel(self):
self.cancelled.set()
class FakeStateMonitor:
def __init__(self):
self.ok = threading.Event()
self.ok.set()
def is_ok(self):
return self.ok.is_set()
def wait_until_ok(self, should_abort, poll_interval=0.01):
while not should_abort():
if self.ok.wait(poll_interval):
return True
return False
def blocking_states(self):
return [] if self.ok.is_set() else ["beam"]
class Harness:
def __init__(self, items: list[ScheduleItem]):
self.items = items
self.scans = mock.MagicMock()
self.dev = {"samx": mock.MagicMock()}
self.dev["samx"].move.return_value = FakeHandle()
self.monitor = FakeStateMonitor()
self.notified: list[str] = []
self.closing = threading.Event()
self.executor = ScheduleExecutor(
lock=threading.Lock(),
get_items=lambda: self.items,
persist_locked=lambda: None,
emit_changed=lambda: None,
context=ExecutionContext(scans=self.scans, dev=self.dev),
state_monitor=self.monitor,
notify_item=lambda item: self.notified.append(item.item_id),
get_queue_storage=mock.MagicMock,
closing=self.closing,
)
self.outcome = None
self.thread = None
def start(self, **kwargs):
def _run():
self.outcome = self.executor.run(**kwargs)
self.thread = threading.Thread(target=_run, daemon=True)
self.thread.start()
def join(self):
self.thread.join(TIMEOUT)
assert not self.thread.is_alive(), "executor did not finish"
return self.outcome
def _wait_until(predicate, timeout=TIMEOUT):
deadline = time.time() + timeout
while time.time() < deadline:
if predicate():
return
time.sleep(0.01)
pytest.fail("condition not reached")
def _scan(item_id, wait=True, pause_on_state=False):
return ScheduleItem(
item_id=item_id,
action="scan",
params={"scan_name": "line_scan", "args": [], "kwargs": {}},
wait_for_completion=wait,
pause_on_state=pause_on_state,
)
def _delay(item_id, seconds=0.05):
return ScheduleItem(item_id=item_id, action="delay", params={"seconds": seconds})
def _move(item_id, pause_on_failure=False):
return ScheduleItem(
item_id=item_id,
action="move",
params={"device": "samx", "value": 1.0, "relative": False, "units": "mm"},
pause_on_failure=pause_on_failure,
)
def _by_id(harness, item_id):
return next(item for item in harness.items if item.item_id == item_id)
def test_sequential_items_complete():
harness = Harness([_move("m1"), _delay("d1"), _move("m2")])
harness.start()
assert harness.join() == "finished"
assert all(item.status == ItemStatus.COMPLETED for item in harness.items)
assert harness.notified == ["m1", "d1", "m2"]
assert _by_id(harness, "d1").report.startswith("Waited")
def test_background_item_runs_concurrently_with_its_block():
release = threading.Event()
parent_handle = FakeHandle(release)
harness = Harness(
[
_scan("parent", wait=False),
_delay("child1"),
_delay("child2"),
ScheduleItem(item_id="join", action="wait_for_parent"),
_move("after"),
]
)
harness.scans.line_scan.return_value = parent_handle
harness.start()
_wait_until(lambda: _by_id(harness, "child2").status == ItemStatus.COMPLETED)
assert _by_id(harness, "parent").status == ItemStatus.RUNNING
_wait_until(lambda: _by_id(harness, "join").status == ItemStatus.RUNNING)
time.sleep(0.1)
assert _by_id(harness, "after").status == ItemStatus.PENDING # still waiting for parent
release.set()
assert harness.join() == "finished"
assert all(item.status == ItemStatus.COMPLETED for item in harness.items)
assert _by_id(harness, "after").started_at >= _by_id(harness, "parent").finished_at
def test_next_background_item_implicitly_waits_for_previous():
release = threading.Event()
first, second = FakeHandle(release), FakeHandle()
harness = Harness([_scan("bg1", wait=False), _delay("child"), _scan("bg2", wait=False)])
harness.scans.line_scan.side_effect = [first, second]
harness.start()
_wait_until(lambda: _by_id(harness, "child").status == ItemStatus.COMPLETED)
time.sleep(0.1)
assert _by_id(harness, "bg2").status == ItemStatus.PENDING
release.set()
assert harness.join() == "finished"
assert _by_id(harness, "bg2").started_at >= _by_id(harness, "bg1").finished_at
def test_failure_without_pause_continues():
harness = Harness([_move("bad"), _move("good")])
harness.dev["samx"].move.side_effect = [RuntimeError("motor error"), FakeHandle()]
harness.start()
assert harness.join() == "finished"
assert _by_id(harness, "bad").status == ItemStatus.FAILED
assert "motor error" in _by_id(harness, "bad").report
assert _by_id(harness, "good").status == ItemStatus.COMPLETED
def test_pause_on_failure_pauses():
harness = Harness([_move("bad", pause_on_failure=True), _move("next")])
harness.dev["samx"].move.side_effect = RuntimeError("motor error")
harness.start()
assert harness.join() == "paused_on_failure"
assert _by_id(harness, "bad").status == ItemStatus.FAILED
assert _by_id(harness, "next").status == ItemStatus.PENDING
def test_retry_unfinished_runs_failed_item_once():
harness = Harness([_move("bad"), _move("next")])
harness.items[0].status = ItemStatus.FAILED
harness.dev["samx"].move.side_effect = [RuntimeError("again"), FakeHandle()]
harness.start(retry_unfinished=True)
assert harness.join() == "finished"
assert _by_id(harness, "bad").status == ItemStatus.FAILED
assert _by_id(harness, "next").status == ItemStatus.COMPLETED
assert harness.dev["samx"].move.call_count == 2
def test_abort_interrupts_delay():
harness = Harness([_delay("long", seconds=100), _move("next")])
harness.start()
_wait_until(lambda: _by_id(harness, "long").status == ItemStatus.RUNNING)
harness.executor.request_abort()
assert harness.join() == "aborted"
assert _by_id(harness, "long").status == ItemStatus.ABORTED
assert _by_id(harness, "next").status == ItemStatus.PENDING
def test_pause_after_current_item():
harness = Harness([_delay("d1", seconds=0.2), _move("next")])
harness.start()
_wait_until(lambda: _by_id(harness, "d1").status == ItemStatus.RUNNING)
harness.executor.request_pause()
assert harness.join() == "paused"
assert _by_id(harness, "d1").status == ItemStatus.COMPLETED
assert _by_id(harness, "next").status == ItemStatus.PENDING
def test_pause_on_state_waits_for_states():
harness = Harness([_move("gated")])
harness.items[0].pause_on_state = True
harness.monitor.ok.clear()
harness.start()
_wait_until(lambda: (_by_id(harness, "gated").report or "").startswith("Waiting"))
assert _by_id(harness, "gated").status == ItemStatus.PENDING
harness.monitor.ok.set()
assert harness.join() == "finished"
assert _by_id(harness, "gated").status == ItemStatus.COMPLETED
def test_state_trip_cancels_and_repeats_gated_scan():
first = FakeHandle(threading.Event()) # blocks until cancelled
second = FakeHandle()
harness = Harness([_scan("scan", pause_on_state=True)])
harness.scans.line_scan.side_effect = [first, second]
harness.start()
_wait_until(lambda: _by_id(harness, "scan").status == ItemStatus.RUNNING)
harness.monitor.ok.clear()
harness.executor.on_states_tripped()
_wait_until(lambda: first.cancelled.is_set())
_wait_until(lambda: (_by_id(harness, "scan").report or "").startswith("Waiting"))
harness.monitor.ok.set()
assert harness.join() == "finished"
assert _by_id(harness, "scan").status == ItemStatus.COMPLETED
assert harness.scans.line_scan.call_count == 2
def test_state_trip_does_not_interrupt_ungated_scan():
release = threading.Event()
handle = FakeHandle(release)
harness = Harness([_scan("scan", pause_on_state=False)])
harness.scans.line_scan.return_value = handle
harness.start()
_wait_until(lambda: _by_id(harness, "scan").status == ItemStatus.RUNNING)
harness.executor.on_states_tripped()
assert not handle.cancelled.is_set()
release.set()
assert harness.join() == "finished"
def test_closing_leaves_running_item_untouched():
harness = Harness([_scan("scan")])
harness.scans.line_scan.return_value = FakeHandle(threading.Event())
harness.start()
_wait_until(lambda: _by_id(harness, "scan").status == ItemStatus.RUNNING)
harness.closing.set()
harness.executor.notify_closing()
# The fake scan only ends when cancelled; closing must not cancel it server-side.
time.sleep(0.1)
assert _by_id(harness, "scan").status == ItemStatus.RUNNING
harness.scans.line_scan.return_value.cancel()
assert harness.join() == "widget_closed"
assert _by_id(harness, "scan").status == ItemStatus.RUNNING
@@ -0,0 +1,311 @@
"""Tests for the Scheduler's data model, action registry and pure scheduling logic."""
# pylint: disable=missing-function-docstring
import json
from unittest import mock
import pytest
from debye_bec.bec_widgets.widgets.scheduler.actions import (
ACTIONS,
ExecutionContext,
describe_item,
format_duration,
run_action,
)
from debye_bec.bec_widgets.widgets.scheduler.models import (
ItemStatus,
NotificationTarget,
Schedule,
ScheduleItem,
is_legacy_schedule,
schedule_from_document,
)
from debye_bec.bec_widgets.widgets.scheduler.schedule_logic import (
BlockRole,
block_parents,
block_roles,
item_depths,
pick_next_runnable,
protected_prefix_length,
)
# A schedule document as written to Redis by the previous (eval-based) Scheduler version.
LEGACY_SCHEDULE = {
"schedule_name": "default_schedule",
"items": [
{
"item_id": "a",
"command": "dev.samx.move(1.0, relative=False)",
"status": "completed",
"kind": "move",
"form_state": {"device_name": "samx", "value": 1.0, "units": "mm", "relative": False},
"pause_on_failure": False,
}
],
"is_running": False,
"notes": "",
"notifications": {"enabled": True, "target": "teams", "teams_scope": "x", "events": []},
"guard": {"enabled": False, "device_name": None, "pause_below": None, "resume_above": None},
}
# Sample parameters for every registered action (the "describe" text must work with them).
SAMPLE_PARAMS = {
"scan": {"scan_name": "line_scan", "args": ["samx", -1, 1], "kwargs": {"steps": 10}},
"move": {"device": "samx", "value": 1.5, "relative": True, "units": "mm"},
"digital_twin": {
"config": {
"mo1_mode": "Monochromatic",
"energy": 9000,
"h_acc": 1e-3,
"v_acc": 1e-4,
"cm_stripe": "Rh",
"cm_pitch": 2e-3,
"mo1_xtal": "Si111",
"fm_stripe": "Pt",
"fm_rotx": 3e-3,
"ot_es1_trz": 100,
"es1man_trz": 1.0,
"smpl_to_xrd": 200.0,
}
},
"auto_gain": {
"config": {
"element": "Cu",
"edge": "K",
"all_amplifiers": ["ic0", "ic1"],
"link_ic0_ic1": True,
"compensate_ring_current": True,
"prohibited_gains": {"ic0": [1e6]},
}
},
"absorber": {"action": "Open"},
"ic_fill": {
"chamber": "IC1",
"gas1": "N2",
"conc1": 80.0,
"gas2": "Ar",
"conc2": 20.0,
"pressure": 1.5,
},
"reffoil": {"foil": "Cu"},
"temperature_controller": {
"config": {
"power_mode": "On",
"target_setpoint": 120,
"ramp_rate": 10,
"ramp_rate_unit": "K/min",
}
},
"delay": {"seconds": 3725},
"wait_for_parent": {},
}
def _item(action="delay", wait=True, status=ItemStatus.PENDING, item_id=None, **params):
kwargs = {"item_id": item_id} if item_id else {}
return ScheduleItem(
action=action,
params=params or SAMPLE_PARAMS[action],
wait_for_completion=wait,
status=status,
**kwargs,
)
# ---------------------------------------------------------------------------------------------- #
# models
# ---------------------------------------------------------------------------------------------- #
def test_legacy_schedule_is_detected_and_rejected():
assert is_legacy_schedule(LEGACY_SCHEDULE)
with pytest.raises(Exception):
Schedule.model_validate(LEGACY_SCHEDULE)
def test_legacy_teams_target_maps_to_scilog():
schedule = Schedule.model_validate({**LEGACY_SCHEDULE, "items": []})
assert schedule.notifications.target == NotificationTarget.SCILOG
assert schedule.notifications.enabled
def test_legacy_notify_rpc_alias():
schedule = Schedule.model_validate(
{"schedule_name": "s", "notifications": {"notify_rpc": False}}
)
assert schedule.notifications.notify_device is False
def test_schedule_json_round_trip():
schedule = Schedule(
schedule_name="s", items=[_item(action) for action in SAMPLE_PARAMS], notes="hello"
)
data = json.loads(json.dumps(schedule.model_dump(mode="json")))
assert Schedule.model_validate(data) == schedule
def test_reset_execution_and_definition():
item = _item("move", status=ItemStatus.FAILED)
item.error, item.report, item.scan_number = "boom", "boom", 3
item.reset_execution()
assert item.status == ItemStatus.PENDING
assert (item.error, item.report, item.scan_number) == (None, None, None)
assert set(item.definition()) == {
"action",
"params",
"wait_for_completion",
"pause_on_failure",
"pause_on_state",
}
# ---------------------------------------------------------------------------------------------- #
# actions
# ---------------------------------------------------------------------------------------------- #
def test_every_action_has_sample_params_and_description():
assert set(ACTIONS) == set(SAMPLE_PARAMS)
for action, params in SAMPLE_PARAMS.items():
json.dumps(params)
text = describe_item(_item(action), "x01da")
assert text and "Unknown action" not in text
def test_describe_unknown_action_does_not_raise():
item = ScheduleItem(action="does_not_exist", params={"a": 1})
assert "does_not_exist" in describe_item(item, None)
def test_run_action_unknown_raises():
with pytest.raises(KeyError):
run_action(ExecutionContext(scans=None, dev=None), "does_not_exist", {})
def test_run_scan_dispatches_to_scans():
scans = mock.MagicMock()
ctx = ExecutionContext(scans=scans, dev=None)
run_action(ctx, "scan", SAMPLE_PARAMS["scan"])
scans.line_scan.assert_called_once_with("samx", -1, 1, steps=10)
def test_run_scan_rejects_private_names():
ctx = ExecutionContext(scans=mock.MagicMock(), dev=None)
with pytest.raises(ValueError):
run_action(ctx, "scan", {"scan_name": "_run", "args": [], "kwargs": {}})
def test_run_move_dispatches_to_device():
dev = {"samx": mock.MagicMock()}
run_action(ExecutionContext(scans=None, dev=dev), "move", SAMPLE_PARAMS["move"])
dev["samx"].move.assert_called_once_with(1.5, relative=True)
def test_run_digital_twin_failure_raises():
twin = mock.MagicMock()
twin.move_with_config.return_value = {"success": False, "failures": {"m": "x"}}
ctx = ExecutionContext(scans=None, dev=None, digital_twin=twin)
with pytest.raises(RuntimeError):
run_action(ctx, "digital_twin", SAMPLE_PARAMS["digital_twin"])
def test_run_delay_is_interrupted_by_abort():
ctx = ExecutionContext(scans=None, dev=None)
ctx.abort_event.set()
with pytest.raises(Exception):
run_action(ctx, "delay", {"seconds": 100})
def test_control_action_cannot_be_run_directly():
with pytest.raises(ValueError):
run_action(ExecutionContext(scans=None, dev=None), "wait_for_parent", {})
def test_format_duration():
assert format_duration(3725) == "1 h 02 min 05 s"
assert format_duration(150) == "2 min 30 s"
assert format_duration(5) == "5 s"
# ---------------------------------------------------------------------------------------------- #
# block structure
# ---------------------------------------------------------------------------------------------- #
def test_blocks_explicit_close():
items = [
_item("move"),
_item("scan", wait=False),
_item("temperature_controller"),
_item("delay"),
_item("wait_for_parent"),
_item("move"),
]
assert block_parents(items) == [None, None, 1, 1, 1, None]
assert item_depths(items) == [0, 0, 1, 1, 1, 0]
assert block_roles(items) == [
BlockRole.NONE,
BlockRole.PARENT,
BlockRole.CHILD,
BlockRole.CHILD,
BlockRole.LAST_CHILD,
BlockRole.NONE,
]
def test_blocks_implicit_close_by_next_background_item_and_end():
items = [_item("scan", wait=False), _item("delay"), _item("scan", wait=False), _item("delay")]
assert block_parents(items) == [None, 0, None, 2]
assert block_roles(items)[1] == BlockRole.LAST_CHILD
assert block_roles(items)[3] == BlockRole.LAST_CHILD
def test_background_item_without_children():
items = [_item("scan", wait=False), _item("scan", wait=False)]
assert block_roles(items) == [BlockRole.PARENT_EMPTY, BlockRole.PARENT_EMPTY]
def test_wait_for_parent_outside_block_is_top_level():
items = [_item("wait_for_parent"), _item("move")]
assert item_depths(items) == [0, 0]
# ---------------------------------------------------------------------------------------------- #
# next item / protected prefix
# ---------------------------------------------------------------------------------------------- #
def test_protected_prefix_with_several_running_items():
items = [
_item(status=ItemStatus.COMPLETED),
_item(status=ItemStatus.RUNNING),
_item(status=ItemStatus.RUNNING),
_item(),
]
assert protected_prefix_length(items) == 3
def test_pick_next_skips_completed_failed_and_active():
items = [
_item(status=ItemStatus.COMPLETED),
_item(status=ItemStatus.FAILED),
_item(status=ItemStatus.RUNNING, item_id="bg"),
_item(item_id="next"),
]
assert pick_next_runnable(items, active_ids={"bg"}).item_id == "next"
def test_pick_next_retries_unfinished_once():
items = [_item(status=ItemStatus.FAILED, item_id="f"), _item(item_id="p")]
assert pick_next_runnable(items, retry_unfinished=True).item_id == "f"
assert pick_next_runnable(items, retry_unfinished=True, attempted_ids={"f"}).item_id == "p"
def test_pick_next_respects_first_index_and_end():
items = [_item(item_id="a"), _item(item_id="b")]
assert pick_next_runnable(items, first_index=1).item_id == "b"
assert pick_next_runnable([_item(status=ItemStatus.COMPLETED)]) is None
def test_schedule_from_document_never_raises():
schedule, problem = schedule_from_document(LEGACY_SCHEDULE)
assert schedule is None and "old" in problem
schedule, problem = schedule_from_document({"items": "garbage"})
assert schedule is None and problem
schedule, problem = schedule_from_document(None)
assert schedule is None and problem
schedule, problem = schedule_from_document({"schedule_name": "s", "items": []})
assert problem is None and schedule.schedule_name == "s"
@@ -0,0 +1,117 @@
"""Tests for the Scheduler's beamline-state monitor and the interlock hiding helper."""
# pylint: disable=missing-function-docstring,redefined-outer-name
from types import SimpleNamespace
from unittest import mock
import pytest
from bec_lib.endpoints import MessageEndpoints
from qtpy.QtWidgets import QApplication
from debye_bec.bec_widgets.widgets.scheduler.interlock_hiding import hide_scan_interlock_controls
from debye_bec.bec_widgets.widgets.scheduler.state_monitor import BeamlineStateMonitor
@pytest.fixture(scope="module")
def qapp():
return QApplication.instance() or QApplication([])
class FakeDispatcher:
def __init__(self):
self.slots: dict[str, object] = {}
def connect_slot(self, slot, topic):
self.slots[topic.endpoint] = slot
def disconnect_slot(self, slot, topic):
self.slots.pop(topic.endpoint, None)
def publish_state(self, name, status):
self.slots[MessageEndpoints.beamline_state(name).endpoint](
{"name": name, "status": status, "label": ""}, {}
)
@pytest.fixture
def monitor(qapp): # pylint: disable=unused-argument
client = mock.MagicMock()
client.connector.get_last.return_value = None
dispatcher = FakeDispatcher()
mon = BeamlineStateMonitor(client, dispatcher)
yield mon, dispatcher
mon.cleanup()
def _set_available(dispatcher, *names):
dispatcher.slots[MessageEndpoints.available_beamline_states().endpoint](
{"states": [SimpleNamespace(name=name) for name in names]}, {}
)
def test_no_states_is_ok(monitor):
mon, _ = monitor
assert mon.is_ok()
assert mon.summary() == "No beamline states defined"
def test_new_state_is_unknown_until_reported(monitor):
mon, dispatcher = monitor
_set_available(dispatcher, "beam")
assert not mon.is_ok()
dispatcher.publish_state("beam", "valid")
assert mon.is_ok()
def test_warning_is_ok_invalid_trips_and_recovers(monitor):
mon, dispatcher = monitor
tripped, recovered = mock.MagicMock(), mock.MagicMock()
mon.tripped.connect(tripped)
mon.recovered.connect(recovered)
_set_available(dispatcher, "beam", "shutter")
tripped.assert_called_once() # new states are "unknown" until they report
dispatcher.publish_state("beam", "valid")
dispatcher.publish_state("shutter", "warning")
assert mon.is_ok()
recovered.assert_called_once()
dispatcher.publish_state("shutter", "invalid")
assert not mon.is_ok()
assert mon.blocking_states() == ["shutter"]
assert tripped.call_count == 2
dispatcher.publish_state("shutter", "valid")
assert mon.is_ok()
assert recovered.call_count == 2
def test_removed_state_is_unsubscribed(monitor):
mon, dispatcher = monitor
_set_available(dispatcher, "beam")
dispatcher.publish_state("beam", "invalid")
assert not mon.is_ok()
_set_available(dispatcher)
assert mon.is_ok()
assert MessageEndpoints.beamline_state("beam").endpoint not in dispatcher.slots
def test_wait_until_ok_aborts(monitor):
mon, dispatcher = monitor
_set_available(dispatcher, "beam")
assert mon.wait_until_ok(should_abort=lambda: True) is False
def test_hide_scan_interlock_controls():
action = mock.MagicMock()
pill = SimpleNamespace(_interlock_button=mock.MagicMock(), _interlock_warning_checkbox=None)
manager = SimpleNamespace(
_toolbar=SimpleNamespace(
components=SimpleNamespace(get_action=lambda name: SimpleNamespace(action=action))
),
_state_pills={"beam": pill},
)
hide_scan_interlock_controls(manager) # must not raise on the missing checkbox
action.setVisible.assert_called_with(False)
pill._interlock_button.setVisible.assert_called_once_with(
False
) # pylint: disable=protected-access