redsun.view¶

Where a view asks to be attached.

A placement names no toolkit type, and this module defines no concrete one. Each frontend declares the placements it understands in its own package. A frontend attaches the placements it lists in redsun.Frontend.requires and refuses the rest.

Declaring one is what makes a component a view. A presenter attaches nowhere and declares none.

A key that runs a component's method, as shortcut recorded it.

Raises:

key: str

title: str

scope: Scope = 'window'

mac: str | None = None

win: str | None = None

linux: str | None = None

when: Callable[[Any], bool] | None = None

repeat: bool = False

key_here() -> str

Where views start in a window: what fills each region, how big it is, what starts hidden.

The region names are the frontend's. A view the layout leaves out goes where its own placement asks.

Raises:

regions: Mapping[str, Node] = field(default_factory=dict)

sizes: Mapping[str, float] = field(default_factory=dict)

hidden: Sequence[str] = ()

names: list[str]

fingerprint() -> str

Bases: Split

Views side by side, left to right.

Each child is a view's name or another node. sizes gives one positive weight per child, and each child takes its weight's share of the width; without it the children share the width equally.

Raises:

Bases: Split

Views stacked, top to bottom.

Each child is a view's name or another node. sizes gives one positive weight per child, and each child takes its weight's share of the height; without it the children share the height equally.

Raises:

Bases: TabGroup

Views sharing one space as tabs.

Each tab is a view's name. current names the view shown on top; without it the first is.

Raises:

The Qt widgets of one plan.

spec: PlanSpec

group_box: QWidget

run_button: QPushButton

container: Container[ValueWidget[Any]]

device_widgets: list[ValueWidget[Any]]

params_widget: QWidget

problem_label: QLabel

action_buttons: dict[str, ActionButton]

actions_group: QGroupBox | None = None

pause_button: QPushButton | None = None

callbacks_list: QListWidget | None = None

progress_group: QGroupBox | None = None

problems: list[str]

parameters: dict[str, Any]

callbacks: list[CallbackType]

attached_callbacks: list[str]

toggle(status: bool) -> None

pause(status: bool) -> None

setEnabled(enabled: bool) -> None

enable_actions(enabled: bool = True) -> None

get_action_button(action_name: str) -> ActionButton | None

has_actions() -> bool

set_values(values: Mapping[str, Any]) -> None

show_progress(scopes: Sequence[PlanProgress]) -> None

Bases: QWidget

Read-only console of the running session's log records.

Records logged before the view existed are shown too, read from the session buffer. The level selector sets the lowest level shown; since the view redraws from the buffer, lowering the level again brings records back.

Application and service records have their own tabs. The Services tab appears once a service logs, and its selector narrows it to one service. Clear log window and Save logs... act on the tab and service shown.

Records are coloured by level, with one palette for light and one for dark backgrounds, chosen from the view's background and redrawn when the palette changes.

New records are drawn in batches, so a burst does not stall the window, and each console keeps no more lines than the buffer holds for it.

With session log files open, Save logs... copies the files of the tab shown and Open log folder opens their folder in the file browser; without them the folder button is disabled.

placement: Placement = Dock('bottom')

level: int

service: str | None

colors: dict[int, str]

changeEvent(event: QEvent | None) -> None

closeEvent(event: QCloseEvent | None) -> None

set_level(level: int) -> None

clear() -> None

save(path: str) -> None

Bases: QAction

The Logs entry of the View menu, showing the session's log in a window.

The window is a LogView, made when the entry is chosen and deleted when it is closed. Choosing the entry while the window is open brings it to the front.

placement: Placement = MenuItem('View')

show_logs() -> None

Bases: QWidget, Loggable

Choose a plan, fill its parameters, and run, pause and stop it.

One PlanWidget per plan the presenter describes, chosen from a list, and the directory runs write under. The view shows a plan running only once the presenter reports it started, and shows that a plan was stopped, or why it failed, until it runs again. The plan chosen last is kept in the session's settings. Ctrl+R runs the chosen plan and Ctrl+. stops the running one, anywhere in the window.

placement: Placement = Dock('left')

sig_launch = Signal(str, dict, tuple)

sig_pause = Signal()

sig_resume = Signal()

sig_stop = Signal()

sig_action = Signal(str, bool)

sig_base_dir = Signal(object)

sig_label = Signal(str)

setup(
    acquisition: DescribesPlans, settings: Settings
) -> None

set_started(
    plan: str, values: dict[str, Any] | None = None
) -> None

set_done(plan: str) -> None

set_stopped(plan: str) -> None

set_failed(plan: str, message: str) -> None

update_progress(scopes: tuple[PlanProgress, ...]) -> None

update_action(action: str, state: object) -> None

update_base_dir(path: Path) -> None

run_plan() -> None

stop_plan() -> None

Bases: QWidget, Loggable

Switch lights on and off and set their intensity: a group per light.

The Lights tab holds one LightGroup per light. The Configuration tab shows and edits every light's configuration. The Advanced tab chooses whether the intensity is also written while the slider is dragged; the choice is kept in the session's settings, under a key named after this view, and wins over the keyword.

Parameters:

placement: Placement = Dock('right')

group_class: MakesLightGroup = LightGroup

sig_enabled = Signal(str, bool)

sig_intensity = Signal(str, float)

sig_configure = Signal(str, object)

tabs: QTabWidget

setup(lights: DescribesLights, settings: Settings) -> None

update_enabled(device: str, on: bool) -> None

update_intensity(device: str, value: float) -> None

set_failed(device: str, message: str) -> None

update_configuration(key: str, value: object) -> None

set_locked(names: frozenset[str]) -> None

Bases: QGroupBox

A light's on/off button and, when it has one, its intensity.

The controls show what the light reads back. The intensity is written when the slider is let go or stepped, when the field is changed (on Enter, on leaving it, or with its arrows), and, with write_while_dragging, during a drag at most every 100 ms.

sig_enabled = Signal(str, bool)

sig_intensity = Signal(str, float)

set_enabled(on: bool) -> None

set_intensity(value: float) -> None

set_failed(message: str) -> None

set_locked(locked: bool) -> None

set_write_while_dragging(on: bool) -> None

Bases: QWidget, Loggable

Move devices by hand: a row per axis, grouped by device.

The Motors tab holds one PositionerGroup per device the positioner describes, and the saved positions. The Configuration tab shows and edits the configuration of every axis. The Advanced tab sets the repeat interval of held step buttons. With an axis row or its step button focused, Left and Right step that axis down and up; they are keyboard shortcuts, so the session file and the Keyboard shortcuts list show and change them. The session's settings keep the saved positions and the repeat interval, under keys named after this view.

Parameters:

placement: Placement = Dock('right')

group_class: MakesPositionerGroup = PositionerGroup

sig_move = Signal(str, str, float)

sig_move_to = Signal(str, dict)

sig_stop_device = Signal(str)

sig_configure = Signal(str, object)

tabs: QTabWidget

setup(
    positioner: DescribesAxes, settings: Settings
) -> None

update_readback(
    device: str, axis: str, value: float
) -> None

update_limits(
    device: str,
    axis: str,
    low: float | None,
    high: float | None,
) -> None

set_moving(device: str, moving: bool) -> None

set_failed(device: str, message: str) -> None

update_configuration(key: str, value: object) -> None

set_locked(names: frozenset[str]) -> None

step_down() -> None

step_up() -> None

Bases: QGroupBox

A device's axes, its state, and buttons to stop it and save where it is.

Parameters:

Raises:

sig_move = Signal(str, str, float)

sig_move_to = Signal(str, dict)

sig_save = Signal(str)

sig_stop = Signal(str)

positions: dict[str, float]

focused_axis() -> str | None

step(axis: str, sign: float) -> None

set_readback(axis: str, value: float) -> None

set_limits(
    axis: str, low: float | None, high: float | None
) -> None

set_moving(moving: bool) -> None

show_message(message: str) -> None

set_failed(message: str) -> None

set_locked(locked: bool) -> None

set_axes_locked(axes: Set[str]) -> None

set_repeat_interval(milliseconds: int) -> None

The acquisition presenter with its view.

The positioner presenter with its view.

The light presenter with its view.