bec-widgets 0.103.0__py3-none-any.whl → 0.105.0__py3-none-any.whl

CHANGELOG.md

@@ -1,5 +1,47 @@
 # CHANGELOG
 
+## v0.105.0 (2024-09-04)
+
+### Feature
+
+* feat: add dap_combobox ([`cc691d4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/cc691d4039bde710e78f362d2f0e712f9e8f196f))
+
+### Refactor
+
+* refactor: cleanup and renaming of slot/signals ([`0fd5cee`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0fd5cee77611b6645326eaefa68455ea8de26597))
+
+* refactor(logger): changed prints to logger calls ([`3a5d7d0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3a5d7d07966ab9b38ba33bda0bed38c30f500c66))
+
+## v0.104.0 (2024-09-04)
+
+### Documentation
+
+* docs(scan_control): docs extended ([`730e25f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/730e25fd3a8be156603005982bfd2a2c2b16dff1))
+
+### Feature
+
+* feat(scan_control): scan control remember the previously set parameters and shares kwarg settings across scans ([`d28f9b0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d28f9b04c45385179353cc247221ec821dcaa29b))
+
+### Fix
+
+* fix(scan_control): SafeSlot applied to run_scan to avoid faulty scan requests ([`9047916`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/90479167fb5cae393c884e71a80fcfdb48a76427))
+
+* fix(scan_control): scan parameters can be loaded from the last executed scan from redis ([`ec3bc8b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ec3bc8b5194c680b847d3306c41eef4638ccfcc7))
+
+* fix(toggle): state can be determined with the widget initialisation ([`2cd9c7f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2cd9c7f5854f158468e53b5b29ec31b1ff1e00e6))
+
+### Refactor
+
+* refactor(scan_control): scan control layout adjusted ([`85dcbda`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/85dcbdaa88fe77aeea7012bfc16f10c4f873f75e))
+
+* refactor(scan_control): basic pydantic config added ([`fe8dc55`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fe8dc55eb102c51c34bf9606690914da53b5ac02))
+
+### Test
+
+* test(scan_control): tests extended for getting kwargs between scan switching and getting parameters from redis ([`b07e677`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b07e67715c9284e9bf36056ba4ba8068f60cbaf3))
+
+* test(conftest): only run cleanup checks if test passed ([`26920f8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/26920f8482bdb35ece46df37232af50ab9cab463))
+
 ## v0.103.0 (2024-09-04)
 
 ### Ci
@@ -113,45 +155,3 @@
 ### Refactor
 
 * refactor(icons): general app icon changed; jupyter app icon changed to material icon ([`5d73fe4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d73fe455a568ad40a9fadc5ce6e249d782ad20d))
-
-* refactor: add option to select scan and hide arg bundle buttons ([`7dadab1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7dadab1f14aa41876ad39e8cdc7f7732248cc643))
-
-## v0.99.10 (2024-08-29)
-
-### Fix
-
-* fix(stop_button): queue logic scan changed to halt instead of abort and reset ([`4a89028`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4a890281f7eaef02d0ec9f4c5bf080be11fe0fe3))
-
-### Refactor
-
-* refactor(stop_button): stop button changed to QWidget and adapted for toolbar ([`097946f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/097946fd688b8faf770e7cc0e689ea668206bc7a))
-
-* refactor: added hide option for device selection button ([`cdd1752`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/cdd175207e922904b2efbb2d9ecf7c556c617f2e))
-
-## v0.99.9 (2024-08-28)
-
-### Fix
-
-* fix: fixed build process and excluded docs and tests from tarballs and wheels ([`719254c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/719254cf0a48e1fc4bd541edba239570778bcfea))
-
-## v0.99.8 (2024-08-28)
-
-### Fix
-
-* fix(website): fixed designer integration for website widget ([`5f37e86`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5f37e862c95ac7173b6918ad39bcaef938dad698))
-
-### Refactor
-
-* refactor(website): changed inheritance of website widget to simple qwidget; closes #325 ([`9925bbd`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9925bbdb48b55eacbbce9fd6a1555a21b84221f9))
-
-## v0.99.7 (2024-08-28)
-
-### Fix
-
-* fix(toolbar): material icons can accept color as kwarg ([`ffc871e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ffc871ebbd3b68abc3e151bb8f5849e6c50e775e))
-
-## v0.99.6 (2024-08-28)
-
-### Fix
-
-* fix(toolbar): use of native qt separators ([`09c6c93`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/09c6c93c397ce4a21c293f6c79106c74b2db65ca))

PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bec_widgets
-Version: 0.103.0
+Version: 0.105.0
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets

bec_widgets/cli/client.py

@@ -22,6 +22,7 @@ class Widgets(str, enum.Enum):
     BECQueue = "BECQueue"
     BECStatusBox = "BECStatusBox"
     BECWaveformWidget = "BECWaveformWidget"
+    DapComboBox = "DapComboBox"
     DarkModeButton = "DarkModeButton"
     DeviceBrowser = "DeviceBrowser"
     DeviceComboBox = "DeviceComboBox"
@@ -2312,6 +2313,35 @@ class BECWaveformWidget(RPCBase):
         """
 
 
+class DapComboBox(RPCBase):
+    @rpc_call
+    def select_y_axis(self, y_axis: str):
+        """
+        Receive update signal for the y axis.
+
+        Args:
+            y_axis(str): Y axis.
+        """
+
+    @rpc_call
+    def select_x_axis(self, x_axis: str):
+        """
+        Receive update signal for the x axis.
+
+        Args:
+            x_axis(str): X axis.
+        """
+
+    @rpc_call
+    def select_fit(self, fit_name: str | None):
+        """
+        Select current fit.
+
+         Args:
+             default_device(str): Default device name.
+        """
+
+
 class DarkModeButton(RPCBase):
     @rpc_call
     def toggle_dark_mode(self) -> "None":

bec_widgets/cli/client_utils.py

@@ -80,7 +80,7 @@ def _get_output(process, logger) -> None:
                     buf.clear()
                     buf.append(remaining)
     except Exception as e:
-        print(f"Error reading process output: {str(e)}")
+        logger.error(f"Error reading process output: {str(e)}")
 
 
 def _start_plot_process(gui_id: str, gui_class: type, config: dict | str, logger=None) -> None:
@@ -146,7 +146,7 @@ class BECGuiClientMixin:
                         continue
                     return ep.load()(gui=self)
                 except Exception as e:
-                    print(f"Error loading auto update script from plugin: {str(e)}")
+                    logger.error(f"Error loading auto update script from plugin: {str(e)}")
         return None
 
     @property
@@ -189,11 +189,12 @@ class BECGuiClientMixin:
         if self._process is None or self._process.poll() is not None:
             self._start_update_script()
             self._process, self._process_output_processing_thread = _start_plot_process(
-                self._gui_id, self.__class__, self._client._service_config.config
+                self._gui_id, self.__class__, self._client._service_config.config, logger=logger
             )
         while not self.gui_is_alive():
             print("Waiting for GUI to start...")
             time.sleep(1)
+        logger.success(f"GUI started with id: {self._gui_id}")
 
     def close(self) -> None:
         """
@@ -226,7 +227,7 @@ class RPCBase:
     def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
         self._client = BECClient()  # BECClient is a singleton; here, we simply get the instance
         self._config = config if config is not None else {}
-        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())[:5]
         self._parent = parent
         self._msg_wait_event = threading.Event()
         self._rpc_response = None

bec_widgets/cli/server.py

@@ -53,9 +53,11 @@ class BECWidgetsCLIServer:
         self._heartbeat_timer.start(200)
 
         self.status = messages.BECStatus.RUNNING
+        logger.success(f"Server started with gui_id: {self.gui_id}")
 
     def on_rpc_update(self, msg: dict, metadata: dict):
         request_id = metadata.get("request_id")
+        logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
         try:
             obj = self.get_object_from_config(msg["parameter"])
             method = msg["action"]
@@ -63,9 +65,10 @@ class BECWidgetsCLIServer:
             kwargs = msg["parameter"].get("kwargs", {})
             res = self.run_rpc(obj, method, args, kwargs)
         except Exception as e:
-            print(e)
+            logger.error(f"Error while executing RPC instruction: {e}")
             self.send_response(request_id, False, {"error": str(e)})
         else:
+            logger.debug(f"RPC instruction executed successfully: {res}")
             self.send_response(request_id, True, {"result": res})
 
     def send_response(self, request_id: str, accepted: bool, msg: dict):
@@ -113,6 +116,7 @@ class BECWidgetsCLIServer:
         return obj
 
     def emit_heartbeat(self):
+        logger.trace(f"Emitting heartbeat for {self.gui_id}")
         self.client.connector.set(
             MessageEndpoints.gui_heartbeat(self.gui_id),
             messages.StatusMessage(name=self.gui_id, status=self.status, info={}),
@@ -120,6 +124,7 @@ class BECWidgetsCLIServer:
         )
 
     def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
+        logger.info(f"Shutting down server with gui_id: {self.gui_id}")
         self.status = messages.BECStatus.IDLE
         self._heartbeat_timer.stop()
         self.emit_heartbeat()
@@ -137,7 +142,8 @@ class SimpleFileLikeFromLogOutputFunc:
 
     def flush(self):
         lines, _, remaining = "".join(self._buffer).rpartition("\n")
-        self._log_func(lines)
+        if lines:
+            self._log_func(lines)
         self._buffer = [remaining]
 
     def close(self):
@@ -155,12 +161,12 @@ def _start_server(gui_id: str, gui_class: Union[BECFigure, BECDockArea], config:
         # if no config is provided, use the default config
         service_config = ServiceConfig()
 
-    bec_logger.configure(
-        service_config.redis,
-        QtRedisConnector,
-        service_name="BECWidgetsCLIServer",
-        service_config=service_config.service_config,
-    )
+    # bec_logger.configure(
+    #     service_config.redis,
+    #     QtRedisConnector,
+    #     service_name="BECWidgetsCLIServer",
+    #     service_config=service_config.service_config,
+    # )
     server = BECWidgetsCLIServer(gui_id=gui_id, config=service_config, gui_class=gui_class)
     return server
 
@@ -175,6 +181,12 @@ def main():
 
     import bec_widgets
 
+    bec_logger.level = bec_logger.LOGLEVEL.DEBUG
+    if __name__ != "__main__":
+        # if not running as main, set the log level to critical
+        # pylint: disable=protected-access
+        bec_logger._stderr_log_level = bec_logger.LOGLEVEL.CRITICAL
+
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
     parser.add_argument("--id", type=str, help="The id of the server")
     parser.add_argument(
@@ -197,7 +209,7 @@ def main():
         )
         gui_class = BECFigure
 
-    with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.debug)):
+    with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):
         with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
             app = QApplication(sys.argv)
             app.setApplicationName("BEC Figure")

bec_widgets/examples/plugin_example_pyside/tictactoe.py

@@ -16,7 +16,6 @@ class TicTacToe(QWidget):  # pragma: no cover
         super().__init__(parent)
         self._state = DEFAULT_STATE
         self._turn_number = 0
-        print("TicTac HERE !!!!!!")
 
     def minimumSizeHint(self):
         return QSize(200, 200)

bec_widgets/utils/bec_connector.py

@@ -6,7 +6,7 @@ import time
 import uuid
 from typing import Optional
 
-import yaml
+from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import_from
 from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
@@ -17,6 +17,7 @@ from bec_widgets.qt_utils.error_popups import ErrorPopupUtility
 from bec_widgets.qt_utils.error_popups import SafeSlot as pyqtSlot
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
+logger = bec_logger.logger
 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
 
@@ -81,9 +82,9 @@ class BECConnector:
             # the function depends on BECClient, and BECDispatcher
             @pyqtSlot()
             def terminate(client=self.client, dispatcher=self.bec_dispatcher):
-                print("Disconnecting", repr(dispatcher))
+                logger.info("Disconnecting", repr(dispatcher))
                 dispatcher.disconnect_all()
-                print("Shutting down BEC Client", repr(client))
+                logger.info("Shutting down BEC Client", repr(client))
                 client.shutdown()
 
             BECConnector.EXIT_HANDLERS[self.client] = terminate
@@ -93,7 +94,7 @@ class BECConnector:
             self.config = config
             self.config.widget_class = self.__class__.__name__
         else:
-            print(
+            logger.debug(
                 f"No initial config found for {self.__class__.__name__}.\n"
                 f"Initializing with default config."
             )

bec_widgets/utils/bec_dispatcher.py

@@ -6,11 +6,14 @@ from typing import TYPE_CHECKING, Union
 
 import redis
 from bec_lib.client import BECClient
+from bec_lib.logger import bec_logger
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from bec_lib.service_config import ServiceConfig
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
+logger = bec_logger.logger
+
 if TYPE_CHECKING:
     from bec_lib.endpoints import EndpointInfo
 
@@ -65,11 +68,6 @@ class QtRedisConnector(RedisConnector):
             cb(msg.content, msg.metadata)
 
 
-class BECClientWithoutLoggerInit(BECClient):
-    def _initialize_logger(self):
-        return
-
-
 class BECDispatcher:
     """Utility class to keep track of slots connected to a particular redis connector"""
 
@@ -94,24 +92,22 @@ class BECDispatcher:
                 if not isinstance(config, ServiceConfig):
                     # config is supposed to be a path
                     config = ServiceConfig(config)
-                self.client = BECClientWithoutLoggerInit(
-                    config=config, connector_cls=QtRedisConnector
-                )  # , forced=True)
-            else:
-                self.client = BECClientWithoutLoggerInit(
-                    connector_cls=QtRedisConnector
-                )  # , forced=True)
+            self.client = BECClient(
+                config=config, connector_cls=QtRedisConnector, name="BECWidgets"
+            )
         else:
             if self.client.started:
                 # have to reinitialize client to use proper connector
+                logger.info("Shutting down BECClient to switch to QtRedisConnector")
                 self.client.shutdown()
             self.client._BECClient__init_params["connector_cls"] = QtRedisConnector
 
         try:
             self.client.start()
         except redis.exceptions.ConnectionError:
-            print("Could not connect to Redis, skipping start of BECClient.")
+            logger.warning("Could not connect to Redis, skipping start of BECClient.")
 
+        logger.success("Initialized BECDispatcher")
         self._initialized = True
 
     @classmethod

bec_widgets/utils/bec_widget.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 import darkdetect
+from bec_lib.logger import bec_logger
 from qtpy.QtCore import Slot
 from qtpy.QtWidgets import QApplication, QWidget
 
 from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
 from bec_widgets.utils.colors import set_theme
 
+logger = bec_logger.logger
+
 
 class BECWidget(BECConnector):
     """Mixin class for all BEC widgets, to handle cleanup"""
@@ -41,7 +44,7 @@ class BECWidget(BECConnector):
         """
         if not isinstance(self, QWidget):
             raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
-        super().__init__(client, config, gui_id)
+        super().__init__(client=client, config=config, gui_id=gui_id)
 
         # Set the theme to auto if it is not set yet
         app = QApplication.instance()
@@ -54,6 +57,7 @@ class BECWidget(BECConnector):
                 set_theme("light")
 
         if theme_update:
+            logger.debug(f"Subscribing to theme updates for {self.__class__.__name__}")
             self._connect_to_theme_change()
 
     def _connect_to_theme_change(self):

bec_widgets/widgets/dap_combo_box/dap_combo_box.py

@@ -0,0 +1,185 @@
+""" Module for DapComboBox widget class to select a DAP model from a combobox. """
+
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property, Signal, Slot
+from qtpy.QtWidgets import QComboBox, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+
+logger = bec_logger.logger
+
+
+class DapComboBox(BECWidget, QWidget):
+    """
+    The DAPComboBox widget is an extension to the QComboBox with all avaialble DAP model from BEC.
+
+    Args:
+        parent: Parent widget.
+        client: BEC client object.
+        gui_id: GUI ID.
+        default: Default device name.
+    """
+
+    ICON_NAME = "data_exploration"
+
+    USER_ACCESS = ["select_y_axis", "select_x_axis", "select_fit_model"]
+
+    ### Signals ###
+    # Signal to emit a new dap_config: (x_axis, y_axis, fit_model). Can be used to add a new DAP process
+    # in the BECWaveformWidget using its add_dap method. The signal is emitted when the user selects a new
+    # fit model, but only if x_axis and y_axis are set.
+    new_dap_config = Signal(str, str, str)
+    # Signal to emit the name of the updated x_axis
+    x_axis_updated = Signal(str)
+    # Signal to emit the name of the updated y_axis
+    y_axis_updated = Signal(str)
+    # Signal to emit the name of the updated fit model
+    fit_model_updated = Signal(str)
+
+    def __init__(
+        self, parent=None, client=None, gui_id: str | None = None, default_fit: str | None = None
+    ):
+        super().__init__(client=client, gui_id=gui_id)
+        QWidget.__init__(self, parent=parent)
+        self.layout = QVBoxLayout(self)
+        self.fit_model_combobox = QComboBox(self)
+        self.layout.addWidget(self.fit_model_combobox)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self._available_models = None
+        self._x_axis = None
+        self._y_axis = None
+        self.populate_fit_model_combobox()
+        self.fit_model_combobox.currentTextChanged.connect(self._update_current_fit)
+        # Set default fit model
+        self.select_default_fit(default_fit)
+
+    def select_default_fit(self, default_fit: str | None):
+        """Set the default fit model.
+
+        Args:
+            default_fit(str): Default fit model.
+        """
+        if self._validate_dap_model(default_fit):
+            self.select_fit_model(default_fit)
+        else:
+            self.select_fit_model("GaussianModel")
+
+    @property
+    def available_models(self):
+        """Available models property."""
+        return self._available_models
+
+    @available_models.setter
+    def available_models(self, available_models: list[str]):
+        """Set the available models.
+
+        Args:
+            available_models(list[str]): Available models.
+        """
+        self._available_models = available_models
+
+    @Property(str)
+    def x_axis(self):
+        """X axis property."""
+        return self._x_axis
+
+    @x_axis.setter
+    def x_axis(self, x_axis: str):
+        """Set the x axis.
+
+        Args:
+            x_axis(str): X axis.
+        """
+        # TODO add validator for x axis -> Positioner? or also device (must be monitored)!!
+        self._x_axis = x_axis
+        self.x_axis_updated.emit(x_axis)
+
+    @Property(str)
+    def y_axis(self):
+        """Y axis property."""
+        # TODO add validator for y axis -> Positioner & Device? Must be a monitored device!!
+        return self._y_axis
+
+    @y_axis.setter
+    def y_axis(self, y_axis: str):
+        """Set the y axis.
+
+        Args:
+            y_axis(str): Y axis.
+        """
+        self._y_axis = y_axis
+        self.y_axis_updated.emit(y_axis)
+
+    def _update_current_fit(self, fit_name: str):
+        """Update the current fit."""
+        self.fit_model_updated.emit(fit_name)
+        if self.x_axis is not None and self.y_axis is not None:
+            self.new_dap_config.emit(self._x_axis, self._y_axis, fit_name)
+
+    @Slot(str)
+    def select_x_axis(self, x_axis: str):
+        """Slot to update the x axis.
+
+        Args:
+            x_axis(str): X axis.
+        """
+        self.x_axis = x_axis
+
+    @Slot(str)
+    def select_y_axis(self, y_axis: str):
+        """Slot to update the y axis.
+
+        Args:
+            y_axis(str): Y axis.
+        """
+        self.y_axis = y_axis
+
+    @Slot(str)
+    def select_fit_model(self, fit_name: str | None):
+        """Slot to update the fit model.
+
+        Args:
+            default_device(str): Default device name.
+        """
+        if not self._validate_dap_model(fit_name):
+            raise ValueError(f"Fit {fit_name} is not valid.")
+        self.fit_model_combobox.setCurrentText(fit_name)
+
+    def populate_fit_model_combobox(self):
+        """Populate the fit_model_combobox with the devices."""
+        # pylint: disable=protected-access
+        self.available_models = [model for model in self.client.dap._available_dap_plugins.keys()]
+        self.fit_model_combobox.clear()
+        self.fit_model_combobox.addItems(self.available_models)
+
+    def _validate_dap_model(self, model: str | None) -> bool:
+        """Validate the DAP model.
+
+        Args:
+            model(str): Model name.
+        """
+        if model is None:
+            return False
+        if model not in self.available_models:
+            return False
+        return True
+
+
+# pragma: no cover
+def main():
+    """Main function to run the DapComboBox widget."""
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication(sys.argv)
+    set_theme("auto")
+    widget = DapComboBox()
+    widget.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+    main()

bec_widgets/widgets/dap_combo_box/dap_combo_box.pyproject

@@ -0,0 +1 @@
+{'files': ['dap_combo_box.py']}

bec_widgets/widgets/dap_combo_box/dap_combo_box_plugin.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.dap_combo_box.dap_combo_box import DapComboBox
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='DapComboBox' name='dap_combo_box'>
+    </widget>
+</ui>
+"""
+
+
+class DapComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = DapComboBox(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Selection Widgets"
+
+    def icon(self):
+        return designer_material_icon(DapComboBox.ICON_NAME)
+
+    def includeFile(self):
+        return "dap_combo_box"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "DapComboBox"
+
+    def toolTip(self):
+        return ""
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/dap_combo_box/register_dap_combo_box.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.dap_combo_box.dap_combo_box_plugin import DapComboBoxPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(DapComboBoxPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()