3.5.1

Automatically generated by python-semantic-release

CHANGELOG.md

@@ -1,6 +1,71 @@
 # CHANGELOG
 
 
+## v3.5.1 (2026-04-20)
+
+### Bug Fixes
+
+- Don't assume attr exists if we timed out waiting for it
+  ([`f7a1ee4`](https://github.com/bec-project/bec_widgets/commit/f7a1ee49a42c58ba315c8957b45a80d862ffe745))
+
+### Refactoring
+
+- Don't import real widgets in client
+  ([`8e51c1a`](https://github.com/bec-project/bec_widgets/commit/8e51c1adb6a7658c54846794cf97b774cbac2193))
+
+
+## v3.5.0 (2026-04-14)
+
+### Bug Fixes
+
+- Connect signals the correct way around
+  ([`f562c61`](https://github.com/bec-project/bec_widgets/commit/f562c61e3cec3387f6821bad74403beeb3436355))
+
+- Create new bec shell if deleted
+  ([`1754e75`](https://github.com/bec-project/bec_widgets/commit/1754e759f0c59f2f4063f661bacd334127326947))
+
+- Formatting in plugin template
+  ([`fa2ef83`](https://github.com/bec-project/bec_widgets/commit/fa2ef83bb9dfeeb4c5fc7cd77168c16101c32693))
+
+- **bec_console**: Persistent bec session
+  ([`9b0ec9d`](https://github.com/bec-project/bec_widgets/commit/9b0ec9dd79ad1adc5d211dd703db7441da965f34))
+
+### Features
+
+- Add qtermwidget plugin and replace web term
+  ([`02cb393`](https://github.com/bec-project/bec_widgets/commit/02cb393bb086165dc64917b633d5570d02e1a2a9))
+
+### Refactoring
+
+- Code cleanup
+  ([`bda5d38`](https://github.com/bec-project/bec_widgets/commit/bda5d389651bb2b13734cd31159679e85b1bd583))
+
+
+## v3.4.4 (2026-04-14)
+
+### Bug Fixes
+
+- Check duplicate stream sub
+  ([`c7de320`](https://github.com/bec-project/bec_widgets/commit/c7de320ca564264a31b84931f553170f25659685))
+
+- Check for duplicate subscriptions in GUIClient
+  ([`37747ba`](https://github.com/bec-project/bec_widgets/commit/37747babda407040333c6bd04646be9a49e0ee81))
+
+- Make gui client registry callback non static
+  ([`32f5d48`](https://github.com/bec-project/bec_widgets/commit/32f5d486d3fc8d41df2668c58932ae982819b285))
+
+- Remove staticmethod subscription
+  ([`0ff1fdc`](https://github.com/bec-project/bec_widgets/commit/0ff1fdc81578eec3ffc5d4030fca7b357a0b4c2f))
+
+
+## v3.4.3 (2026-04-13)
+
+### Bug Fixes
+
+- Set OPHYD_CONTROL_LAYER to dummy for tests
+  ([`5e84d3b`](https://github.com/bec-project/bec_widgets/commit/5e84d3bec608ae9f2ee6dae67db2e3e1387b1f59))
+
+
 ## v3.4.2 (2026-04-01)
 
 ### Bug Fixes

bec_widgets/cli/client.py

@@ -13,7 +13,7 @@ from typing import Literal, Optional
 from bec_lib.logger import bec_logger
 
 from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module
+from bec_widgets.utils.bec_plugin_helper import get_plugin_client_module
 
 logger = bec_logger.logger
 
@@ -62,29 +62,19 @@ _Widgets = {
 
 
 try:
-    _plugin_widgets = get_all_plugin_widgets().as_dict()
     plugin_client = get_plugin_client_module()
-    Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
-
-    if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
-        for _widget in _overlap:
-            logger.warning(
-                f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !"
-            )
     for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
         if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
+            if plugin_name not in _Widgets:
+                _Widgets[plugin_name] = plugin_name
             if plugin_name in globals():
-                conflicting_file = (
-                    inspect.getfile(_plugin_widgets[plugin_name])
-                    if plugin_name in _plugin_widgets
-                    else f"{plugin_client}"
-                )
                 logger.warning(
-                    f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
+                    f"Plugin widget {plugin_name} in {plugin_class._IMPORT_MODULE} conflicts with a built-in class!"
                 )
                 continue
-            if plugin_name not in _overlap:
+            else:
                 globals()[plugin_name] = plugin_class
+        Widgets = _WidgetsEnumType("Widgets", _Widgets)
 except ImportError as e:
     logger.error(f"Failed loading plugins: \n{reduce(add, traceback.format_exception(e))}")
 
@@ -92,6 +82,8 @@ except ImportError as e:
 class AdminView(RPCBase):
     """A view for administrators to change the current active experiment, manage messaging"""
 
+    _IMPORT_MODULE = "bec_widgets.applications.views.admin_view.admin_view"
+
     @rpc_call
     def activate(self) -> "None":
         """
@@ -100,6 +92,8 @@ class AdminView(RPCBase):
 
 
 class AutoUpdates(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.containers.auto_update.auto_updates"
+
     @property
     @rpc_call
     def enabled(self) -> "bool":
@@ -136,6 +130,8 @@ class AutoUpdates(RPCBase):
 
 
 class AvailableDeviceResources(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_resources"
+
     @rpc_call
     def remove(self):
         """
@@ -156,6 +152,8 @@ class AvailableDeviceResources(RPCBase):
 
 
 class BECDockArea(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.containers.dock_area.dock_area"
+
     @rpc_call
     def new(
         self,
@@ -391,6 +389,8 @@ class BECDockArea(RPCBase):
 
 
 class BECMainWindow(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.containers.main_window.main_window"
+
     @rpc_call
     def remove(self):
         """
@@ -413,6 +413,8 @@ class BECMainWindow(RPCBase):
 class BECProgressBar(RPCBase):
     """A custom progress bar with smooth transitions. The displayed text can be customized using a template."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.progress.bec_progressbar.bec_progressbar"
+
     @rpc_call
     def set_value(self, value):
         """
@@ -486,6 +488,8 @@ class BECProgressBar(RPCBase):
 class BECQueue(RPCBase):
     """Widget to display the BEC queue."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.services.bec_queue.bec_queue"
+
     @rpc_call
     def remove(self):
         """
@@ -508,6 +512,8 @@ class BECQueue(RPCBase):
 class BECShell(RPCBase):
     """A BecConsole pre-configured to run the BEC shell."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.editors.bec_console.bec_console"
+
     @rpc_call
     def remove(self):
         """
@@ -530,6 +536,8 @@ class BECShell(RPCBase):
 class BECStatusBox(RPCBase):
     """An autonomous widget to display the status of BEC services."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.services.bec_status_box.bec_status_box"
+
     @rpc_call
     def get_server_state(self) -> "str":
         """
@@ -565,6 +573,8 @@ class BECStatusBox(RPCBase):
 class BaseROI(RPCBase):
     """Base class for all Region of Interest (ROI) implementations."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
+
     @property
     @rpc_call
     def label(self) -> "str":
@@ -694,6 +704,8 @@ class BaseROI(RPCBase):
 class BecConsole(RPCBase):
     """A console widget with access to a shared registry of terminals, such that instances can be moved around."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.editors.bec_console.bec_console"
+
     @rpc_call
     def remove(self):
         """
@@ -716,6 +728,8 @@ class BecConsole(RPCBase):
 class CircularROI(RPCBase):
     """Circular Region of Interest with center/diameter tracking and auto-labeling."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
+
     @property
     @rpc_call
     def label(self) -> "str":
@@ -843,6 +857,8 @@ class CircularROI(RPCBase):
 
 
 class Curve(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.waveform.curve"
+
     @rpc_call
     def remove(self):
         """
@@ -1009,6 +1025,8 @@ class Curve(RPCBase):
 class DapComboBox(RPCBase):
     """Editable combobox listing the available DAP models."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.dap.dap_combo_box.dap_combo_box"
+
     @rpc_call
     def select_y_axis(self, y_axis: str):
         """
@@ -1040,6 +1058,8 @@ class DapComboBox(RPCBase):
 class DeveloperView(RPCBase):
     """A view for users to write scripts and macros and execute them within the application."""
 
+    _IMPORT_MODULE = "bec_widgets.applications.views.developer_view.developer_view"
+
     @rpc_call
     def activate(self) -> "None":
         """
@@ -1050,6 +1070,8 @@ class DeveloperView(RPCBase):
 class DeviceBrowser(RPCBase):
     """DeviceBrowser is a widget that displays all available devices in the current BEC session."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.services.device_browser.device_browser"
+
     @rpc_call
     def remove(self):
         """
@@ -1072,6 +1094,8 @@ class DeviceBrowser(RPCBase):
 class DeviceInitializationProgressBar(RPCBase):
     """A progress bar that displays the progress of device initialization."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.progress.device_initialization_progress_bar.device_initialization_progress_bar"
+
     @rpc_call
     def remove(self):
         """
@@ -1094,6 +1118,8 @@ class DeviceInitializationProgressBar(RPCBase):
 class DeviceInputBase(RPCBase):
     """Mixin base class for device input widgets."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.control.device_input.base_classes.device_input_base"
+
     @rpc_call
     def remove(self):
         """
@@ -1116,6 +1142,8 @@ class DeviceInputBase(RPCBase):
 class DeviceManagerView(RPCBase):
     """A view for users to manage devices within the application."""
 
+    _IMPORT_MODULE = "bec_widgets.applications.views.device_manager_view.device_manager_view"
+
     @rpc_call
     def activate(self) -> "None":
         """
@@ -1126,6 +1154,8 @@ class DeviceManagerView(RPCBase):
 class DockAreaView(RPCBase):
     """Modular dock area view for arranging and managing multiple dockable widgets."""
 
+    _IMPORT_MODULE = "bec_widgets.applications.views.dock_area_view.dock_area_view"
+
     @rpc_call
     def activate(self) -> "None":
         """
@@ -1369,6 +1399,8 @@ class DockAreaView(RPCBase):
 class DockAreaWidget(RPCBase):
     """Lightweight dock area that exposes the core Qt ADS docking helpers without any"""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.containers.dock_area.basic_dock_area"
+
     @rpc_call
     def new(
         self,
@@ -1553,6 +1585,8 @@ class DockAreaWidget(RPCBase):
 class EllipticalROI(RPCBase):
     """Elliptical Region of Interest with centre/width/height tracking and auto-labelling."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
+
     @property
     @rpc_call
     def label(self) -> "str":
@@ -1675,6 +1709,8 @@ class EllipticalROI(RPCBase):
 class Heatmap(RPCBase):
     """Heatmap widget for visualizing 2d grid data with color mapping for the z-axis."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.heatmap.heatmap"
+
     @rpc_call
     def remove(self):
         """
@@ -2373,6 +2409,8 @@ class Heatmap(RPCBase):
 class Image(RPCBase):
     """Image widget for displaying 2D data."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.image.image"
+
     @rpc_call
     def remove(self):
         """
@@ -2984,6 +3022,8 @@ class Image(RPCBase):
 
 
 class ImageItem(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.image.image_item"
+
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -3134,6 +3174,8 @@ class ImageItem(RPCBase):
 
 
 class LaunchWindow(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.applications.launch_window"
+
     @rpc_call
     def show_launcher(self):
         """
@@ -3150,6 +3192,8 @@ class LaunchWindow(RPCBase):
 class LogPanel(RPCBase):
     """Displays a log panel"""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.utility.logpanel.logpanel"
+
     @rpc_call
     def set_plain_text(self, text: str) -> None:
         """
@@ -3169,12 +3213,15 @@ class LogPanel(RPCBase):
         """
 
 
-class Minesweeper(RPCBase): ...
+class Minesweeper(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.games.minesweeper"
 
 
 class MonacoDock(RPCBase):
     """MonacoDock is a dock widget that contains Monaco editor instances."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.editors.monaco.monaco_dock"
+
     @rpc_call
     def new(
         self,
@@ -3359,6 +3406,8 @@ class MonacoDock(RPCBase):
 class MonacoWidget(RPCBase):
     """A simple Monaco editor widget"""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.editors.monaco.monaco_widget"
+
     @rpc_call
     def set_text(
         self, text: "str", file_name: "str | None" = None, reset: "bool" = False
@@ -3533,6 +3582,8 @@ class MonacoWidget(RPCBase):
 class MotorMap(RPCBase):
     """Motor map widget for plotting motor positions in 2D including a trace of the last points."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.motor_map.motor_map"
+
     @rpc_call
     def remove(self):
         """
@@ -4003,6 +4054,8 @@ class MotorMap(RPCBase):
 class MultiWaveform(RPCBase):
     """MultiWaveform widget for displaying multiple waveforms emitted by a single signal."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.multi_waveform.multi_waveform"
+
     @rpc_call
     def remove(self):
         """
@@ -4462,6 +4515,8 @@ class MultiWaveform(RPCBase):
 class PdfViewerWidget(RPCBase):
     """A widget to display PDF documents with toolbar controls."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.utility.pdf_viewer.pdf_viewer"
+
     @rpc_call
     def load_pdf(self, file_path: str):
         """
@@ -4593,6 +4648,10 @@ class PdfViewerWidget(RPCBase):
 class PositionIndicator(RPCBase):
     """Display a position within a defined range, e.g. motor limits."""
 
+    _IMPORT_MODULE = (
+        "bec_widgets.widgets.control.device_control.position_indicator.position_indicator"
+    )
+
     @rpc_call
     def set_value(self, position: float):
         """
@@ -4658,6 +4717,10 @@ class PositionIndicator(RPCBase):
 class PositionerBox(RPCBase):
     """Simple Widget to control a positioner in box form"""
 
+    _IMPORT_MODULE = (
+        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box"
+    )
+
     @rpc_call
     def set_positioner(self, positioner: "str | Positioner"):
         """
@@ -4690,6 +4753,8 @@ class PositionerBox(RPCBase):
 class PositionerBox2D(RPCBase):
     """Simple Widget to control two positioners in box form"""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.control.device_control.positioner_box.positioner_box_2d.positioner_box_2d"
+
     @rpc_call
     def set_positioner_hor(self, positioner: "str | Positioner"):
         """
@@ -4759,6 +4824,8 @@ class PositionerBox2D(RPCBase):
 class PositionerControlLine(RPCBase):
     """A widget that controls a single device."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line.positioner_control_line"
+
     @rpc_call
     def set_positioner(self, positioner: "str | Positioner"):
         """
@@ -4791,6 +4858,8 @@ class PositionerControlLine(RPCBase):
 class PositionerGroup(RPCBase):
     """Simple Widget to control a positioner in box form"""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.control.device_control.positioner_group.positioner_group"
+
     @rpc_call
     def set_positioners(self, device_names: "str"):
         """
@@ -4822,6 +4891,8 @@ class PositionerGroup(RPCBase):
 class RectangularROI(RPCBase):
     """Defines a rectangular Region of Interest (ROI) with additional functionality."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.roi.image_roi"
+
     @property
     @rpc_call
     def label(self) -> "str":
@@ -4951,6 +5022,8 @@ class RectangularROI(RPCBase):
 class ResumeButton(RPCBase):
     """A button that continue scan queue."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.control.buttons.button_resume.button_resume"
+
     @rpc_call
     def remove(self):
         """
@@ -4971,6 +5044,8 @@ class ResumeButton(RPCBase):
 
 
 class Ring(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.progress.ring_progress_bar.ring"
+
     @rpc_call
     def set_value(self, value: "int | float"):
         """
@@ -5064,6 +5139,8 @@ class Ring(RPCBase):
 
 
 class RingProgressBar(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar"
+
     @rpc_call
     def remove(self):
         """
@@ -5143,12 +5220,14 @@ class RingProgressBar(RPCBase):
 class SBBMonitor(RPCBase):
     """A widget to display the SBB monitor website."""
 
-    ...
+    _IMPORT_MODULE = "bec_widgets.widgets.editors.sbb_monitor.sbb_monitor"
 
 
 class ScanControl(RPCBase):
     """Widget to submit new scans to the queue."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.control.scan_control.scan_control"
+
     @rpc_call
     def attach(self):
         """
@@ -5172,6 +5251,8 @@ class ScanControl(RPCBase):
 class ScanProgressBar(RPCBase):
     """Widget to display a progress bar that is hooked up to the scan progress of a scan."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.progress.scan_progressbar.scan_progressbar"
+
     @rpc_call
     def remove(self):
         """
@@ -5194,6 +5275,8 @@ class ScanProgressBar(RPCBase):
 class ScatterCurve(RPCBase):
     """Scatter curve item for the scatter waveform widget."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.scatter_waveform.scatter_curve"
+
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -5203,6 +5286,8 @@ class ScatterCurve(RPCBase):
 
 
 class ScatterWaveform(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.scatter_waveform.scatter_waveform"
+
     @rpc_call
     def remove(self):
         """
@@ -5670,6 +5755,8 @@ class ScatterWaveform(RPCBase):
 
 
 class SignalLabel(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.widgets.utility.signal_label.signal_label"
+
     @property
     @rpc_call
     def custom_label(self) -> "str":
@@ -5814,6 +5901,8 @@ class SignalLabel(RPCBase):
 class TextBox(RPCBase):
     """A widget that displays text in plain and HTML format"""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.editors.text_box.text_box"
+
     @rpc_call
     def set_plain_text(self, text: str) -> None:
         """
@@ -5836,6 +5925,8 @@ class TextBox(RPCBase):
 class ViewBase(RPCBase):
     """Wrapper for a content widget used inside the main app's stacked view."""
 
+    _IMPORT_MODULE = "bec_widgets.applications.views.view"
+
     @rpc_call
     def activate(self) -> "None":
         """
@@ -5846,6 +5937,8 @@ class ViewBase(RPCBase):
 class Waveform(RPCBase):
     """Widget for plotting waveforms."""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.plots.waveform.waveform"
+
     @rpc_call
     def remove(self):
         """
@@ -6424,6 +6517,8 @@ class Waveform(RPCBase):
 
 
 class WaveformViewInline(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.applications.views.view"
+
     @rpc_call
     def activate(self) -> "None":
         """
@@ -6432,6 +6527,8 @@ class WaveformViewInline(RPCBase):
 
 
 class WaveformViewPopup(RPCBase):
+    _IMPORT_MODULE = "bec_widgets.applications.views.view"
+
     @rpc_call
     def activate(self) -> "None":
         """
@@ -6442,6 +6539,8 @@ class WaveformViewPopup(RPCBase):
 class WebsiteWidget(RPCBase):
     """A simple widget to display a website"""
 
+    _IMPORT_MODULE = "bec_widgets.widgets.editors.website.website"
+
     @rpc_call
     def set_url(self, url: str) -> None:
         """

bec_widgets/cli/client_utils.py

@@ -10,9 +10,9 @@ import threading
 import time
 from contextlib import contextmanager
 from threading import Lock
-from typing import TYPE_CHECKING, Literal, TypeAlias, cast
+from typing import TYPE_CHECKING, Callable, Literal, TypeAlias, cast
 
-from bec_lib.endpoints import MessageEndpoints
+from bec_lib.endpoints import EndpointInfo, MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import, lazy_import_from
 from rich.console import Console
@@ -232,6 +232,11 @@ class BECGuiClient(RPCBase):
         """The launcher object."""
         return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, object_name="launcher")
 
+    def _safe_register_stream(self, endpoint: EndpointInfo, cb: Callable, **kwargs):
+        """Check if already registered for registration in idempotent functions."""
+        if not self._client.connector.any_stream_is_registered(endpoint, cb=cb):
+            self._client.connector.register(endpoint, cb=cb, **kwargs)
+
     def connect_to_gui_server(self, gui_id: str) -> None:
         """Connect to a GUI server"""
         # Unregister the old callback
@@ -247,10 +252,9 @@ class BECGuiClient(RPCBase):
         self._ipython_registry = {}
 
         # Register the new callback
-        self._client.connector.register(
+        self._safe_register_stream(
             MessageEndpoints.gui_registry_state(self._gui_id),
             cb=self._handle_registry_update,
-            parent=self,
             from_start=True,
         )
 
@@ -531,20 +535,14 @@ class BECGuiClient(RPCBase):
 
     def _start(self, wait: bool = False) -> None:
         self._killed = False
-        self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id),
-            cb=self._handle_registry_update,
-            parent=self,
+        self._safe_register_stream(
+            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
         )
         return self._start_server(wait=wait)
 
-    @staticmethod
-    def _handle_registry_update(
-        msg: dict[str, GUIRegistryStateMessage], parent: BECGuiClient
-    ) -> None:
+    def _handle_registry_update(self, msg: dict[str, GUIRegistryStateMessage]) -> None:
         # This was causing a deadlock during shutdown, not sure why.
         # with self._lock:
-        self = parent
         self._server_registry = cast(dict[str, RegistryState], msg["data"].state)
         self._update_dynamic_namespace(self._server_registry)
 

bec_widgets/cli/generate_cli.py

@@ -7,6 +7,7 @@ import inspect
 import os
 import sys
 from pathlib import Path
+from typing import get_overloads
 
 import black
 import isort
@@ -18,20 +19,6 @@ from bec_widgets.utils.plugin_utils import BECClassContainer, get_custom_classes
 
 logger = bec_logger.logger
 
-if sys.version_info >= (3, 11):
-    from typing import get_overloads
-else:
-    print(
-        "Python version is less than 3.11, using dummy function for get_overloads. "
-        "If you want to use the real function 'typing.get_overloads()', please use Python 3.11 or later."
-    )
-
-    def get_overloads(_obj):
-        """
-        Dummy function for Python versions before 3.11.
-        """
-        return []
-
 
 class ClientGenerator:
     def __init__(self, base=False):
@@ -54,7 +41,7 @@ from __future__ import annotations
 from bec_lib.logger import bec_logger
 
 from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-{"from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module" if self._base else ""}
+{"from bec_widgets.utils.bec_plugin_helper import get_plugin_client_module" if self._base else ""}
 
 logger = bec_logger.logger
 
@@ -111,27 +98,19 @@ _Widgets = {
             self.content += """
 
 try:
-    _plugin_widgets = get_all_plugin_widgets().as_dict()
     plugin_client = get_plugin_client_module()
-    Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
-
-    if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
-        for _widget in _overlap:
-            logger.warning(f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !")
     for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
         if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
+            if plugin_name not in _Widgets:
+                _Widgets[plugin_name] = plugin_name
             if plugin_name in globals():
-                conflicting_file = (
-                    inspect.getfile(_plugin_widgets[plugin_name])
-                    if plugin_name in _plugin_widgets
-                    else f"{plugin_client}"
-                )
                 logger.warning(
-                    f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
+                    f"Plugin widget {plugin_name} in {plugin_class._IMPORT_MODULE} conflicts with a built-in class!"
                 )
                 continue
-            if plugin_name not in _overlap:
+            else:
                 globals()[plugin_name] = plugin_class
+        Widgets = _WidgetsEnumType("Widgets", _Widgets)
 except ImportError as e:
     logger.error(f"Failed loading plugins: \\n{reduce(add, traceback.format_exception(e))}")
 """
@@ -146,12 +125,8 @@ except ImportError as e:
 
         class_name = cls.__name__
 
-        if class_name == "BECDockArea":
-            self.content += f"""
-class {class_name}(RPCBase):"""
-        else:
-            self.content += f"""
-class {class_name}(RPCBase):"""
+        self.content += f"""
+class {class_name}(RPCBase):\n"""
 
         if cls.__doc__:
             # We only want the first line of the docstring
@@ -162,13 +137,9 @@ class {class_name}(RPCBase):"""
             else:
                 class_docs = cls.__doc__.split("\n")[1]
             self.content += f"""
-    \"\"\"{class_docs}\"\"\"
-    """
+    \"\"\"{class_docs}\"\"\"\n"""
         user_access_entries = self._get_user_access_entries(cls)
-        if not user_access_entries:
-            self.content += """...
-    """
-
+        self.content += f'    _IMPORT_MODULE="{cls.__module__}"\n'
         for method_entry in user_access_entries:
             method, obj, is_property_setter = self._resolve_method_object(cls, method_entry)
             if obj is None:

bec_widgets/cli/rpc/rpc_base.py

@@ -248,9 +248,7 @@ class RPCBase:
             self._rpc_response = None
             self._msg_wait_event.clear()
             self._client.connector.register(
-                MessageEndpoints.gui_instruction_response(request_id),
-                cb=self._on_rpc_response,
-                parent=self,
+                MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
             )
 
         self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
@@ -276,11 +274,10 @@ class RPCBase:
             self._rpc_response = None
             return self._create_widget_from_msg_result(msg_result)
 
-    @staticmethod
-    def _on_rpc_response(msg_obj: MessageObject, parent: RPCBase) -> None:
+    def _on_rpc_response(self, msg_obj: MessageObject) -> None:
         msg = cast(messages.RequestResponseMessage, msg_obj.value)
-        parent._rpc_response = msg
-        parent._msg_wait_event.set()
+        self._rpc_response = msg
+        self._msg_wait_event.set()
 
     def _create_widget_from_msg_result(self, msg_result):
         if msg_result is None:

bec_widgets/utils/bec_dispatcher.py

@@ -175,12 +175,15 @@ class BECDispatcher:
             cb_info (dict | None): A dictionary containing information about the callback. Defaults to None.
         """
         qt_slot = QtThreadSafeCallback(cb=slot, cb_info=cb_info)
-        if qt_slot not in self._registered_slots:
-            self._registered_slots[qt_slot] = qt_slot
-        qt_slot = self._registered_slots[qt_slot]
-        self.client.connector.register(topics, cb=qt_slot, **kwargs)
-        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        qt_slot.topics.update(set(topics_str))
+        if not self.client.connector.any_stream_is_registered(topics, qt_slot):
+            if qt_slot not in self._registered_slots:
+                self._registered_slots[qt_slot] = qt_slot
+            qt_slot = self._registered_slots[qt_slot]
+            self.client.connector.register(topics, cb=qt_slot, **kwargs)
+            topics_str, _ = self.client.connector._convert_endpointinfo(topics)
+            qt_slot.topics.update(set(topics_str))
+        else:
+            logger.warning(f"Attempted to create duplicate stream subscription for {topics=}")
 
     def disconnect_slot(
         self, slot: Callable, topics: EndpointInfo | str | list[EndpointInfo] | list[str]

bec_widgets/widgets/containers/main_window/main_window.py

@@ -30,7 +30,6 @@ from bec_widgets.widgets.containers.main_window.addons.notification_center.notif
 )
 from bec_widgets.widgets.containers.main_window.addons.scroll_label import ScrollLabel
 from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
-from bec_widgets.widgets.editors.bec_console.bec_console import BecConsoleRegistry
 from bec_widgets.widgets.progress.scan_progressbar.scan_progressbar import ScanProgressBar
 from bec_widgets.widgets.utility.widget_hierarchy_tree.widget_hierarchy_tree import (
     WidgetHierarchyDialog,
@@ -54,9 +53,6 @@ class BECMainWindow(BECWidget, QMainWindow):
         super().__init__(parent=parent, **kwargs)
 
         self.app = QApplication.instance()
-        self._console_registry = BecConsoleRegistry(self)
-        if not hasattr(self.app, "console_widget_registry"):
-            self.app.console_widget_registry = self._console_registry
         self.status_bar = self.statusBar()
         self._launcher_window = None
         self.setWindowTitle(window_title)

bec_widgets/widgets/editors/bec_console/bec_console.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import enum
+from dataclasses import dataclass, field
 from uuid import uuid4
 from weakref import WeakValueDictionary
 
 import shiboken6
 from bec_lib.logger import bec_logger
-from pydantic import BaseModel
-from qtpy.QtCore import QObject, Qt
+from qtpy.QtCore import Qt, Signal
 from qtpy.QtGui import QMouseEvent
 from qtpy.QtWidgets import (
     QApplication,
@@ -39,33 +39,133 @@ class ConsoleMode(str, enum.Enum):
     HIDDEN = "hidden"
 
 
-class _TerminalOwnerInfo(BaseModel):
+@dataclass
+class _TerminalOwnerInfo:
     """Should be managed only by the BecConsoleRegistry. Consoles should ask the registry for
     necessary ownership info."""
 
     owner_console_id: str | None = None
-    registered_console_ids: set[str] = set()
-    instance: BecTerminal | QWidget
-    terminal_id: str
+    registered_console_ids: set[str] = field(default_factory=set)
+    instance: BecTerminal | None = None
+    terminal_id: str = ""
     initialized: bool = False
-    keep_if_last_console_closed: bool = False
-
-    model_config = {"arbitrary_types_allowed": True}
+    persist_session: bool = False
+    fallback_holder: QWidget | None = None
 
 
-class BecConsoleRegistry(QWidget):
+class BecConsoleRegistry:
     """
     A registry for the BecConsole class to manage its instances.
     """
 
-    def __init__(self, parent):
+    def __init__(self):
         """
         Initialize the registry.
         """
-        super().__init__(parent=parent)
         self._consoles: WeakValueDictionary[str, BecConsole] = WeakValueDictionary()
         self._terminal_registry: dict[str, _TerminalOwnerInfo] = {}
 
+    @staticmethod
+    def _is_valid_qobject(obj: object | None) -> bool:
+        return obj is not None and shiboken6.isValid(obj)
+
+    def _connect_app_cleanup(self) -> None:
+        app = QApplication.instance()
+        if app is None:
+            return
+        app.aboutToQuit.connect(self.clear, Qt.ConnectionType.UniqueConnection)
+
+    @staticmethod
+    def _new_terminal_info(console: BecConsole) -> _TerminalOwnerInfo:
+        term = _BecTermClass()
+        return _TerminalOwnerInfo(
+            registered_console_ids={console.console_id},
+            owner_console_id=console.console_id,
+            instance=term,
+            terminal_id=console.terminal_id,
+            persist_session=console.persist_terminal_session,
+        )
+
+    @staticmethod
+    def _replace_terminal(info: _TerminalOwnerInfo, console: BecConsole) -> None:
+        info.instance = _BecTermClass()
+        info.initialized = False
+        info.owner_console_id = console.console_id
+        info.registered_console_ids.add(console.console_id)
+        info.persist_session = info.persist_session or console.persist_terminal_session
+
+    def _delete_terminal_info(self, info: _TerminalOwnerInfo) -> None:
+        if self._is_valid_qobject(info.instance):
+            info.instance.deleteLater()  # type: ignore[union-attr]
+        info.instance = None
+        if self._is_valid_qobject(info.fallback_holder):
+            info.fallback_holder.deleteLater()
+        info.fallback_holder = None
+
+    def _parking_parent(
+        self,
+        info: _TerminalOwnerInfo,
+        console: BecConsole | None = None,
+        *,
+        avoid_console: bool = False,
+    ) -> QWidget | None:
+        for console_id in info.registered_console_ids:
+            candidate = self._consoles.get(console_id)
+            if candidate is None or candidate is console:
+                continue
+            if self._is_valid_qobject(candidate):
+                return candidate._term_holder
+
+        if console is None or not self._is_valid_qobject(console):
+            return None
+
+        window = console.window()
+        if window is not None and window is not console and self._is_valid_qobject(window):
+            return window
+
+        if not avoid_console:
+            return console._term_holder
+        return None
+
+    def _fallback_holder(
+        self,
+        info: _TerminalOwnerInfo,
+        console: BecConsole | None = None,
+        *,
+        avoid_console: bool = False,
+    ) -> QWidget:
+        if not self._is_valid_qobject(info.fallback_holder):
+            info.fallback_holder = QWidget(
+                parent=self._parking_parent(info, console, avoid_console=avoid_console)
+            )
+            info.fallback_holder.setObjectName(f"_bec_console_terminal_holder_{info.terminal_id}")
+            info.fallback_holder.hide()
+        return info.fallback_holder
+
+    def _park_terminal(
+        self,
+        info: _TerminalOwnerInfo,
+        console: BecConsole | None = None,
+        *,
+        avoid_console: bool = False,
+    ) -> None:
+        if not self._is_valid_qobject(info.instance):
+            return
+
+        parent = self._parking_parent(info, console, avoid_console=avoid_console)
+        if parent is None and info.persist_session:
+            parent = self._fallback_holder(info, console, avoid_console=avoid_console)
+
+        info.instance.hide()  # type: ignore[union-attr]
+        info.instance.setParent(parent)  # type: ignore[union-attr]
+
+    def clear(self) -> None:
+        """Delete every tracked terminal and holder."""
+        for info in list(self._terminal_registry.values()):
+            self._delete_terminal_info(info)
+        self._terminal_registry.clear()
+        self._consoles.clear()
+
     def register(self, console: BecConsole):
         """
         Register an instance of BecConsole. If there is already a terminal with the associated
@@ -74,49 +174,56 @@ class BecConsoleRegistry(QWidget):
         Args:
             console (BecConsole): The instance to register.
         """
+        self._connect_app_cleanup()
         self._consoles[console.console_id] = console
         console_id, terminal_id = console.console_id, console.terminal_id
-        if (term_info := self._terminal_registry.get(terminal_id)) is None or not shiboken6.isValid(
-            term_info.instance
-        ):
-            term = _BecTermClass()
-            self._terminal_registry[terminal_id] = _TerminalOwnerInfo(
-                registered_console_ids={console_id},
-                owner_console_id=console_id,
-                instance=term,
-                terminal_id=terminal_id,
-                keep_if_last_console_closed=console.persevere_terminal,
-            )
-            if console.persevere_terminal:
-                term.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, False)
+        term_info = self._terminal_registry.get(terminal_id)
+        if term_info is None:
+            self._terminal_registry[terminal_id] = self._new_terminal_info(console)
             return
 
-        logger.info(f"Registered new console {console_id} for terminal {terminal_id}")
+        term_info.persist_session = term_info.persist_session or console.persist_terminal_session
+        had_registered_consoles = bool(term_info.registered_console_ids)
         term_info.registered_console_ids.add(console_id)
+        if not self._is_valid_qobject(term_info.instance):
+            self._replace_terminal(term_info, console)
+            return
+        if (
+            term_info.owner_console_id is not None
+            and term_info.owner_console_id not in self._consoles
+        ):
+            term_info.owner_console_id = None
+        if term_info.owner_console_id is None and not had_registered_consoles:
+            term_info.owner_console_id = console_id
+        logger.info(f"Registered new console {console_id} for terminal {terminal_id}")
 
     def unregister(self, console: BecConsole):
         """
         Unregister an instance of BecConsole.
 
         Args:
-            instance (BecConsole): The instance to unregister.
+            console (BecConsole): The instance to unregister.
         """
         console_id, terminal_id = console.console_id, console.terminal_id
         if console_id in self._consoles:
             del self._consoles[console_id]
         if (term_info := self._terminal_registry.get(terminal_id)) is None:
             return
+        detached = console._detach_terminal_widget(term_info.instance)
         if console_id in term_info.registered_console_ids:
             term_info.registered_console_ids.remove(console_id)
         if term_info.owner_console_id == console_id:
             term_info.owner_console_id = None
         if not term_info.registered_console_ids:
-            if not term_info.keep_if_last_console_closed:
-                term_info.instance.deleteLater()
-                del self._terminal_registry[terminal_id]
-            else:
-                term_info.instance.setHidden()
-                term_info.instance.setParent(self)
+            if term_info.persist_session and self._is_valid_qobject(term_info.instance):
+                self._park_terminal(term_info, console, avoid_console=True)
+                logger.info(f"Unregistered console {console_id} for terminal {terminal_id}")
+                return
+
+            self._delete_terminal_info(term_info)
+            del self._terminal_registry[terminal_id]
+        elif detached:
+            self._park_terminal(term_info, console, avoid_console=True)
 
         logger.info(f"Unregistered console {console_id} for terminal {terminal_id}")
 
@@ -127,6 +234,8 @@ class BecConsoleRegistry(QWidget):
         if (info := self._terminal_registry.get(console.terminal_id)) is None:
             logger.warning(f"Console {console.console_id} references an unknown terminal!")
             return False
+        if not self._is_valid_qobject(info.instance):
+            return False
         return info.owner_console_id == console.console_id
 
     def take_ownership(self, console: BecConsole) -> BecTerminal | None:
@@ -141,14 +250,19 @@ class BecConsoleRegistry(QWidget):
         console_id, terminal_id = console.console_id, console.terminal_id
 
         if terminal_id not in self._terminal_registry:
-            logger.warning(f"Terminal {terminal_id} not found in registry")
-            return None
+            self.register(console)
 
         instance_info = self._terminal_registry[terminal_id]
-        if (old_owner_console_id := instance_info.owner_console_id) is not None:
-            if (old_owner := self._consoles.get(old_owner_console_id)) is not None:
+        if not self._is_valid_qobject(instance_info.instance):
+            self._replace_terminal(instance_info, console)
+        if (old_owner_console_ide := instance_info.owner_console_id) is not None:
+            if (
+                old_owner_console_ide != console_id
+                and (old_owner := self._consoles.get(old_owner_console_ide)) is not None
+            ):
                 old_owner.yield_ownership()  # call this on the old owner to make sure it is updated
         instance_info.owner_console_id = console_id
+        instance_info.registered_console_ids.add(console_id)
         logger.info(f"Transferred ownership of terminal {terminal_id} to {console_id}")
         return instance_info.instance
 
@@ -168,17 +282,21 @@ class BecConsoleRegistry(QWidget):
             return None
 
         instance_info = self._terminal_registry[terminal_id]
+        if not self._is_valid_qobject(instance_info.instance):
+            if instance_info.owner_console_id == console_id:
+                self._replace_terminal(instance_info, console)
+            else:
+                return None
         if instance_info.owner_console_id == console_id:
             return instance_info.instance
 
     def yield_ownership(self, console: BecConsole):
         """
-        Yield ownership of a instance without destroying it. The instance remains in the
+        Yield ownership of an instance without destroying it. The instance remains in the
         registry with no owner, available for another widget to claim.
 
         Args:
-            gui_id (str): The GUI ID of the widget yielding ownership.
-
+            console (BecConsole): The console which wishes to yield ownership of its associated terminal.
         """
         console_id, terminal_id = console.console_id, console.terminal_id
         logger.debug(f"Console {console_id} attempted to yield ownership")
@@ -190,20 +308,40 @@ class BecConsoleRegistry(QWidget):
             logger.debug(f"But it was not the owner, which was {term_info.owner_console_id}!")
             return
         term_info.owner_console_id = None
+        console._detach_terminal_widget(term_info.instance)
+        self._park_terminal(term_info, console)
 
-        term_info.instance.setParent(QApplication.instance().console_widget_registry)
+    def should_initialize(self, console: BecConsole) -> bool:
+        """Return true if the console should send its startup command to the terminal."""
+        info = self._terminal_registry.get(console.terminal_id)
+        if info is None:
+            return False
+        return (
+            info.owner_console_id == console.console_id
+            and not info.initialized
+            and self._is_valid_qobject(info.instance)
+        )
+
+    def mark_initialized(self, console: BecConsole) -> None:
+        info = self._terminal_registry.get(console.terminal_id)
+        if info is not None and info.owner_console_id == console.console_id:
+            info.initialized = True
 
     def owner_is_visible(self, term_id: str) -> bool:
         """
-        Check if the owner of a instance is currently visible.
+        Check if the owner of an instance is currently visible.
 
         Args:
-            unique_id (str): The unique identifier for the instance.
+            term_id (str): The terminal ID to check.
         Returns:
             bool: True if the owner is visible, False otherwise.
         """
         instance_info = self._terminal_registry.get(term_id)
-        if instance_info is None or instance_info.owner_console_id is None:
+        if (
+            instance_info is None
+            or instance_info.owner_console_id is None
+            or not self._is_valid_qobject(instance_info.instance)
+        ):
             return False
 
         if (owner := self._consoles.get(instance_info.owner_console_id)) is None:
@@ -211,6 +349,9 @@ class BecConsoleRegistry(QWidget):
         return owner.isVisible()
 
 
+_bec_console_registry = BecConsoleRegistry()
+
+
 class _Overlay(QWidget):
     def __init__(self, console: BecConsole):
         super().__init__(parent=console)
@@ -227,8 +368,12 @@ class _Overlay(QWidget):
 class BecConsole(BECWidget, QWidget):
     """A console widget with access to a shared registry of terminals, such that instances can be moved around."""
 
+    _js_callback = Signal(bool)
+    initialized = Signal()
+
     PLUGIN = True
     ICON_NAME = "terminal"
+    persist_terminal_session = False
 
     def __init__(
         self,
@@ -238,7 +383,6 @@ class BecConsole(BECWidget, QWidget):
         gui_id=None,
         startup_cmd: str | None = None,
         terminal_id: str | None = None,
-        persevere_terminal: bool = False,
         **kwargs,
     ):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
@@ -248,7 +392,6 @@ class BecConsole(BECWidget, QWidget):
         self.terminal_id = terminal_id or str(uuid4())
         self.console_id = self.gui_id
         self.term: BecTerminal | None = None  # Will be set in _set_up_instance
-        self.persevere_terminal = persevere_terminal
 
         self._set_up_instance()
 
@@ -276,13 +419,12 @@ class BecConsole(BECWidget, QWidget):
         self._stacked_layout.addWidget(self._overlay)
 
         # will create a new terminal instance if there isn't already one for this ID
-        QApplication.instance().console_widget_registry.register(self)
+        _bec_console_registry.register(self)
         self._infer_mode()
-        if self.startup_cmd:
-            self.write(self.startup_cmd, True)  # will have no effect if not the owner
+        self._ensure_startup_started()
 
     def _infer_mode(self):
-        self.term = QApplication.instance().console_widget_registry.try_get_term(self)
+        self.term = _bec_console_registry.try_get_term(self)
         if self.term:
             self._set_mode(ConsoleMode.ACTIVE)
         elif self.isHidden():
@@ -301,8 +443,9 @@ class BecConsole(BECWidget, QWidget):
         match mode:
             case ConsoleMode.ACTIVE:
                 if self.term:
-                    if self.term not in (self._term_layout.children()):
+                    if self._term_layout.indexOf(self.term) == -1:  # type: ignore[arg-type]
                         self._term_layout.addWidget(self.term)  # type: ignore # BecTerminal is QWidget
+                    self.term.show()  # type: ignore[attr-defined]
                     self._stacked_layout.setCurrentIndex(0)
                     self._mode = mode
                 else:
@@ -326,7 +469,6 @@ class BecConsole(BECWidget, QWidget):
     def startup_cmd(self, cmd: str | None):
         """
         Set the startup command for the console.
-        logger.info(f"{self._console_id} inferred mode active through ownerp)
         """
         self._startup_cmd = cmd
 
@@ -341,14 +483,38 @@ class BecConsole(BECWidget, QWidget):
         if self.term:
             self.term.write(data, send_return)
 
+    def _ensure_startup_started(self):
+        if not self.startup_cmd or not _bec_console_registry.should_initialize(self):
+            return
+        self.write(self.startup_cmd, True)
+        _bec_console_registry.mark_initialized(self)
+
+    def _detach_terminal_widget(self, term: BecTerminal | None) -> bool:
+        if term is None or not BecConsoleRegistry._is_valid_qobject(term):
+            if self.term is term:
+                self.term = None
+            return False
+
+        is_child = self.isAncestorOf(term)  # type: ignore[arg-type]
+        if self._term_layout.indexOf(term) != -1:  # type: ignore[arg-type]
+            self._term_layout.removeWidget(term)  # type: ignore[arg-type]
+            is_child = True
+        if is_child:
+            term.hide()  # type: ignore[attr-defined]
+            term.setParent(None)  # type: ignore[attr-defined]
+        if self.term is term:
+            self.term = None
+        return is_child
+
     def take_terminal_ownership(self):
         """
         Take ownership of a web instance from the registry. This will transfer the instance
         from its current owner (if any) to this widget.
         """
         # Get the instance from registry
-        self.term = QApplication.instance().console_widget_registry.take_ownership(self)
+        self.term = _bec_console_registry.take_ownership(self)
         self._infer_mode()
+        self._ensure_startup_started()
         if self._mode == ConsoleMode.ACTIVE:
             logger.debug(f"Widget {self.gui_id} took ownership of instance {self.terminal_id}")
 
@@ -358,7 +524,7 @@ class BecConsole(BECWidget, QWidget):
         available for another widget to claim. This is automatically called when the
         widget becomes hidden.
         """
-        QApplication.instance().console_widget_registry.yield_ownership(self)
+        _bec_console_registry.yield_ownership(self)
         self._infer_mode()
         if self._mode != ConsoleMode.ACTIVE:
             logger.debug(f"Widget {self.gui_id} yielded ownership of instance {self.terminal_id}")
@@ -371,13 +537,13 @@ class BecConsole(BECWidget, QWidget):
     def showEvent(self, event):
         """Called when the widget is shown. Updates UI state based on ownership."""
         super().showEvent(event)
-        if not QApplication.instance().console_widget_registry.is_owner(self):
-            if not QApplication.instance().console_widget_registry.owner_is_visible(self.terminal_id):
+        if not _bec_console_registry.is_owner(self):
+            if not _bec_console_registry.owner_is_visible(self.terminal_id):
                 self.take_terminal_ownership()
 
     def cleanup(self):
         """Unregister this console on destruction."""
-        QApplication.instance().console_widget_registry.unregister(self)
+        _bec_console_registry.unregister(self)
         super().cleanup()
 
 
@@ -389,6 +555,7 @@ class BECShell(BecConsole):
     """
 
     ICON_NAME = "hub"
+    persist_terminal_session = True
 
     def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
         super().__init__(
@@ -397,7 +564,6 @@ class BECShell(BecConsole):
             client=client,
             gui_id=gui_id,
             terminal_id="bec_shell",
-            persevere_terminal=True,
             **kwargs,
         )
 

bec_widgets/widgets/utility/bec_term/qtermwidget_wrapper.py

@@ -52,19 +52,19 @@ class BecQTerm(QWidget):
         self.setLayout(self._layout)
         if QTermWidget:
             self._main_widget = QTermWidget(parent=self)
-            self.activity.connect(self._main_widget.activity)
-            self.bell.connect(self._main_widget.bell)
-            self.copy_available.connect(self._main_widget.copyAvailable)
-            self.current_directory_changed.connect(self._main_widget.currentDirectoryChanged)
-            self.finished.connect(self._main_widget.finished)
-            self.profile_changed.connect(self._main_widget.profileChanged)
-            self.received_data.connect(self._main_widget.receivedData)
-            self.silence.connect(self._main_widget.silence)
-            self.term_got_focus.connect(self._main_widget.termGetFocus)
-            self.term_key_pressed.connect(self._main_widget.termKeyPressed)
-            self.term_lost_focus.connect(self._main_widget.termLostFocus)
-            self.title_changed.connect(self._main_widget.titleChanged)
-            self.url_activated.connect(self._main_widget.urlActivated)
+            self._main_widget.activity.connect(self.activity)
+            self._main_widget.bell.connect(self.bell)
+            self._main_widget.copyAvailable.connect(self.copy_available)
+            self._main_widget.currentDirectoryChanged.connect(self.current_directory_changed)
+            self._main_widget.finished.connect(self.finished)
+            self._main_widget.profileChanged.connect(self.profile_changed)
+            self._main_widget.receivedData.connect(self.received_data)
+            self._main_widget.silence.connect(self.silence)
+            self._main_widget.termGetFocus.connect(self.term_got_focus)
+            self._main_widget.termKeyPressed.connect(self.term_key_pressed)
+            self._main_widget.termLostFocus.connect(self.term_lost_focus)
+            self._main_widget.titleChanged.connect(self.title_changed)
+            self._main_widget.urlActivated.connect(self.url_activated)
             self._setEnvironment([f"{k}={v}" for k, v in os.environ.items()])
             self._setColorScheme("Solarized")
         else:
@@ -78,12 +78,6 @@ class BecQTerm(QWidget):
             text += "\n"
         self._sendText(text)
 
-    def deleteLater(self, /) -> None:
-        return super().deleteLater()
-
-    def close(self, /) -> bool:
-        return super().close()
-
     # automatically forwarded to the widget only if it exists
     @_forward
     def _addCustomColorSchemeDir(self, custom_dir: str, /) -> None: ...

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bec_widgets"
-version = "3.4.2"
+version = "3.5.1"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [

tests/end-2-end/conftest.py

@@ -33,7 +33,7 @@ def threads_check_fixture(threads_check):
 @pytest.fixture
 def gui_id():
     """New gui id each time, to ensure no 'gui is alive' zombie key can perturb"""
-    return f"figure_{random.randint(0,100)}"  # make a new gui id each time, to ensure no 'gui is alive' zombie key can perturb
+    return f"figure_{random.randint(0, 100)}"  # make a new gui id each time, to ensure no 'gui is alive' zombie key can perturb
 
 
 @pytest.fixture(scope="function")
@@ -51,6 +51,7 @@ def connected_client_gui_obj(qtbot, gui_id, bec_client_lib):
         qtbot.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)
         yield gui
     finally:
-        gui.bec.delete_all()  # ensure clean state
-        qtbot.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)
+        if (bec := getattr(gui, "bec", None)) is not None:
+            bec.delete_all()  # ensure clean state
+            qtbot.waitUntil(lambda: len(bec.widget_list()) == 0, timeout=10000)
         gui.kill_server()

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -1,6 +1,7 @@
 import pytest
 
 from bec_widgets.cli.client import Image, MotorMap, Waveform
+from bec_widgets.cli.client_utils import BECGuiClient
 from bec_widgets.cli.rpc.rpc_base import RPCReference
 
 # pylint: disable=unused-argument
@@ -122,7 +123,7 @@ def test_ring_bar(qtbot, connected_client_gui_obj):
     assert gui._ipython_registry[bar._gui_id].__class__.__name__ == "RingProgressBar"
 
 
-def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
+def test_rpc_gui_obj(connected_client_gui_obj: BECGuiClient, qtbot):
     gui = connected_client_gui_obj
 
     qtbot.waitUntil(lambda: len(gui.windows) == 1, timeout=3000)

tests/unit_tests/conftest.py

@@ -1,3 +1,8 @@
+# Force ophyd onto its dummy control layer in tests so importing it does not
+# try to create a real EPICS CA context.
+import os
+
+os.environ.setdefault("OPHYD_CONTROL_LAYER", "dummy")
 import json
 import time
 from unittest import mock
@@ -13,7 +18,7 @@ from bec_lib.client import BECClient
 from bec_lib.messages import _StoredDataInfo
 from bec_qthemes import apply_theme
 from bec_qthemes._theme import Theme
-from ophyd._pyepics_shim import _dispatcher
+from ophyd._dummy_shim import _dispatcher
 from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
 from qtpy.QtCore import QEvent, QEventLoop
 from qtpy.QtWidgets import QApplication, QMessageBox

tests/unit_tests/test_bec_console.py

@@ -1,10 +1,13 @@
 from unittest import mock
 
 import pytest
-from qtpy.QtCore import Qt
+import shiboken6
+from qtpy.QtCore import QEvent, QEventLoop, Qt
 from qtpy.QtGui import QHideEvent, QShowEvent
 from qtpy.QtTest import QTest
+from qtpy.QtWidgets import QApplication, QWidget
 
+import bec_widgets.widgets.editors.bec_console.bec_console as bec_console_module
 from bec_widgets.widgets.editors.bec_console.bec_console import (
     BecConsole,
     BECShell,
@@ -15,6 +18,20 @@ from bec_widgets.widgets.editors.bec_console.bec_console import (
 from .client_mocks import mocked_client
 
 
+def process_deferred_deletes():
+    app = QApplication.instance()
+    app.sendPostedEvents(None, QEvent.DeferredDelete)
+    app.processEvents(QEventLoop.AllEvents)
+
+
+@pytest.fixture(autouse=True)
+def clean_bec_console_registry():
+    _bec_console_registry.clear()
+    yield
+    _bec_console_registry.clear()
+    process_deferred_deletes()
+
+
 @pytest.fixture
 def console_widget(qtbot):
     """Create a BecConsole widget."""
@@ -128,12 +145,108 @@ def test_is_owner(console_widget: BecConsole):
     assert not _bec_console_registry.is_owner(mock_console)
 
 
-def test_bec_shell_leaves_terminal_instantiated(qtbot):
-    widget = BECShell()
+def test_closing_active_console_keeps_terminal_valid_for_remaining_console(qtbot):
+    widget1 = BecConsole(client=mocked_client, gui_id="close_owner", terminal_id="shared_close")
+    widget2 = BecConsole(client=mocked_client, gui_id="remaining", terminal_id="shared_close")
+    qtbot.addWidget(widget2)
+
+    widget1.take_terminal_ownership()
+    term = widget1.term
+    assert term is not None
+
+    widget1.close()
+    widget1.deleteLater()
+    process_deferred_deletes()
+
+    assert shiboken6.isValid(term)
+    widget2.take_terminal_ownership()
+
+    assert widget2.term is term
+    assert widget2._mode == ConsoleMode.ACTIVE
+
+
+def test_active_console_detaches_terminal_before_destruction(qtbot):
+    widget1 = BecConsole(client=mocked_client, gui_id="owner", terminal_id="shared_detach")
+    widget2 = BecConsole(client=mocked_client, gui_id="survivor", terminal_id="shared_detach")
+    qtbot.addWidget(widget1)
+    qtbot.addWidget(widget2)
+
+    widget1.take_terminal_ownership()
+    term = widget1.term
+    assert term is not None
+    assert widget1.isAncestorOf(term)
+
+    widget1.close()
+
+    assert shiboken6.isValid(term)
+    assert not widget1.isAncestorOf(term)
+    assert term.parent() is widget2._term_holder
+
+
+def test_bec_shell_terminal_persists_after_last_shell_unregisters(qtbot):
+    shell = BECShell(gui_id="bec_shell_persistent")
+    qtbot.addWidget(shell)
+    term = shell.term
+    assert term is not None
+
+    _bec_console_registry.unregister(shell)
+
+    info = _bec_console_registry._terminal_registry["bec_shell"]
+    assert info.registered_console_ids == set()
+    assert info.owner_console_id is None
+    assert info.persist_session is True
+    assert info.instance is term
+    assert shiboken6.isValid(term)
+
+
+def test_new_bec_shell_claims_preserved_terminal(qtbot):
+    shell1 = BECShell(gui_id="bec_shell_first")
+    term = shell1.term
+    assert term is not None
+
+    shell1.close()
+    shell1.deleteLater()
+    process_deferred_deletes()
+
+    assert "bec_shell" in _bec_console_registry._terminal_registry
+    assert shiboken6.isValid(term)
+
+    shell2 = BECShell(gui_id="bec_shell_second")
+    qtbot.addWidget(shell2)
+    shell2.showEvent(QShowEvent())
+
+    assert shell2.term is term
+    assert shell2._mode == ConsoleMode.ACTIVE
+
+
+def test_persistent_bec_shell_sends_startup_command_once(qtbot, monkeypatch):
+    class RecordingTerminal(QWidget):
+        writes = []
+
+        def write(self, text: str, add_newline: bool = True):
+            self.writes.append((text, add_newline))
+
+    monkeypatch.setattr(bec_console_module, "_BecTermClass", RecordingTerminal)
+
+    shell1 = BECShell(gui_id="bec_shell_startup_first")
+    shell1.close()
+    shell1.deleteLater()
+    process_deferred_deletes()
+
+    shell2 = BECShell(gui_id="bec_shell_startup_second")
+    qtbot.addWidget(shell2)
+    shell2.showEvent(QShowEvent())
+
+    assert len(RecordingTerminal.writes) == 1
+    assert RecordingTerminal.writes[0][0].startswith("bec ")
+    assert RecordingTerminal.writes[0][1] is True
+
+
+def test_plain_console_terminal_removed_after_last_unregister(qtbot):
+    widget = BecConsole(client=mocked_client, gui_id="plain_console", terminal_id="plain_terminal")
     qtbot.addWidget(widget)
 
-    assert len(_bec_console_registry._terminal_registry) != 0
+    assert "plain_terminal" in _bec_console_registry._terminal_registry
     _bec_console_registry.unregister(widget)
-    assert len(_bec_console_registry._terminal_registry) != 0
 
-    assert _bec_console_registry._terminal_registry["bec_shell"].owner_console_id is None
+    assert "plain_terminal" not in _bec_console_registry._terminal_registry

tests/unit_tests/test_client_plugin_widgets.py

@@ -9,7 +9,8 @@ from bec_widgets.cli.rpc.rpc_base import RPCBase
 from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
 
 
-class _TestGlobalPlugin(RPCBase): ...
+class _TestGlobalPlugin(RPCBase):
+    _IMPORT_MODULE = "test.global.plugin.widgets"
 
 
 mock_client_module_globals = SimpleNamespace()
@@ -25,12 +26,13 @@ mock_client_module_globals.Widgets = _TestGlobalPlugin
 def test_plugins_dont_clobber_client_globals(bec_logger: MagicMock):
     reload(client)
     bec_logger.logger.warning.assert_called_with(
-        "Plugin widget Widgets from namespace(Widgets=<class 'tests.unit_tests.test_client_plugin_widgets._TestGlobalPlugin'>) conflicts with a built-in class!"
+        "Plugin widget Widgets in test.global.plugin.widgets conflicts with a built-in class!"
     )
     assert isinstance(client.Widgets, enum.EnumType)
 
 
-class _TestDuplicatePlugin(RPCBase): ...
+class _TestDuplicatePlugin(RPCBase):
+    _IMPORT_MODULE = "test.duplicate.plugin.module"
 
 
 mock_client_module_duplicate = SimpleNamespace()
@@ -54,7 +56,7 @@ def test_duplicate_plugins_not_allowed(_, bec_logger: MagicMock):
     reload(client)
     assert (
         call(
-            f"Detected duplicate widget Waveform in plugin repo file: {inspect.getfile(_TestDuplicatePlugin)} !"
+            "Plugin widget Waveform in test.duplicate.plugin.module conflicts with a built-in class!"
         )
         in bec_logger.logger.warning.mock_calls
     )

tests/unit_tests/test_generate_cli_client.py

@@ -104,8 +104,7 @@ def test_client_generator_with_black_formatting():
         from bec_lib.logger import bec_logger
 
         from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-        from bec_widgets.utils.bec_plugin_helper import (get_all_plugin_widgets,
-                                                        get_plugin_client_module)
+        from bec_widgets.utils.bec_plugin_helper import get_plugin_client_module
 
         logger = bec_logger.logger
 
@@ -123,31 +122,25 @@ def test_client_generator_with_black_formatting():
 
         
         try:
-            _plugin_widgets = get_all_plugin_widgets().as_dict()
             plugin_client = get_plugin_client_module()
-            Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
-
-            if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
-                for _widget in _overlap:
-                    logger.warning(f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !")
             for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
                 if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
+                    if plugin_name not in _Widgets:
+                        _Widgets[plugin_name] = plugin_name
                     if plugin_name in globals():
-                        conflicting_file = (
-                            inspect.getfile(_plugin_widgets[plugin_name])
-                            if plugin_name in _plugin_widgets
-                            else f"{plugin_client}"
-                        )
                         logger.warning(
-                            f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
+                            f"Plugin widget {plugin_name} in {plugin_class._IMPORT_MODULE} conflicts with a built-in class!"
                         )
                         continue
-                    if plugin_name not in _overlap:
+                    else:
                         globals()[plugin_name] = plugin_class
+                Widgets = _WidgetsEnumType("Widgets", _Widgets)
         except ImportError as e:
             logger.error(f"Failed loading plugins: \\n{reduce(add, traceback.format_exception(e))}")
 
         class MockBECFigure(RPCBase):
+            _IMPORT_MODULE = "tests.unit_tests.test_generate_cli_client"
+            
             @rpc_call
             def add_plot(self, plot_id: str):
                 """
@@ -162,6 +155,8 @@ def test_client_generator_with_black_formatting():
 
 
         class MockBECWaveform1D(RPCBase):
+            _IMPORT_MODULE = "tests.unit_tests.test_generate_cli_client"
+            
             @rpc_call
             def set_frequency(self, frequency: float) -> list:
                 """