User-interface and worker API

Measurement logic communicates through a small adapter interface. This keeps terminal and Qt front ends separate from the measurement environment. Blocking device operations belong in a worker thread; adapter calls transport prompts, progress, interruption, and log information.

class mpylab.env.ui.ui_adapter.MeasurementUIAdapter

Abstract UI adapter contract for measurement flows.

ask(msg: str = 'Are you ready?', buttons: list[str] | None = None, level: str = '', data: dict[Any, Any] | None = None) → int

Display a question and return the selected button index.

Parameters:

  • msg (str, optional) – User-facing prompt text.

  • buttons (list of str or None, optional) – Available answer labels.

  • level (str, optional) – Message severity or presentation level.

  • data (dict or None, optional) – Structured context supplied with the prompt.

check_interrupt() → int | None

Check for an interrupt request using key polling.

Returns:

Pending key code, or None when no interrupt was requested.

Return type:

int or None

emit_log(block, *args) → None

Emit one structured log block.

Parameters:

  • block (object) – Log block or message.

  • *args (object) – Additional arguments forwarded to logger callbacks.

poll_key() → int | None

Poll one pending key event, if any.

post_user_event() → None

Run hook after user-facing event.

pre_user_event() → None

Run hook before user-facing event.

run_interactive(obj: Any, banner: str) → None

Start an interactive shell for an object.

Parameters:

  • obj (object) – Object exposed to the interactive session.

  • banner (str) – Introductory session text.

class mpylab.env.ui.ui_adapter.TUIAdapter(messenger: Callable[[str, list[str] | None, str, dict[Any, Any] | None], int], logger: list[Callable[[...], Any]] | None, interrupt_tester: Callable[[], int | None], pre_user_event: Callable[[], None], post_user_event: Callable[[], None], interactive_runner: Callable[[Any, str], None])

Default terminal adapter using callbacks supplied by Measure.

Parameters:

  • messenger (callable) – Callback that displays prompts and returns an answer index.

  • logger (list of callable or None) – Callbacks receiving structured log blocks.

  • interrupt_tester (callable) – Non-blocking callback returning a pending key code.

  • pre_user_event (callable) – Hook invoked before user interaction.

  • post_user_event (callable) – Hook invoked after user interaction.

  • interactive_runner (callable) – Callback starting an interactive session.

ask(msg: str = 'Are you ready?', buttons: list[str] | None = None, level: str = '', data: dict[Any, Any] | None = None) → int

Forward a prompt to the configured messenger.

Parameters:

  • msg (str, optional) – User-facing prompt text.

  • buttons (list of str or None, optional) – Available answer labels.

  • level (str, optional) – Message severity or presentation level.

  • data (dict or None, optional) – Structured context supplied with the prompt.

Returns:

Index of the selected answer.

Return type:

int

emit_log(block, *args) → None

Forward one log block to all configured loggers.

Parameters:

  • block (object) – Log block or message.

  • *args (object) – Additional arguments forwarded to every logger callback.

poll_key() → int | None

Poll the configured interrupt tester.

Returns:

Pending key code, or None when no key is available.

Return type:

int or None

post_user_event() → None

Call post-user-event hook.

pre_user_event() → None

Call pre-user-event hook.

run_interactive(obj: Any, banner: str) → None

Call the interactive runner with an object and banner.

Parameters:

  • obj (object) – Object exposed to the interactive session.

  • banner (str) – Introductory session text.

set_interactive_runner(runner: Callable[[Any, str], None]) → None

Replace the interactive-session callback.

Parameters:

runner (callable) – Callback accepting the exposed object and session banner.

set_interrupt_tester(tester: Callable[[], int | None]) → None

Replace the interrupt polling callback.

Parameters:

tester (callable) – Non-blocking callback returning a pending key code.

set_logger(logger: list[Callable[[...], Any]] | None) → None

Replace the logger callback list.

Parameters:

logger (list of callable or None) – Callbacks receiving structured log blocks.

set_messenger(messenger: Callable[[str, list[str] | None, str, dict[Any, Any] | None], int]) → None

Replace the messenger callback.

Parameters:

messenger (callable) – Callback that displays prompts and returns an answer index.

set_post_user_event(cb: Callable[[], None]) → None

Replace the post-user-event callback.

Parameters:

cb (callable) – Hook invoked after user interaction.

set_pre_user_event(cb: Callable[[], None]) → None

Replace the pre-user-event callback.

Parameters:

cb (callable) – Hook invoked before user interaction.

mpylab.env.ui.ui_adapter.resolve_poll_key(handler: Any, caller_locals: dict[str, Any] | None = None) → Callable[[], int | None] | None

Resolve a poll-key callable from a handler or caller context.

Parameters:

  • handler (object) – Explicit polling callback, if callable.

  • caller_locals (dict or None, optional) – Caller namespace whose self.PollKey method is used as a fallback.

Returns:

Non-blocking key polling callback, or None when unavailable.

Return type:

callable or None

Qt adapter and runner

class mpylab.env.ui.qt_adapter.QtUIAdapter(interrupt_key: str = 'q')

Qt-backed measurement UI adapter.

The stop button does not access hardware directly. It sets an interrupt flag that is returned once by poll_key(), allowing the existing measurement safety path to call RFOff_Devices from the measurement worker thread.

Parameters:

interrupt_key (str, optional) – Synthetic key returned once after a stop request. The first character is used and defaults to "q".

answer_prompt_with_quit() → bool

Answer an active prompt with Quit when available.

Returns:

True if a matching answer was submitted, otherwise False.

Return type:

bool

ask(msg: str = 'Are you ready?', buttons: list[str] | None = None, level: str = '', data: dict[Any, Any] | None = None) → int

Display a prompt and wait for the selected button index.

This method is called from the measurement worker. Communication with Qt widgets uses queued signals; waiting occurs on a condition and does not block the Qt event loop.

Parameters:

  • msg (str, optional) – User-facing prompt text.

  • buttons (list of str or None, optional) – Available answers. None provides Ok and Quit.

  • level (str, optional) – Message severity or presentation level.

  • data (dict or None, optional) – Structured context supplied with the prompt.

Returns:

Selected answer index, or -1 for an informational message without buttons.

Return type:

int

create_widget(parent=None) → MeasurementControlWidget

Create the control widget for this adapter.

Parameters:

parent (QWidget or None, optional) – Parent widget.

Returns:

Newly created control widget.

Return type:

MeasurementControlWidget

emit_log(block, *args) → None

Emit log data to Qt and configured logger callbacks.

Parameters:

  • block (object) – Log block or message displayed as text in Qt.

  • *args (object) – Additional arguments forwarded to logger callbacks.

poll_key() → int | None

Return a synthetic key code after a Stop / RF Off request.

Returns:

Configured interrupt key once per request, otherwise None.

Return type:

int or None

post_user_event() → None

Mark UI state after a user-facing event.

pre_user_event() → None

Mark UI state before a user-facing event.

request_interrupt() → None

Request measurement interruption at the next poll point.

request_stop() → None

Request stop, answering an active Quit prompt if possible.

run_interactive(obj: Any, banner: str) → None

Report that terminal-style interactive mode is unavailable.

Parameters:

  • obj (object) – Object that would have been exposed to an interactive session. It is not used by the Qt adapter.

  • banner (str) – Session description included in the log message.

set_configuration(config, trace=None) → None

Store a read-only effective configuration for the Qt view.

Parameters:

  • config (dict) – Effective configuration before runtime UI objects are attached.

  • trace (ConfigTrace or None, optional) – Ordered provenance of the configuration values.

Raises:

TypeError – If the configuration or trace cannot be represented.

set_logger(logger: list[Any] | None) → None

Set optional additional logger callbacks.

Parameters:

logger (list or None) – Objects that are callable are retained as log callbacks.

submit_answer(index: int) → None

Submit a prompt answer from the UI thread.

Parameters:

index (int) – Zero-based answer index.

submit_eut_status(status: str) → bool

Submit a manual during-exposure EUT observation from Qt.

Parameters:

status (str) – Functional-state identifier accepted by the manual EUT monitor.

Returns:

True if the observation was accepted, otherwise False.

Return type:

bool

submit_post_exposure_state(state: str, recovery: str) → bool

Submit post-exposure state and recovery observations.

Parameters:

  • state (str) – Functional state observed after exposure.

  • recovery (str) – Recovery category associated with that state.

Returns:

True if the observation was accepted, otherwise False.

Return type:

bool

class mpylab.env.ui.qt_adapter.MeasurementControlWidget(*args: Any, **kwargs: Any)

Display measurement messages, prompts, EUT state, and stop controls.

Parameters:

  • adapter (QtUIAdapter) – Adapter receiving all user actions from the widget.

  • parent (QWidget or None, optional) – Parent widget.

append_log(text: str) → None

Append one log message to the output pane.

clear_prompt() → None

Clear prompt text and dynamic buttons.

show_prompt(msg: str, buttons: list[str], level: str = '', data: object = None) → None

Show a prompt and create one button per answer.

class mpylab.env.qt_runner.MeasurementTask(*args: Any, **kwargs: Any)

Run a measurement script in a Qt worker thread.

Parameters:

  • measurement_module (module) – Module providing a run(config) function.

  • config (dict) – Measurement configuration passed to the module.

failed

alias of object

finished

alias of int

run()

Execute the configured measurement.

mpylab.env.qt_runner.attach_ui_adapter(config, ui_adapter)

Attach a Qt UI adapter and remove non-interactive callbacks.

Parameters:

  • config (dict) – Measurement configuration modified in place.

  • ui_adapter (QtUIAdapter) – Adapter and optional manual EUT monitor to attach.

mpylab.env.qt_runner.run_qt_script(script_path, argv=None, module_name=None, window_title=None)

Start a Qt UI and run a measurement script in a worker thread.

Parameters:

  • script_path (path-like) – Path to the measurement script.

  • argv (sequence of str or None, optional) – Configuration arguments. None uses command-line arguments.

  • module_name (str or None, optional) – Import name assigned to the loaded script module.

  • window_title (str or None, optional) – Title overriding the adapter widget’s default title.

Returns:

Qt application exit code, or 2 for an invalid configuration.

Return type:

int

Emission sweep review

The workflow receives detached decisions and owns validation and persistence. Adapters may display/edit snapshots but do not commit measurement history. See TEM emission data for terminal operation and PNG output.

class mpylab.env.ui.sweep_review.SweepReviewAdapter(*args, **kwargs)

Interface for Qt, terminal or application-specific sweep review.

prepare(tem)

Check availability before acquisition.

Parameters:

tem (TEMCell) – Measurement environment providing UI hooks and output paths.

review(tem, description, record)

Return an explicit decision from a detached sweep snapshot.

Parameters:

  • tem (TEMCell) – Environment providing pre/post user-event hooks.

  • description (str) – Measurement description.

  • record (dict) – Detached snapshot; changes do not modify retained measurement data.

Returns:

Operator decision and edited metadata.

Return type:

SweepReviewDecision

Raises:

UserWarning – Save and exit without evaluation was requested.

select(tem, raw, triplets)

Propose explicitly selected evaluations without changing history.

Parameters:

  • tem (TEMCell) – Environment providing user-event hooks.

  • raw (dict) – Detached retained-sweep data.

  • triplets (sequence of sequence) – Existing canonical orientation groups.

Returns:

Proposed evaluations. Empty means no new evaluation.

Return type:

list of SweepEvaluationSelection

class mpylab.env.ui.sweep_review.SweepReviewDecision(action: str, variant: str, notes: str)

Operator decision without a reference to measurement or GUI objects.

action

repeat, continue or stop (finish and select evaluations).

Type:

str

variant

EUT variant as measured.

Type:

str

notes

Notes attached to this sweep.

Type:

str

class mpylab.env.ui.sweep_review.SweepEvaluationSelection(name: str, sweeps: dict, created_at_utc: str | None = None)

Proposed evaluation; the workflow validates and stores it.

name

Non-empty, unused evaluation name.

Type:

str

sweeps

One retained sweep ID per orientation.

Type:

dict

created_at_utc

ISO UTC timestamp when this set was added. None keeps compatibility with adapters that supply only name and sweeps; the workflow then records its commit time.

Type:

str or None, optional

class mpylab.env.ui.emission_review_tui.TerminalSweepReviewAdapter(output_dir=None, *, input_fn=None, output_fn=None)

Review sweeps without Qt and keep their plots as PNG files.

Parameters:

  • output_dir (path-like or None, optional) – Image directory; None derives it from the measurement autosave path.

  • input_fn (callable or None, optional) – Prompt callback returning text. None uses input from an interactive stdin. Explicit callbacks support application integration and tests.

  • output_fn (callable or None, optional) – Text output callback. None uses print.

prepare(tem)

Check terminal input and image-directory access before acquisition.

Parameters:

tem (TEMCell) – Measurement environment providing an optional autosave path.

Raises:

  • RuntimeError – No interactive stdin or explicit input callback is available, or normal stdin review was requested from a worker thread.

  • OSError – Images cannot be written to the configured directory.

review(tem, description, record)

Save the plot and ask for metadata and an explicit sweep decision.

Parameters:

  • tem (TEMCell) – Measurement environment providing user-event hooks.

  • description (str) – Measurement description.

  • record (dict) – Detached retained-sweep snapshot.

Returns:

Repeat, continue or finish-acquisition decision and metadata.

Return type:

SweepReviewDecision

Raises:

  • UserWarning – Save/exit, EOF, Ctrl-C or interruption was requested.

  • OSError – The PNG cannot be written.

select(tem, raw, triplets)

Select complete orientation sets from the retained-sweep inventory.

Parameters:

  • tem (TEMCell) – Measurement environment providing user-event hooks.

  • raw (dict) – Detached retained-sweep data.

  • triplets (sequence of sequence) – Canonical orthogonal orientation groups.

Returns:

Explicit selections. Save/exit, EOF or Ctrl-C discards all newly staged selections and returns an empty list.

Return type:

list of SweepEvaluationSelection

class mpylab.env.ui.emission_review.QtSweepReviewAdapter

Adapt the existing Qt dialogs to detached sweep-review decisions.

prepare(tem)

Validate Qt availability before acquisition.

Parameters:

tem (TEMCell) – Measurement environment.

review(tem, description, record)

Return the existing dialog’s decision and edited metadata.

Parameters:

  • tem (TEMCell) – Measurement environment and GUI-thread dispatcher.

  • description (str) – Measurement description.

  • record (dict) – Detached sweep snapshot.

Returns:

Explicit decision and metadata.

Return type:

SweepReviewDecision

Raises:

UserWarning – The GUI requested save and exit without evaluation.

select(tem, raw, triplets)

Translate the existing selection dialog’s detached result.

Parameters:

  • tem (TEMCell) – Measurement environment and GUI-thread dispatcher.

  • raw (dict) – Detached retained-sweep data.

  • triplets (sequence of sequence) – Canonical orientation groups.

Returns:

Explicitly added evaluations.

Return type:

list of SweepEvaluationSelection

mpylab.env.ui.emission_review.resolve_sweep_review(tem, backend='auto', output_dir=None)

Prepare an explicit adapter, Qt, or a terminal fallback.

Parameters:

  • tem (TEMCell) – Measurement environment.

  • backend (str or SweepReviewAdapter, optional) – auto prefers available Qt with a display/GUI dispatcher, otherwise terminal review. qt and terminal choose explicitly. An adapter object may implement prepare, review and select directly.

  • output_dir (path-like or None, optional) – Terminal image directory. None derives a directory from the autosave path, falling back to tem-emission-review in the working directory.

Returns:

Prepared adapter, kept local to the calling workflow.

Return type:

SweepReviewAdapter

Raises:

  • ValueError – Unknown backend or incomplete adapter contract.

  • RuntimeError – No usable interactive display or terminal is available.

  • OSError – Terminal images cannot be written.

Long receiver scans

class mpylab.device.receiver_scan_worker.ReceiverScanWorker(receiver, scan_kwargs=None, on_point=None, on_done=None, on_error=None, on_cancel=None, safety_stop=None)

Run a receiver RunScan call in a background thread.

Callbacks are executed from the worker thread. GUI frontends should bridge them into the UI thread, for example with Qt signals or a thread-safe queue.

is_running()

Return whether the scan thread is currently active.

join(timeout=None)

Wait for the worker thread and return whether it has finished.

request_stop()

Request cancellation and call the optional safety stop callback.

start()

Start the receiver scan in a daemon thread and return self.

wait_finished(timeout=None)

Wait for the worker completion event.

Device test UI lifecycle and workers

class mpylab.device.ui_task_executor.DeviceTaskExecutor(*args: Any, **kwargs: Any)

Run submitted device callables serially on one persistent QThread.

Parameters:

parent (PySide6.QtCore.QObject, optional) – Qt owner that controls the executor’s lifetime.

completed

alias of object

shutdown(timeout_ms=3000)

Stop the worker event loop and wait for its thread to finish.

Parameters:

timeout_ms (int, optional) – Maximum wait time in milliseconds.

Returns:

True when the worker thread stopped within the timeout.

Return type:

bool

submit(func)

Queue one callable for execution.

Parameters:

func (callable) – Zero-argument callable to run in the persistent worker thread.

Return type:

None

Raises:

RuntimeError – If the worker thread has already stopped.

mpylab.device.ui_task_executor.ensure_task_executor(owner, completed_slot, idle_slot)

Return an owner’s executor, creating and connecting it once.

Parameters:

  • owner (PySide6.QtCore.QObject) – UI object that owns the executor.

  • completed_slot (callable) – Slot receiving (result, error) for each task.

  • idle_slot (callable) – Slot called after result delivery.

Returns:

Existing or newly created executor for owner.

Return type:

DeviceTaskExecutor

mpylab.device.ui_task_executor.shutdown_task_executor(owner)

Stop an owner’s executor if it has been created.

Parameters:

owner (PySide6.QtCore.QObject) – UI object whose executor should stop.

Returns:

True if no executor exists or its thread stopped in time.

Return type:

bool

mpylab.device.ui_driver_lifecycle.result_error_code(result)

Return an integer driver error code when result contains one.

Parameters:

result (object) – Value returned by a driver call. May be an integer, an integer-like sequence such as (error_code, ...) or [error_code, ...], or any other object for which no error code can be extracted.

Returns:

The extracted driver error code, or 0 when result does not contain an integer error code.

Return type:

int

mpylab.device.ui_driver_lifecycle.require_driver_success(result, operation, allowed_error_codes=())

Return result or raise when it contains a driver error code.

Parameters:

  • result (object) – Value returned by a driver call, interpreted by result_error_code().

  • operation (str) – Human-readable name of the operation being performed. Used in the error message of the raised exception.

  • allowed_error_codes (iterable of int, optional) – Error codes that are considered non-fatal and therefore do not trigger an exception. Defaults to the empty tuple, i.e. any non-zero error code raises.

Returns:

The unmodified result passed in, when it contains no unexpected driver error code.

Return type:

object

Raises:

RuntimeError – If result contains an error code that is neither 0 nor listed in allowed_error_codes.

mpylab.device.ui_driver_lifecycle.shutdown_driver_instances(drivers, *, safety_calls=(), cleanup_methods=('Quit', 'close'))

Safely stop and close each unique driver instance.

All instances are attempted even if an earlier call fails. A combined RuntimeError is raised afterwards so callers do not silently discard a device whose safe shutdown could not be confirmed.

Parameters:

  • drivers (iterable) – Driver instances to shut down. None entries and duplicate instances (compared by identity) are skipped.

  • safety_calls (sequence of (str, tuple), keyword-only, optional) – (method_name, args) pairs describing safety-relevant calls to attempt on each driver before cleanup. A driver method is skipped when it does not exist.

  • cleanup_methods (sequence of str, keyword-only, optional) – Names of cleanup methods to call on each driver, tried in order until one succeeds. Defaults to ("Quit", "close").

Returns:

One entry per successful call: (driver, method_name, result).

Return type:

tuple of (object, str, object)

Raises:

RuntimeError – If any safety or cleanup call raises or returns a non-zero error code. The message combines all failures encountered.

See UI adapters and worker interface for threading, stop, RF-off, and EUT monitoring guidance.

Application identity and branding

class mpylab.gui.ApplicationIdentity(name: str, version: str, description: str, resource_package: str, resource_directory: tuple[str, ...], documentation_url: str, project_url: str, author: str = 'Hans Georg Krauthäuser', license_name: str = 'GPL-3.0-or-later', tagline: str = '')

Application-specific content for the optional Qt branding helpers.

Parameters:

  • name (str) – Application/menu name.

  • version (str) – Installed application version.

  • description (str) – Short user-facing description.

  • resource_package (str) – Importable package containing the artwork.

  • resource_directory (tuple of str) – Relative resource-directory components in that package.

  • documentation_url (str) – Link to maintained user documentation.

  • project_url (str) – Link to the source project.

  • author (str) – Copyright attribution.

  • license_name (str) – Software/artwork license description.

  • tagline (str) – Accessible artwork description; optional About subtitle.

Notes

The resource directory must provide icon.png, logo.svg and logo-inverse.svg. Keep source attribution and artwork licensing beside those assets.

mpylab.gui.qt.create_application(argv, identity=ApplicationIdentity(name='MPyLab', version='1.0.33', description='Graph-based laboratory measurements and device test tools.', resource_package='mpylab.gui', resource_directory=('resources', 'branding'), documentation_url='https://mpylab-75fcff.gp.hrz.tu-chemnitz.de/', project_url='https://gitlab.hrz.tu-chemnitz.de/chair-of-electromagnetic-theory-and-compatibility-at-tu-dresden/mpylab/mpylab', author='Hans Georg Krauthäuser', license_name='GPL-3.0-or-later', tagline='Graph-Based Lab Measurements'))

Create or reuse QApplication with identity established before Cocoa starts.

Parameters:

  • argv (sequence of str) – Qt command-line arguments including the executable name.

  • identity (ApplicationIdentity, optional) – Application and artwork metadata; defaults to MPyLab.

Returns:

Existing application or a newly initialized one.

Return type:

QApplication

Notes

Existing host applications retain their identity and dialog preferences. On macOS a new application uses Qt dialogs to avoid the native NSAlert rendering crash observed with Qt 6.11.2 on the development Mac. Native menus remain enabled. No interpreter or system files are modified.

mpylab.gui.qt.install_branding(window, identity=ApplicationIdentity(name='MPyLab', version='1.0.33', description='Graph-based laboratory measurements and device test tools.', resource_package='mpylab.gui', resource_directory=('resources', 'branding'), documentation_url='https://mpylab-75fcff.gp.hrz.tu-chemnitz.de/', project_url='https://gitlab.hrz.tu-chemnitz.de/chair-of-electromagnetic-theory-and-compatibility-at-tu-dresden/mpylab/mpylab', author='Hans Georg Krauthäuser', license_name='GPL-3.0-or-later', tagline='Graph-Based Lab Measurements'), *, menu_bar=None, about_action=None, quit_action=None)

Add project identity, About and Quit without replacing a close handler.

Parameters:

  • window (QWidget) – Tool window with an existing layout, or QMainWindow.

  • identity (ApplicationIdentity, optional) – Application and artwork metadata; defaults to MPyLab.

  • menu_bar (QMenuBar, optional) – Existing menu bar. Otherwise use or create the window’s menu bar.

  • about_action (QAction, optional) – Existing About action with no connected About callback.

  • quit_action (QAction, optional) – Existing Quit action already connected to the window’s close handler.

Returns:

Window-owned controller exposing about_action, quit_action and dialog. Repeated installation returns the same controller without adding menus.

Return type:

QObject

Raises:

  • ValueError – A plain QWidget has no layout yet or an artwork resource is invalid.

  • FileNotFoundError – The application did not package its artwork.

Notes

New Quit actions call window.close(), never QApplication.quit(). This keeps existing RF-off, worker shutdown, confirmation and autosave paths intact.

mpylab.gui.qt.application_icon(identity=ApplicationIdentity(name='MPyLab', version='1.0.33', description='Graph-based laboratory measurements and device test tools.', resource_package='mpylab.gui', resource_directory=('resources', 'branding'), documentation_url='https://mpylab-75fcff.gp.hrz.tu-chemnitz.de/', project_url='https://gitlab.hrz.tu-chemnitz.de/chair-of-electromagnetic-theory-and-compatibility-at-tu-dresden/mpylab/mpylab', author='Hans Georg Krauthäuser', license_name='GPL-3.0-or-later', tagline='Graph-Based Lab Measurements'))

Load an icon from installed package resources.

Parameters:

identity (ApplicationIdentity, optional) – Application and artwork metadata; defaults to MPyLab.

Returns:

Application icon with a neutral background.

Return type:

QIcon

Raises:

  • FileNotFoundError – The application did not package the requested artwork.

  • ValueError – Packaged icon data cannot be decoded.

class mpylab.gui.qt.AboutDialog(*args: Any, **kwargs: Any)

Reusable, nonmodal application information with palette-aware artwork.

Parameters:

  • identity (ApplicationIdentity) – Application and artwork metadata.

  • parent (QWidget, optional) – Owning tool window.

  • tool_name (str, optional) – Additional tool name inside the dialog for a shared application identity.

See GUI identity and application menus for resources, native macOS behavior and consumer adoption order.