0.78.0

Automatically generated by python-semantic-release

CHANGELOG.md

@@ -1,5 +1,77 @@
 # CHANGELOG
 
+## v0.78.0 (2024-07-02)
+
+### Feature
+
+* feat(color_button): patched ColorButton from pyqtgraph to be able to be opened in another QDialog ([`c36bb80`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c36bb80d6a4939802a4a1c8e5452c7b94bac185e))
+
+## v0.77.0 (2024-07-02)
+
+### Feature
+
+* feat(bec_connector): export config to yaml ([`a391f30`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a391f3018c50fee6a4a06884491b957df80c3cd3))
+
+* feat(utils): colors added convertor for rgba to hex ([`572f2fb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/572f2fb8110d5cb0e80f3ca45ce57ef405572456))
+
+### Fix
+
+* fix(waveform): scatter 2D brush error ([`215d59c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/215d59c8bfe7fda9aff8cec8353bef9e1ce2eca1))
+
+* fix(figure): API cleanup ([`008a33a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/008a33a9b192473cc58e90cd6d98c5bcb5f7b8c0))
+
+* fix(figure): if/else logic corrected in subplot_factory ([`3e78723`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3e787234c7274b0698423d7bf9a4c54ec46bad5f))
+
+* fix(image): processing of already displayed data; closes #106 ([`1173510`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1173510105d2d70d7e498c2ac1e122cea3a16597))
+
+* fix(bec_figure): full reconstruction with config from other bec figure ([`b6e1e20`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b6e1e20b7c8549bb092e981062329e601411dda6))
+
+* fix(motor_map): API changes updates current visualisation; motor_map can be initialised from config ([`2e2d422`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2e2d422910685a2527a3d961a468c787f771ca44))
+
+* fix(image): image add_custom_image fixed, closes #225 ([`f0556e4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f0556e44113ffee66cf735aa2dd758c62cb634f4))
+
+* fix(figure): subplot methods consolidated; added subplot factory ([`4a97105`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4a97105e4bd2ce77d72dfe5f8307dd9ee65b21b0))
+
+* fix(image): image can be fully reconstructed from config ([`797f73c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/797f73c39aa73e07d6311f3de4baea53f6c380e0))
+
+* fix(image_item): vrange added int for pydantic model check ([`b8f796f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b8f796fd3fcc15641e8fc6a3ca75c344ce90fc45))
+
+* fix(bec_figure): waveforms can be initialised from the config; widgets are deleteLater after removal ([`78673ea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/78673ea11a47aad878128197ae6213925228ed59))
+
+### Unknown
+
+* Resolve "add VT100 console executing BEC as a widget" ([`c6a14c0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c6a14c0768a90695567a83a7895247ed0c64f3ce))
+
+## v0.76.1 (2024-06-29)
+
+### Fix
+
+* fix(plugins): fixes and tests for auto-gen plugins ([`c42511d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c42511dd44cc13577e108a6cef3166376e594f54))
+
+## v0.76.0 (2024-06-28)
+
+### Feature
+
+* feat(designer): added support for creating designer plugins automatically ([`c1dd0ee`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c1dd0ee1906dba1f2e2ae9ce40a84d55c26a1cce))
+
+### Fix
+
+* fix: fixed qwidget inheritance for ring progress bar ([`0610d2f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0610d2f9f027f8659e7149f2dfbb316ff30e337d))
+
+### Unknown
+
+* fix:parent set as first kwarg TextBox and WebsiteWidget ([`a45c407`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a45c4075684b93bfdcee03e5a416b84f61d3bc6f))
+
+## v0.75.0 (2024-06-26)
+
+### Feature
+
+* feat(widgets): added simple bec queue widget ([`3faee98`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3faee98ec80041a27e4c1f1156178de6f9dcdc63))
+
+### Refactor
+
+* refactor(dispatcher): cleanup ([`ca02132`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ca02132c8d18535b37e9192e00459d2aca6ba5cf))
+
 ## v0.74.1 (2024-06-26)
 
 ### Build
@@ -77,77 +149,3 @@
 ### Fix
 
 * fix: renamed spiral progress bar to ring progress bar; closes #235 ([`e5c0087`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e5c0087c9aed831edbe1c172746325a772a3bafa))
-
-### Test
-
-* test: bugfix to prohibit leackage of mock ([`4348ed1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4348ed1bb2182da6bdecaf372d6db85279e60af8))
-
-## v0.72.0 (2024-06-24)
-
-### Feature
-
-* feat(connector): added threadpool wrapper ([`4ca1efe`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4ca1efeeb8955604069f7b98374c7f82e1a8da67))
-
-### Unknown
-
-* tests(status_box_test): temporary disabled tests for status_box due to high rate of failures ([`aa7ce2e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/aa7ce2ea27bb9564d4f5104bbff30725b8656453))
-
-## v0.71.1 (2024-06-23)
-
-### Fix
-
-* fix: don't print exception if the auto-update module cannot be found in plugins ([`860517a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/860517a3211075d1f6e2af7fa6a567b9e0cd77f3))
-
-## v0.71.0 (2024-06-23)
-
-### Feature
-
-* feat(scan_group_box): scan box for args and kwargs separated from ScanControlGUI code ([`d8cf441`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d8cf44134c30063e586771f9068947fef7a306d1))
-
-### Fix
-
-* fix(cleanup): cleanup added to device_input widgets and scan_control ([`8badb6a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8badb6adc1d003dbf0b2b1a800c34821f3fc9aa3))
-
-* fix(scan_group_box): added row counter based on widgets ([`37682e7`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/37682e7b8a6ede38308880d285e41a948d6fe831))
-
-* fix(scan_control): added default min limit for args bundle if specified ([`ec4574e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ec4574ed5c2c85ea6fbbe2b98f162a8e1220653b))
-
-* fix(scan_control): argbox delete later added to prevent overlapping gui if scan changed ([`7ce3a83`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7ce3a83c58cb69c2bf7cb7f4eaba7e6a2ca6c546))
-
-* fix(scan_control): only scans with defined gui_config are allowed ([`6dff187`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6dff1879c4178df0f8ebfd35101acdebb028d572))
-
-* fix(WidgetIO): find handlers within base classes ([`ca85638`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ca856384f380dabf28d43f1cd48511af784c035b))
-
-* fix(scan_control): adapted widget to scan BEC gui config ([`8b822e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8b822e0fa8e28f080b9a4bf81948a7280a4c07bf))
-
-* fix(scan_control): scan_control.py combatible with the newest BEC versions, test disabled ([`67d398c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/67d398caf74e08ab25a70cc5d85a5f0c2de8212d))
-
-### Refactor
-
-* refactor(device_line_edit): renamed default_device to default ([`4e2c9df`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4e2c9df6a4979d935285fd7eba17fd7fd455a35c))
-
-### Test
-
-* test(scan_control): tests added ([`56e74a0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/56e74a0e7da72d18e89bc30d1896dbf9ef97cd6b))
-
-### Unknown
-
-* test(scan_control):e2e tests added ([`83001a0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/83001a0d8267e1320549b07032857dcf46ecd293))
-
-* doc(scan_control): docs added ([`1b7921a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1b7921a7f2e3bcc846219a2a7aa0de0fd27bb8fe))
-
-* fix(device_line_edit):SizePolicy fixed for 100 horizontal ([`21d20e0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/21d20e0fc78e9a3853abe802733388cce119ce20))
-
-* tests WIP ([`c09644b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c09644b29ddb291c91dc58bcd6ebf02ff45cab36))
-
-## v0.70.0 (2024-06-21)
-
-### Feature
-
-* feat(bec-designer): automatic plugin discovery ([`4639eee`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4639eee0b975ebd7a946e0e290449f5b88c372eb))
-
-* feat(device_line_edit): plugin added to bec-designer ([`b4b27ae`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b4b27aea3d8c08fa3d5d5514c69dbde32721d1dc))
-
-### Fix
-
-* fix(bec-desiger+plugins): imports fixed, PYSIDE6 check to not enable run plugins with pyqt6 ([`50b3422`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/50b3422528d46d74317e8c903b6286e868ab7fe0))

bec_widgets/cli/client.py

@@ -13,6 +13,7 @@ class Widgets(str, enum.Enum):
     Enum for the available widgets.
     """
 
+    BECQueue = "BECQueue"
     BECStatusBox = "BECStatusBox"
     BECDock = "BECDock"
     BECDockArea = "BECDockArea"
@@ -40,14 +41,14 @@ class BECCurve(RPCBase):
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -161,7 +162,7 @@ class BECCurve(RPCBase):
 class BECDock(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -171,7 +172,7 @@ class BECDock(RPCBase):
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
@@ -289,7 +290,7 @@ class BECDock(RPCBase):
 class BECDockArea(RPCBase, BECGuiClientMixin):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -397,7 +398,7 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -416,14 +417,14 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
 class BECFigure(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -431,6 +432,12 @@ class BECFigure(RPCBase):
             dict: The configuration of the widget.
         """
 
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
     @rpc_call
     def axes(self, row: "int", col: "int") -> "BECPlotBase":
         """
@@ -453,103 +460,6 @@ class BECFigure(RPCBase):
             dict: All widgets within the figure.
         """
 
-    @rpc_call
-    def add_plot(
-        self,
-        x: "list | np.ndarray" = None,
-        y: "list | np.ndarray" = None,
-        x_name: "str" = None,
-        y_name: "str" = None,
-        z_name: "str" = None,
-        x_entry: "str" = None,
-        y_entry: "str" = None,
-        z_entry: "str" = None,
-        color: "Optional[str]" = None,
-        color_map_z: "Optional[str]" = "plasma",
-        label: "Optional[str]" = None,
-        validate: "bool" = True,
-        row: "int" = None,
-        col: "int" = None,
-        config=None,
-        dap: "str | None" = None,
-        **axis_kwargs,
-    ) -> "BECWaveform":
-        """
-        Add a Waveform1D plot to the figure at the specified position.
-
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
-        """
-
-    @rpc_call
-    def add_image(
-        self,
-        monitor: "str" = None,
-        color_bar: "Literal['simple', 'full']" = "full",
-        color_map: "str" = "magma",
-        data: "np.ndarray" = None,
-        vrange: "tuple[float, float]" = None,
-        row: "int" = None,
-        col: "int" = None,
-        config=None,
-        **axis_kwargs,
-    ) -> "BECImageShow":
-        """
-        Add an image to the figure at the specified position.
-
-        Args:
-            monitor(str): The name of the monitor to display.
-            color_bar(Literal["simple","full"]): The type of color bar to display.
-            color_map(str): The color map to use for the image.
-            data(np.ndarray): Custom data to display.
-            vrange(tuple[float, float]): The range of values to display.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECImageShow: The image widget.
-        """
-
-    @rpc_call
-    def add_motor_map(
-        self,
-        motor_x: "str" = None,
-        motor_y: "str" = None,
-        row: "int" = None,
-        col: "int" = None,
-        config=None,
-        **axis_kwargs,
-    ) -> "BECMotorMap":
-        """
-        Args:
-            motor_x(str): The name of the motor for the X axis.
-            motor_y(str): The name of the motor for the Y axis.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs:
-
-        Returns:
-            BECMotorMap: The motor map widget.
-        """
-
     @rpc_call
     def plot(
         self,
@@ -565,7 +475,11 @@ class BECFigure(RPCBase):
         color_map_z: "str | None" = "plasma",
         label: "str | None" = None,
         validate: "bool" = True,
+        new: "bool" = False,
+        row: "int | None" = None,
+        col: "int | None" = None,
         dap: "str | None" = None,
+        config: "dict | None" = None,
         **axis_kwargs,
     ) -> "BECWaveform":
         """
@@ -584,7 +498,11 @@ class BECFigure(RPCBase):
             color_map_z(str): The color map to use for the z-axis.
             label(str): The label of the curve.
             validate(bool): If True, validate the device names and entries.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
             dap(str): The DAP model to use for the curve.
+            config(dict): Recreates the whole BECWaveform widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
@@ -599,6 +517,10 @@ class BECFigure(RPCBase):
         color_map: "str" = "magma",
         data: "np.ndarray" = None,
         vrange: "tuple[float, float]" = None,
+        new: "bool" = False,
+        row: "int | None" = None,
+        col: "int | None" = None,
+        config: "dict | None" = None,
         **axis_kwargs,
     ) -> "BECImageShow":
         """
@@ -610,6 +532,10 @@ class BECFigure(RPCBase):
             color_map(str): The color map to use for the image.
             data(np.ndarray): Custom data to display.
             vrange(tuple[float, float]): The range of values to display.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
@@ -618,7 +544,14 @@ class BECFigure(RPCBase):
 
     @rpc_call
     def motor_map(
-        self, motor_x: "str" = None, motor_y: "str" = None, **axis_kwargs
+        self,
+        motor_x: "str" = None,
+        motor_y: "str" = None,
+        new: "bool" = False,
+        row: "int | None" = None,
+        col: "int | None" = None,
+        config: "dict | None" = None,
+        **axis_kwargs,
     ) -> "BECMotorMap":
         """
         Add a motor map to the figure. Always access the first motor map widget in the figure.
@@ -626,6 +559,10 @@ class BECFigure(RPCBase):
         Args:
             motor_x(str): The name of the motor for the X axis.
             motor_y(str): The name of the motor for the Y axis.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
@@ -676,12 +613,6 @@ class BECFigure(RPCBase):
         Clear all widgets from the figure and reset to default state
         """
 
-    @rpc_call
-    def get_all_rpc(self) -> "dict":
-        """
-        Get all registered RPC objects.
-        """
-
     @property
     @rpc_call
     def widget_list(self) -> "list[BECPlotBase]":
@@ -695,14 +626,14 @@ class BECFigure(RPCBase):
 class BECImageItem(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -849,14 +780,14 @@ class BECImageItem(RPCBase):
 class BECImageShow(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -876,34 +807,12 @@ class BECImageShow(RPCBase):
             BECImageItem: The image object.
         """
 
-    @rpc_call
-    def get_image_config(self, image_id, dict_output: "bool" = True) -> "ImageItemConfig | dict":
-        """
-        Get the configuration of the image.
-
-        Args:
-            image_id(str): The ID of the image.
-            dict_output(bool): Whether to return the configuration as a dictionary. Defaults to True.
-
-        Returns:
-            ImageItemConfig|dict: The configuration of the image.
-        """
-
-    @rpc_call
-    def get_image_dict(self) -> "dict[str, dict[str, BECImageItem]]":
-        """
-        Get all images.
-
-        Returns:
-            dict[str, dict[str, BECImageItem]]: The dictionary of images.
-        """
-
     @rpc_call
     def add_monitor_image(
         self,
         monitor: "str",
         color_map: "Optional[str]" = "magma",
-        color_bar: "Optional[Literal['simple', 'full']]" = "simple",
+        color_bar: "Optional[Literal['simple', 'full']]" = "full",
         downsample: "Optional[bool]" = True,
         opacity: "Optional[float]" = 1.0,
         vrange: "Optional[tuple[int, int]]" = None,
@@ -919,7 +828,7 @@ class BECImageShow(RPCBase):
         name: "str",
         data: "Optional[np.ndarray]" = None,
         color_map: "Optional[str]" = "magma",
-        color_bar: "Optional[Literal['simple', 'full']]" = "simple",
+        color_bar: "Optional[Literal['simple', 'full']]" = "full",
         downsample: "Optional[bool]" = True,
         opacity: "Optional[float]" = 1.0,
         vrange: "Optional[tuple[int, int]]" = None,
@@ -1064,15 +973,6 @@ class BECImageShow(RPCBase):
             name(str): The name of the image. If None, apply to all images.
         """
 
-    @rpc_call
-    def toggle_threading(self, use_threading: "bool"):
-        """
-        Toggle threading for the widgets postprocessing and updating.
-
-        Args:
-            use_threading(bool): Whether to use threading.
-        """
-
     @rpc_call
     def set(self, **kwargs) -> "None":
         """
@@ -1208,14 +1108,14 @@ class BECImageShow(RPCBase):
 class BECMotorMap(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1306,7 +1206,7 @@ class BECMotorMap(RPCBase):
 class BECPlotBase(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1446,10 +1346,10 @@ class BECPlotBase(RPCBase):
         """
 
 
-class BECStatusBox(RPCBase):
+class BECQueue(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1458,7 +1358,25 @@ class BECStatusBox(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+
+class BECStatusBox(RPCBase):
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1467,14 +1385,14 @@ class BECStatusBox(RPCBase):
 class BECWaveform(RPCBase):
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1599,28 +1517,6 @@ class BECWaveform(RPCBase):
             BECCurve: The curve object.
         """
 
-    @rpc_call
-    def get_curve_config(self, curve_id: "str", dict_output: "bool" = True) -> "CurveConfig | dict":
-        """
-        Get the configuration of a curve by its ID.
-
-        Args:
-            curve_id(str): ID of the curve.
-
-        Returns:
-            CurveConfig|dict: Configuration of the curve.
-        """
-
-    @rpc_call
-    def apply_config(self, config: "dict | SubplotConfig", replot_last_scan: "bool" = False):
-        """
-        Apply the configuration to the 1D waveform widget.
-
-        Args:
-            config(dict|SubplotConfig): Configuration settings.
-            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
-        """
-
     @rpc_call
     def get_all_data(self, output: "Literal['dict', 'pandas']" = "dict") -> "dict | pd.DataFrame":
         """
@@ -1768,7 +1664,7 @@ class BECWaveform(RPCBase):
 class DeviceComboBox(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1777,7 +1673,7 @@ class DeviceComboBox(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1786,7 +1682,7 @@ class DeviceComboBox(RPCBase):
 class DeviceInputBase(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1795,7 +1691,7 @@ class DeviceInputBase(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1804,7 +1700,7 @@ class DeviceInputBase(RPCBase):
 class DeviceLineEdit(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1813,7 +1709,7 @@ class DeviceLineEdit(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -1821,21 +1717,21 @@ class DeviceLineEdit(RPCBase):
 
 class Ring(RPCBase):
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -1921,21 +1817,21 @@ class Ring(RPCBase):
 
 class RingProgressBar(RPCBase):
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
 
     @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def _rpc_id(self) -> "str":
         """
         Get the RPC ID of the widget.
         """
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -2101,7 +1997,7 @@ class RingProgressBar(RPCBase):
 class ScanControl(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -2110,7 +2006,7 @@ class ScanControl(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """
@@ -2119,7 +2015,7 @@ class ScanControl(RPCBase):
 class StopButton(RPCBase):
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def _config_dict(self) -> "dict":
         """
         Get the configuration of the widget.
 
@@ -2128,7 +2024,7 @@ class StopButton(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def _get_all_rpc(self) -> "dict":
         """
         Get all registered RPC objects.
         """

bec_widgets/cli/generate_cli.py

@@ -10,6 +10,7 @@ from typing import Literal
 import black
 import isort
 
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
 from bec_widgets.utils.plugin_utils import get_rpc_classes
 
 if sys.version_info >= (3, 11):
@@ -161,6 +162,26 @@ def main():
         generator.generate_client(rpc_classes)
         generator.write(client_path)
 
+        for cls in rpc_classes["top_level_classes"]:
+            plugin = DesignerPluginGenerator(cls)
+            if not hasattr(plugin, "info"):
+                continue
+
+            # if the class directory already has a register, plugin and pyproject file, skip
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"register_{plugin.info.plugin_name_snake}.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}_plugin.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}.pyproject")
+            ):
+                continue
+            plugin.run()
+
 
 if __name__ == "__main__":  # pragma: no cover
     sys.argv = ["generate_cli.py", "--core"]

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -40,12 +40,13 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "w1": self.w1,
                     "w2": self.w2,
                     "w3": self.w3,
+                    "w1_c": self.w1_c,
+                    "w2_c": self.w2_c,
+                    "w3_c": self.w3_c,
+                    "w4": self.w4,
                     "d0": self.d0,
                     "d1": self.d1,
                     "d2": self.d2,
-                    "fig0": self.fig0,
-                    "fig1": self.fig1,
-                    "fig2": self.fig2,
                     "plt": self.plt,
                     "bar": self.bar,
                 }
@@ -75,17 +76,37 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.figure.plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="cividis")
         self.figure.motor_map("samx", "samy")
         self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
-        self.figure.add_plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma")
+        self.figure.plot(
+            x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma", new=True
+        )
 
         self.figure.change_layout(2, 2)
 
         self.w1 = self.figure[0, 0]
         self.w2 = self.figure[0, 1]
         self.w3 = self.figure[1, 0]
+        self.w4 = self.figure[1, 1]
+
+        # Plot Customisation
+        self.w1.set_title("Waveform 1")
+        self.w1.set_x_label("Motor Position (samx)")
+        self.w1.set_y_label("Intensity A.U.")
+
+        # Image Customisation
+        self.w3.set_title("Eiger Image")
+        self.w3.set_x_label("X")
+        self.w3.set_y_label("Y")
+
+        # Configs to try to pass
+        self.w1_c = self.w1._config_dict
+        self.w2_c = self.w2._config_dict
+        self.w3_c = self.w3._config_dict
 
         # curves for w1
         self.c1 = self.w1.get_config()
 
+        self.fig_c = self.figure._config_dict
+
     def _init_dock(self):
 
         self.d0 = self.dock.add_dock(name="dock_0")

bec_widgets/utils/bec_connector.py

@@ -1,15 +1,19 @@
 # pylint: disable = no-name-in-module,missing-module-docstring
 from __future__ import annotations
 
+import os
 import time
+import uuid
 from typing import Optional
 
+import yaml
 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
 from qtpy.QtCore import Slot as pyqtSlot
 
 from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
@@ -62,7 +66,7 @@ class Worker(QRunnable):
 class BECConnector:
     """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
-    USER_ACCESS = ["config_dict", "get_all_rpc"]
+    USER_ACCESS = ["_config_dict", "_get_all_rpc"]
 
     def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
         # BEC related connections
@@ -126,23 +130,23 @@ class BECConnector:
         self._thread_pool.start(worker)
         return worker
 
-    def get_all_rpc(self) -> dict:
+    def _get_all_rpc(self) -> dict:
         """Get all registered RPC objects."""
         all_connections = self.rpc_register.list_all_connections()
         return dict(all_connections)
 
     @property
-    def rpc_id(self) -> str:
+    def _rpc_id(self) -> str:
         """Get the RPC ID of the widget."""
         return self.gui_id
 
-    @rpc_id.setter
-    def rpc_id(self, rpc_id: str) -> None:
+    @_rpc_id.setter
+    def _rpc_id(self, rpc_id: str) -> None:
         """Set the RPC ID of the widget."""
         self.gui_id = rpc_id
 
     @property
-    def config_dict(self) -> dict:
+    def _config_dict(self) -> dict:
         """
         Get the configuration of the widget.
 
@@ -151,8 +155,8 @@ class BECConnector:
         """
         return self.config.model_dump()
 
-    @config_dict.setter
-    def config_dict(self, config: BaseModel) -> None:
+    @_config_dict.setter
+    def _config_dict(self, config: BaseModel) -> None:
         """
         Get the configuration of the widget.
 
@@ -161,6 +165,60 @@ class BECConnector:
         """
         self.config = config
 
+    def apply_config(self, config: dict, generate_new_id: bool = True) -> None:
+        """
+        Apply the configuration to the widget.
+
+        Args:
+            config(dict): Configuration settings.
+            generate_new_id(bool): If True, generate a new GUI ID for the widget.
+        """
+        self.config = ConnectionConfig(**config)
+        if generate_new_id is True:
+            gui_id = str(uuid.uuid4())
+            self.rpc_register.remove_rpc(self)
+            self.set_gui_id(gui_id)
+            self.rpc_register.add_rpc(self)
+        else:
+            self.gui_id = self.config.gui_id
+
+    def load_config(self, path: str | None = None, gui: bool = False):
+        """
+        Load the configuration of the widget from YAML.
+
+        Args:
+            path(str): Path to the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to load the configuration file.
+        """
+        if gui is True:
+            config = load_yaml_gui(self)
+        else:
+            config = load_yaml(path)
+
+        if config is not None:
+            if config.get("widget_class") != self.__class__.__name__:
+                raise ValueError(
+                    f"Configuration file is not for {self.__class__.__name__}. Got configuration for {config.get('widget_class')}."
+                )
+            self.apply_config(config)
+
+    def save_config(self, path: str | None = None, gui: bool = False):
+        """
+        Save the configuration of the widget to YAML.
+
+        Args:
+            path(str): Path to save the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to save the configuration file.
+        """
+        if gui is True:
+            save_yaml_gui(self, self._config_dict)
+        else:
+            if path is None:
+                path = os.getcwd()
+            file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
+
+            save_yaml(file_path, self._config_dict)
+
     @pyqtSlot(str)
     def set_gui_id(self, gui_id: str) -> None:
         """

bec_widgets/utils/bec_dispatcher.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import argparse
 import collections
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Union

bec_widgets/utils/colors.py

@@ -67,6 +67,44 @@ class Colors:
                 raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
         return colors
 
+    @staticmethod
+    def hex_to_rgba(hex_color: str, alpha=255) -> tuple:
+        """
+        Convert HEX color to RGBA.
+
+        Args:
+            hex_color(str): HEX color string.
+            alpha(int): Alpha value (0-255). Default is 255 (opaque).
+
+        Returns:
+            tuple: RGBA color tuple (r, g, b, a).
+        """
+        hex_color = hex_color.lstrip("#")
+        if len(hex_color) == 6:
+            r, g, b = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
+        elif len(hex_color) == 8:
+            r, g, b, a = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4, 6))
+            return (r, g, b, a)
+        else:
+            raise ValueError("HEX color must be 6 or 8 characters long.")
+        return (r, g, b, alpha)
+
+    @staticmethod
+    def rgba_to_hex(r: int, g: int, b: int, a: int = 255) -> str:
+        """
+        Convert RGBA color to HEX.
+
+        Args:
+            r(int): Red value (0-255).
+            g(int): Green value (0-255).
+            b(int): Blue value (0-255).
+            a(int): Alpha value (0-255). Default is 255 (opaque).
+
+        Returns:
+            hec_color(str): HEX color string.
+        """
+        return "#{:02X}{:02X}{:02X}{:02X}".format(r, g, b, a)
+
     @staticmethod
     def validate_color(color: tuple | str) -> tuple | str:
         """

bec_widgets/utils/generate_designer_plugin.py

@@ -0,0 +1,148 @@
+import inspect
+import os
+import re
+
+from qtpy.QtCore import QObject
+
+EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock"]
+
+
+class DesignerPluginInfo:
+    def __init__(self, plugin_class):
+        self.plugin_class = plugin_class
+        self.plugin_name_pascal = plugin_class.__name__
+        self.plugin_name_snake = self.pascal_to_snake(self.plugin_name_pascal)
+        self.widget_import = f"from {plugin_class.__module__} import {self.plugin_name_pascal}"
+        plugin_module = (
+            ".".join(plugin_class.__module__.split(".")[:-1]) + f".{self.plugin_name_snake}_plugin"
+        )
+        self.plugin_import = f"from {plugin_module} import {self.plugin_name_pascal}Plugin"
+
+        # first sentence / line of the docstring is used as tooltip
+        self.plugin_tooltip = (
+            plugin_class.__doc__.split("\n")[0].strip().replace('"', "'")
+            if plugin_class.__doc__
+            else self.plugin_name_pascal
+        )
+
+        self.base_path = os.path.dirname(inspect.getfile(plugin_class))
+
+    @staticmethod
+    def pascal_to_snake(name: str) -> str:
+        """
+        Convert PascalCase to snake_case.
+
+        Args:
+            name (str): The name to be converted.
+
+        Returns:
+            str: The converted name.
+        """
+        s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+        s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
+        return s2.lower()
+
+
+class DesignerPluginGenerator:
+    def __init__(self, widget: type):
+        self._excluded = False
+        self.widget = widget
+        self.info = DesignerPluginInfo(widget)
+        if widget.__name__ in EXCLUDED_PLUGINS:
+
+            self._excluded = True
+            return
+
+        self.templates = {}
+        self.template_path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "plugin_templates"
+        )
+
+    def run(self):
+        if self._excluded:
+            print(f"Plugin {self.widget.__name__} is excluded from generation.")
+            return
+        self._check_class_validity()
+        self._load_templates()
+        self._write_templates()
+
+    def _check_class_validity(self):
+
+        # Check if the widget is a QWidget subclass
+        if not issubclass(self.widget, QObject):
+            return
+
+        # Check if the widget class has parent as the first argument. This is a strict requirement of Qt!
+        signature = list(inspect.signature(self.widget.__init__).parameters.values())
+        if len(signature) == 1 or signature[1].name != "parent":
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must have parent as the first argument."
+            )
+
+        base_cls = [val for val in self.widget.__bases__ if issubclass(val, QObject)]
+        if not base_cls:
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must inherit from a QObject subclass."
+            )
+
+        # Check if the widget class calls the super constructor with parent argument
+        init_source = inspect.getsource(self.widget.__init__)
+        cls_init_found = (
+            bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent=parent") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent)") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent,") > 0)
+        )
+        super_init_found = (
+            bool(
+                init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent=parent") > 0
+            )
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent,") > 0)
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent)") > 0)
+        )
+        if issubclass(self.widget.__bases__[0], QObject) and not super_init_found:
+            super_init_found = (
+                bool(init_source.find("super().__init__(parent=parent") > 0)
+                or bool(init_source.find("super().__init__(parent,") > 0)
+                or bool(init_source.find("super().__init__(parent)") > 0)
+            )
+
+        if not cls_init_found and not super_init_found:
+            raise ValueError(
+                f"Widget class {self.widget.__name__} must call the super constructor with parent."
+            )
+
+    def _write_templates(self):
+        self._write_register()
+        self._write_plugin()
+        self._write_pyproject()
+
+    def _write_register(self):
+        file_path = os.path.join(self.info.base_path, f"register_{self.info.plugin_name_snake}.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["register"].format(**self.info.__dict__))
+
+    def _write_plugin(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}_plugin.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["plugin"].format(**self.info.__dict__))
+
+    def _write_pyproject(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}.pyproject")
+        out = {"files": [f"{self.info.plugin_class.__module__.split('.')[-1]}.py"]}
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(str(out))
+
+    def _load_templates(self):
+        for file in os.listdir(self.template_path):
+            if not file.endswith(".template"):
+                continue
+            with open(os.path.join(self.template_path, file), "r", encoding="utf-8") as f:
+                self.templates[file.split(".")[0]] = f.read()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+    from bec_widgets.widgets.dock import BECDockArea
+
+    generator = DesignerPluginGenerator(BECDockArea)
+    generator.run()

bec_widgets/utils/plugin_templates/plugin.template

@@ -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 qtpy.QtGui import QIcon
+
+{widget_import}
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='{plugin_name_pascal}' name='{plugin_name_snake}'>
+    </widget>
+</ui>
+"""
+
+
+class {plugin_name_pascal}Plugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = {plugin_name_pascal}(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "{plugin_name_snake}"
+
+    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 "{plugin_name_pascal}"
+
+    def toolTip(self):
+        return "{plugin_tooltip}"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/utils/plugin_templates/register.template

@@ -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
+
+    {plugin_import}
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget({plugin_name_pascal}Plugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/utils/yaml_dialog.py

@@ -6,7 +6,7 @@ import yaml
 from qtpy.QtWidgets import QFileDialog
 
 
-def load_yaml(instance) -> Union[dict, None]:
+def load_yaml_gui(instance) -> Union[dict, None]:
     """
     Load YAML file from disk.
 
@@ -20,12 +20,25 @@ def load_yaml(instance) -> Union[dict, None]:
     file_path, _ = QFileDialog.getOpenFileName(
         instance, "Load Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
     )
+    config = load_yaml(file_path)
+    return config
 
+
+def load_yaml(file_path: str) -> Union[dict, None]:
+    """
+    Load YAML file from disk.
+
+    Args:
+        file_path(str): Path to the YAML file.
+
+    Returns:
+        dict: Configuration data loaded from the YAML file.
+    """
     if not file_path:
         return None
     try:
         with open(file_path, "r") as file:
-            config = yaml.safe_load(file)
+            config = yaml.load(file, Loader=yaml.FullLoader)
         return config
 
     except FileNotFoundError:
@@ -38,7 +51,7 @@ def load_yaml(instance) -> Union[dict, None]:
         print(f"An error occurred while loading the settings from {file_path}: {e}")
 
 
-def save_yaml(instance, config: dict) -> None:
+def save_yaml_gui(instance, config: dict) -> None:
     """
     Save YAML file to disk.
 
@@ -51,6 +64,17 @@ def save_yaml(instance, config: dict) -> None:
         instance, "Save Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
     )
 
+    save_yaml(file_path, config)
+
+
+def save_yaml(file_path: str, config: dict) -> None:
+    """
+    Save YAML file to disk.
+
+    Args:
+        file_path(str): Path to the YAML file.
+        config(dict): Configuration data to be saved.
+    """
     if not file_path:
         return
     try:

bec_widgets/widgets/bec_queue/bec_queue.py

@@ -0,0 +1,111 @@
+from bec_lib.endpoints import MessageEndpoints
+from qtpy.QtCore import Qt, Slot
+from qtpy.QtWidgets import QHeaderView, QTableWidget, QTableWidgetItem, QWidget
+
+from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+
+
+class BECQueue(BECConnector, QTableWidget):
+    """
+    Widget to display the BEC queue.
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        client=None,
+        config: ConnectionConfig = None,
+        gui_id: str = None,
+    ):
+        super().__init__(client, config, gui_id)
+        QTableWidget.__init__(self, parent=parent)
+        self.setColumnCount(3)
+        self.setHorizontalHeaderLabels(["Scan Number", "Type", "Status"])
+        header = self.horizontalHeader()
+        header.setSectionResizeMode(QHeaderView.Stretch)
+        self.bec_dispatcher.connect_slot(self.update_queue, MessageEndpoints.scan_queue_status())
+        self.reset_content()
+
+    @Slot(dict, dict)
+    def update_queue(self, content, _metadata):
+        """
+        Update the queue table with the latest queue information.
+
+        Args:
+            content (dict): The queue content.
+            _metadata (dict): The metadata.
+        """
+        # only show the primary queue for now
+        queue_info = content.get("queue", {}).get("primary", {}).get("info", [])
+        self.setRowCount(len(queue_info))
+        self.clearContents()
+
+        if not queue_info:
+            self.reset_content()
+            return
+
+        for index, item in enumerate(queue_info):
+            blocks = item.get("request_blocks", [])
+            scan_types = []
+            scan_numbers = []
+            status = item.get("status", "")
+            for request_block in blocks:
+                scan_type = request_block.get("content", {}).get("scan_type", "")
+                if scan_type:
+                    scan_types.append(scan_type)
+                scan_number = request_block.get("scan_number", "")
+                if scan_number:
+                    scan_numbers.append(str(scan_number))
+            if scan_types:
+                scan_types = ", ".join(scan_types)
+            if scan_numbers:
+                scan_numbers = ", ".join(scan_numbers)
+            self.set_row(index, scan_numbers, scan_types, status)
+
+    def format_item(self, content: str) -> QTableWidgetItem:
+        """
+        Format the content of the table item.
+
+        Args:
+            content (str): The content to be formatted.
+
+        Returns:
+            QTableWidgetItem: The formatted item.
+        """
+        item = QTableWidgetItem(content)
+        item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
+        return item
+
+    def set_row(self, index: int, scan_number: str, scan_type: str, status: str):
+        """
+        Set the row of the table.
+
+        Args:
+            index (int): The index of the row.
+            scan_number (str): The scan number.
+            scan_type (str): The scan type.
+            status (str): The status.
+        """
+
+        self.setItem(index, 0, self.format_item(scan_number))
+        self.setItem(index, 1, self.format_item(scan_type))
+        self.setItem(index, 2, self.format_item(status))
+
+    def reset_content(self):
+        """
+        Reset the content of the table.
+        """
+
+        self.setRowCount(1)
+        self.set_row(0, "", "", "")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = BECQueue()
+    widget.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/bec_queue/bec_queue.pyproject

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

bec_widgets/widgets/bec_queue/bec_queue_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 qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECQueue' name='bec_queue'>
+    </widget>
+</ui>
+"""
+
+
+class BECQueuePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECQueue(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "bec_queue"
+
+    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 "BECQueue"
+
+    def toolTip(self):
+        return "Widget to display the BEC queue."
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/bec_queue/register_bec_queue.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.bec_queue.bec_queue_plugin import BECQueuePlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECQueuePlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/buttons/color_button/color_button.py

@@ -0,0 +1,17 @@
+import pyqtgraph as pg
+
+
+class ColorButton(pg.ColorButton):
+    """
+    A ColorButton that opens a dialog to select a color. Inherits from pyqtgraph.ColorButton.
+    Patches event loop of the ColorDialog, if opened in another QDialog.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def selectColor(self):
+        self.origColor = self.color()
+        self.colorDialog.setCurrentColor(self.color())
+        self.colorDialog.open()
+        self.colorDialog.exec()

bec_widgets/widgets/buttons/color_button/color_button.pyproject

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

bec_widgets/widgets/buttons/color_button/color_button_plugin.py

@@ -0,0 +1,55 @@
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.buttons.color_button.color_button import ColorButton
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='ColorButton' name='color_button'>
+    </widget>
+</ui>
+"""
+
+
+class ColorButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = ColorButton(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Buttons"
+
+    def icon(self):
+        current_path = os.path.dirname(__file__)
+        icon_path = os.path.join(current_path, "assets", "color_button.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "color_button"
+
+    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 "ColorButton"
+
+    def toolTip(self):
+        return "ColorButton which opens a color dialog."
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/buttons/color_button/register_color_button.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.buttons.color_button.color_button_plugin import ColorButtonPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(ColorButtonPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/console/console.py

@@ -0,0 +1,496 @@
+"""
+BECConsole is a Qt widget that runs a Bash shell. The widget can be used and
+embedded like any other Qt widget.
+
+BECConsole is powered by Pyte, a Python based terminal emulator
+(https://github.com/selectel/pyte).
+"""
+
+import fcntl
+import html
+import os
+import pty
+import subprocess
+import sys
+import threading
+
+import pyte
+from qtpy import QtCore, QtGui, QtWidgets
+from qtpy.QtCore import QSize, QSocketNotifier, Qt
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtGui import QClipboard, QTextCursor
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QScrollBar, QSizePolicy
+
+ansi_colors = {
+    "black": "#000000",
+    "red": "#CD0000",
+    "green": "#00CD00",
+    "brown": "#996633",  # Brown, replacing the yellow
+    "blue": "#0000EE",
+    "magenta": "#CD00CD",
+    "cyan": "#00CDCD",
+    "white": "#E5E5E5",
+    "brightblack": "#7F7F7F",
+    "brightred": "#FF0000",
+    "brightgreen": "#00FF00",
+    "brightyellow": "#FFFF00",
+    "brightblue": "#5C5CFF",
+    "brightmagenta": "#FF00FF",
+    "brightcyan": "#00FFFF",
+    "brightwhite": "#FFFFFF",
+}
+
+control_keys_mapping = {
+    QtCore.Qt.Key_A: b"\x01",  # Ctrl-A
+    QtCore.Qt.Key_B: b"\x02",  # Ctrl-B
+    QtCore.Qt.Key_C: b"\x03",  # Ctrl-C
+    QtCore.Qt.Key_D: b"\x04",  # Ctrl-D
+    QtCore.Qt.Key_E: b"\x05",  # Ctrl-E
+    QtCore.Qt.Key_F: b"\x06",  # Ctrl-F
+    QtCore.Qt.Key_G: b"\x07",  # Ctrl-G (Bell)
+    QtCore.Qt.Key_H: b"\x08",  # Ctrl-H (Backspace)
+    QtCore.Qt.Key_I: b"\x09",  # Ctrl-I (Tab)
+    QtCore.Qt.Key_J: b"\x0A",  # Ctrl-J (Line Feed)
+    QtCore.Qt.Key_K: b"\x0B",  # Ctrl-K (Vertical Tab)
+    QtCore.Qt.Key_L: b"\x0C",  # Ctrl-L (Form Feed)
+    QtCore.Qt.Key_M: b"\x0D",  # Ctrl-M (Carriage Return)
+    QtCore.Qt.Key_N: b"\x0E",  # Ctrl-N
+    QtCore.Qt.Key_O: b"\x0F",  # Ctrl-O
+    QtCore.Qt.Key_P: b"\x10",  # Ctrl-P
+    QtCore.Qt.Key_Q: b"\x11",  # Ctrl-Q
+    QtCore.Qt.Key_R: b"\x12",  # Ctrl-R
+    QtCore.Qt.Key_S: b"\x13",  # Ctrl-S
+    QtCore.Qt.Key_T: b"\x14",  # Ctrl-T
+    QtCore.Qt.Key_U: b"\x15",  # Ctrl-U
+    QtCore.Qt.Key_V: b"\x16",  # Ctrl-V
+    QtCore.Qt.Key_W: b"\x17",  # Ctrl-W
+    QtCore.Qt.Key_X: b"\x18",  # Ctrl-X
+    QtCore.Qt.Key_Y: b"\x19",  # Ctrl-Y
+    QtCore.Qt.Key_Z: b"\x1A",  # Ctrl-Z
+    QtCore.Qt.Key_Escape: b"\x1B",  # Ctrl-Escape
+    QtCore.Qt.Key_Backslash: b"\x1C",  # Ctrl-\
+    QtCore.Qt.Key_Underscore: b"\x1F",  # Ctrl-_
+}
+
+normal_keys_mapping = {
+    QtCore.Qt.Key_Return: b"\n",
+    QtCore.Qt.Key_Space: b" ",
+    QtCore.Qt.Key_Enter: b"\n",
+    QtCore.Qt.Key_Tab: b"\t",
+    QtCore.Qt.Key_Backspace: b"\x08",
+    QtCore.Qt.Key_Home: b"\x47",
+    QtCore.Qt.Key_End: b"\x4f",
+    QtCore.Qt.Key_Left: b"\x02",
+    QtCore.Qt.Key_Up: b"\x10",
+    QtCore.Qt.Key_Right: b"\x06",
+    QtCore.Qt.Key_Down: b"\x0E",
+    QtCore.Qt.Key_PageUp: b"\x49",
+    QtCore.Qt.Key_PageDown: b"\x51",
+    QtCore.Qt.Key_F1: b"\x1b\x31",
+    QtCore.Qt.Key_F2: b"\x1b\x32",
+    QtCore.Qt.Key_F3: b"\x1b\x33",
+    QtCore.Qt.Key_F4: b"\x1b\x34",
+    QtCore.Qt.Key_F5: b"\x1b\x35",
+    QtCore.Qt.Key_F6: b"\x1b\x36",
+    QtCore.Qt.Key_F7: b"\x1b\x37",
+    QtCore.Qt.Key_F8: b"\x1b\x38",
+    QtCore.Qt.Key_F9: b"\x1b\x39",
+    QtCore.Qt.Key_F10: b"\x1b\x30",
+    QtCore.Qt.Key_F11: b"\x45",
+    QtCore.Qt.Key_F12: b"\x46",
+}
+
+
+def QtKeyToAscii(event):
+    """
+    Convert the Qt key event to the corresponding ASCII sequence for
+    the terminal. This works fine for standard alphanumerical characters, but
+    most other characters require terminal specific control sequences.
+
+    The conversion below works for TERM="linux" terminals.
+    """
+    if sys.platform == "darwin":
+        # special case for MacOS
+        # /!\ Qt maps ControlModifier to CMD
+        # CMD-C, CMD-V for copy/paste
+        # CTRL-C and other modifiers -> key mapping
+        if event.modifiers() == QtCore.Qt.MetaModifier:
+            if event.key() == Qt.Key_Backspace:
+                return control_keys_mapping.get(Qt.Key_W)
+            return control_keys_mapping.get(event.key())
+        elif event.modifiers() == QtCore.Qt.ControlModifier:
+            if event.key() == Qt.Key_C:
+                # copy
+                return "copy"
+            elif event.key() == Qt.Key_V:
+                # paste
+                return "paste"
+            return None
+        else:
+            return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+    if event.modifiers() == QtCore.Qt.ControlModifier:
+        return control_keys_mapping.get(event.key())
+    else:
+        return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+
+
+class Screen(pyte.HistoryScreen):
+    def __init__(self, stdin_fd, numColumns, numLines, historyLength):
+        super().__init__(numColumns, numLines, historyLength, ratio=1 / numLines)
+        self._fd = stdin_fd
+
+    def write_process_input(self, data):
+        """Response to CPR request for example"""
+        os.write(self._fd, data.encode("utf-8"))
+
+
+class Backend(QtCore.QObject):
+    """
+    Poll Bash.
+
+    This class will run as a qsocketnotifier (started in ``_TerminalWidget``) and poll the
+    file descriptor of the Bash terminal.
+    """
+
+    # Signals to communicate with ``_TerminalWidget``.
+    startWork = pyqtSignal()
+    dataReady = pyqtSignal(object)
+
+    def __init__(self, fd, numColumns, numLines):
+        super().__init__()
+
+        # File descriptor that connects to Bash process.
+        self.fd = fd
+
+        # Setup Pyte (hard coded display size for now).
+        self.screen = Screen(self.fd, numColumns, numLines, 10000)
+        self.stream = pyte.ByteStream()
+        self.stream.attach(self.screen)
+
+        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
+        self.notifier.activated.connect(self._fd_readable)
+
+    def _fd_readable(self):
+        """
+        Poll the Bash output, run it through Pyte, and notify the main applet.
+        """
+        # Read the shell output until the file descriptor is closed.
+        try:
+            out = os.read(self.fd, 2**16)
+        except OSError:
+            return
+
+        # Feed output into Pyte's state machine and send the new screen
+        # output to the GUI
+        self.stream.feed(out)
+        self.dataReady.emit(self.screen)
+
+
+class BECConsole(QtWidgets.QScrollArea):
+    """Container widget for the terminal text area"""
+
+    def __init__(self, parent=None, numLines=50, numColumns=125):
+        super().__init__(parent)
+
+        self.innerWidget = QtWidgets.QWidget(self)
+        QHBoxLayout(self.innerWidget)
+        self.innerWidget.layout().setContentsMargins(0, 0, 0, 0)
+
+        self.term = _TerminalWidget(self.innerWidget, numLines, numColumns)
+        self.term.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        self.innerWidget.layout().addWidget(self.term)
+
+        self.scroll_bar = QScrollBar(Qt.Vertical, self.term)
+        self.innerWidget.layout().addWidget(self.scroll_bar)
+
+        self.term.set_scroll(self.scroll_bar)
+
+        self.setWidget(self.innerWidget)
+
+    def start(self, cmd=["bec", "--nogui"], deactivate_ctrl_d=True):
+        self.term._cmd = cmd
+        self.term.start(deactivate_ctrl_d=deactivate_ctrl_d)
+
+    def push(self, text):
+        """Push some text to the terminal"""
+        return self.term.push(text)
+
+
+class _TerminalWidget(QtWidgets.QPlainTextEdit):
+    """
+    Start ``Backend`` process and render Pyte output as text.
+    """
+
+    def __init__(self, parent, numColumns, numLines, **kwargs):
+        super().__init__(parent)
+
+        # file descriptor to communicate with the subprocess
+        self.fd = None
+        self.backend = None
+        self.lock = threading.Lock()
+        # command to execute
+        self._cmd = None
+        # should ctrl-d be deactivated ? (prevent Python exit)
+        self._deactivate_ctrl_d = False
+
+        # Specify the terminal size in terms of lines and columns.
+        self.numLines = numLines
+        self.numColumns = numColumns
+        self.output = [""] * numLines
+
+        # Use Monospace fonts and disable line wrapping.
+        self.setFont(QtGui.QFont("Courier", 9))
+        self.setFont(QtGui.QFont("Monospace"))
+        self.setLineWrapMode(QtWidgets.QPlainTextEdit.NoWrap)
+
+        # Disable vertical scrollbar (we use our own, to be set via .set_scroll())
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+
+        fmt = QtGui.QFontMetrics(self.font())
+        self._char_width = fmt.width("w")
+        self._char_height = fmt.height()
+        self.setCursorWidth(self._char_width)
+        # self.setStyleSheet("QPlainTextEdit { color: #ffff00; background-color: #303030; } ");
+
+    def start(self, deactivate_ctrl_d=False):
+        self._deactivate_ctrl_d = deactivate_ctrl_d
+
+        # Start the Bash process
+        self.fd = self.forkShell()
+
+        # Create the ``Backend`` object
+        self.backend = Backend(self.fd, self.numColumns, self.numLines)
+        self.backend.dataReady.connect(self.dataReady)
+
+    def minimumSizeHint(self):
+        width = self._char_width * self.numColumns
+        height = self._char_height * self.numLines
+        return QSize(width, height + 20)
+
+    def set_scroll(self, scroll):
+        self.scroll = scroll
+        self.scroll.setMinimum(0)
+        self.scroll.valueChanged.connect(self.scroll_value_change)
+
+    def scroll_value_change(self, value, old={"value": 0}):
+        if value <= old["value"]:
+            # scroll up
+            # value is number of lines from the start
+            nlines = old["value"] - value
+            # history ratio gives prev_page == 1 line
+            for i in range(nlines):
+                self.backend.screen.prev_page()
+        else:
+            # scroll down
+            nlines = value - old["value"]
+            for i in range(nlines):
+                self.backend.screen.next_page()
+        old["value"] = value
+        self.dataReady(self.backend.screen, reset_scroll=False)
+
+    @pyqtSlot(object)
+    def keyPressEvent(self, event):
+        """
+        Redirect all keystrokes to the terminal process.
+        """
+        # Convert the Qt key to the correct ASCII code.
+        if (
+            self._deactivate_ctrl_d
+            and event.modifiers() == QtCore.Qt.ControlModifier
+            and event.key() == QtCore.Qt.Key_D
+        ):
+            return None
+
+        code = QtKeyToAscii(event)
+        if code == "copy":
+            # MacOS only: CMD-C handling
+            self.copy()
+        elif code == "paste":
+            # MacOS only: CMD-V handling
+            self._push_clipboard()
+        elif code is not None:
+            os.write(self.fd, code)
+
+    def push(self, text):
+        """
+        Write 'text' to terminal
+        """
+        os.write(self.fd, text.encode("utf-8"))
+
+    def contextMenuEvent(self, event):
+        menu = self.createStandardContextMenu()
+        for action in menu.actions():
+            # remove all actions except copy and paste
+            if "opy" in action.text():
+                # redefine text without shortcut
+                # since it probably clashes with control codes (like CTRL-C etc)
+                action.setText("Copy")
+                continue
+            if "aste" in action.text():
+                # redefine text without shortcut
+                action.setText("Paste")
+                # paste -> have to insert with self.push
+                action.triggered.connect(self._push_clipboard)
+                continue
+            menu.removeAction(action)
+        menu.exec_(event.globalPos())
+
+    def _push_clipboard(self):
+        clipboard = QApplication.instance().clipboard()
+        self.push(clipboard.text())
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.MiddleButton:
+            # push primary selection buffer ("mouse clipboard") to terminal
+            clipboard = QApplication.instance().clipboard()
+            if clipboard.supportsSelection():
+                self.push(clipboard.text(QClipboard.Selection))
+            return None
+        elif event.button() == Qt.LeftButton:
+            # left button click
+            textCursor = self.textCursor()
+            if textCursor.selectedText():
+                # mouse was used to select text -> nothing to do
+                pass
+            else:
+                # a simple 'click', make cursor going to end
+                textCursor.setPosition(0)
+                textCursor.movePosition(
+                    QTextCursor.Down, QTextCursor.MoveAnchor, self.backend.screen.cursor.y
+                )
+                textCursor.movePosition(
+                    QTextCursor.Right, QTextCursor.MoveAnchor, self.backend.screen.cursor.x
+                )
+                self.setTextCursor(textCursor)
+                self.ensureCursorVisible()
+                return None
+        return super().mouseReleaseEvent(event)
+
+    def dataReady(self, screenData, reset_scroll=True):
+        """
+        Render the new screen as text into the widget.
+
+        This method is triggered via a signal from ``Backend``.
+        """
+        with self.lock:
+            # Clear the widget
+            self.clear()
+
+            # Prepare the HTML output
+            for line_no in screenData.dirty:
+                line = text = ""
+                style = old_style = ""
+                for ch in screenData.buffer[line_no].values():
+                    style = f"{'background-color:%s;' % ansi_colors.get(ch.bg, ansi_colors['black']) if ch.bg!='default' else ''}{'color:%s;' % ansi_colors.get(ch.fg, ansi_colors['white']) if ch.fg!='default' else ''}{'font-weight:bold;' if ch.bold else ''}{'font-style:italic;' if ch.italics else ''}"
+                    if style != old_style:
+                        if old_style:
+                            line += f"<span style={repr(old_style)}>{html.escape(text, quote=True)}</span>"
+                        else:
+                            line += html.escape(text, quote=True)
+                        text = ""
+                        old_style = style
+                    text += ch.data
+                if style:
+                    line += f"<span style={repr(style)}>{html.escape(text, quote=True)}</span>"
+                else:
+                    line += html.escape(text, quote=True)
+                self.output[line_no] = line
+            # fill the text area with HTML contents in one go
+            self.appendHtml(f"<pre>{chr(10).join(self.output)}</pre>")
+            # done updates, all clean
+            screenData.dirty.clear()
+
+            # Activate cursor
+            textCursor = self.textCursor()
+            textCursor.setPosition(0)
+            textCursor.movePosition(QTextCursor.Down, QTextCursor.MoveAnchor, screenData.cursor.y)
+            textCursor.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor, screenData.cursor.x)
+            self.setTextCursor(textCursor)
+            self.ensureCursorVisible()
+
+            # manage scroll
+            if reset_scroll:
+                self.scroll.valueChanged.disconnect(self.scroll_value_change)
+                tmp = len(self.backend.screen.history.top) + len(self.backend.screen.history.bottom)
+                self.scroll.setMaximum(tmp if tmp > 0 else 0)
+                self.scroll.setSliderPosition(len(self.backend.screen.history.top))
+                self.scroll.valueChanged.connect(self.scroll_value_change)
+
+    # def resizeEvent(self, event):
+    #    with self.lock:
+    #        self.numColumns = int(self.width() / self._char_width)
+    #        self.numLines = int(self.height() / self._char_height)
+    #        self.output = [""] * self.numLines
+    #        print("RESIZING TO", self.numColumns, "x", self.numLines)
+    #        self.backend.screen.resize(self.numLines, self.numColumns)
+
+    def wheelEvent(self, event):
+        y = event.angleDelta().y()
+        if y > 0:
+            self.backend.screen.prev_page()
+        else:
+            self.backend.screen.next_page()
+        self.dataReady(self.backend.screen, reset_scroll=False)
+
+    def forkShell(self):
+        """
+        Fork the current process and execute bec in shell.
+        """
+        try:
+            pid, fd = pty.fork()
+        except (IOError, OSError):
+            return False
+        if pid == 0:
+            # Safe way to make it work under BSD and Linux
+            try:
+                ls = os.environ["LANG"].split(".")
+            except KeyError:
+                ls = []
+            if len(ls) < 2:
+                ls = ["en_US", "UTF-8"]
+            try:
+                os.putenv("COLUMNS", str(self.numColumns))
+                os.putenv("LINES", str(self.numLines))
+                os.putenv("TERM", "linux")
+                os.putenv("LANG", ls[0] + ".UTF-8")
+                if isinstance(self._cmd, str):
+                    os.execvp(self._cmd, self._cmd)
+                else:
+                    os.execvp(self._cmd[0], self._cmd)
+                # print "child_pid", child_pid, sts
+            except (IOError, OSError):
+                pass
+            # self.proc_finish(sid)
+            os._exit(0)
+        else:
+            # We are in the parent process.
+            # Set file control
+            fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
+            print("Spawned Bash shell (PID {})".format(pid))
+            return fd
+
+
+if __name__ == "__main__":
+    import os
+    import sys
+
+    from qtpy import QtGui, QtWidgets
+
+    # Terminal size in characters.
+    numLines = 25
+    numColumns = 100
+
+    # Create the Qt application and QBash instance.
+    app = QtWidgets.QApplication([])
+    mainwin = QtWidgets.QMainWindow()
+    title = "BECConsole ({}x{})".format(numColumns, numLines)
+    mainwin.setWindowTitle(title)
+
+    console = BECConsole(mainwin, numColumns, numLines)
+    mainwin.setCentralWidget(console)
+    console.start()
+
+    # Show widget and launch Qt's event loop.
+    mainwin.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/dock/dock.py

@@ -26,8 +26,8 @@ class DockConfig(ConnectionConfig):
 
 class BECDock(BECConnector, Dock):
     USER_ACCESS = [
-        "config_dict",
-        "rpc_id",
+        "_config_dict",
+        "_rpc_id",
         "widget_list",
         "show_title_bar",
         "hide_title_bar",

bec_widgets/widgets/dock/dock_area.py

@@ -23,7 +23,7 @@ class DockAreaConfig(ConnectionConfig):
 
 class BECDockArea(BECConnector, DockArea):
     USER_ACCESS = [
-        "config_dict",
+        "_config_dict",
         "panels",
         "save_state",
         "remove_dock",
@@ -32,7 +32,7 @@ class BECDockArea(BECConnector, DockArea):
         "clear_all",
         "detach_dock",
         "attach_all",
-        "get_all_rpc",
+        "_get_all_rpc",
         "temp_areas",
     ]
 

bec_widgets/widgets/figure/figure.py

@@ -8,7 +8,7 @@ from typing import Literal, Optional
 import numpy as np
 import pyqtgraph as pg
 import qdarktheme
-from pydantic import Field
+from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtWidgets import QWidget
 from typeguard import typechecked
@@ -30,16 +30,36 @@ class FigureConfig(ConnectionConfig):
         {}, description="The list of widgets to be added to the figure widget."
     )
 
+    @field_validator("widgets", mode="before")
+    @classmethod
+    def validate_widgets(cls, v):
+        """Validate the widgets configuration."""
+        widget_class_map = {
+            "BECWaveform": Waveform1DConfig,
+            "BECImageShow": ImageConfig,
+            "BECMotorMap": MotorMapConfig,
+        }
+        validated_widgets = {}
+        for key, widget_config in v.items():
+            if "widget_class" not in widget_config:
+                raise ValueError(f"Widget config for {key} does not contain 'widget_class'.")
+            widget_class = widget_config["widget_class"]
+            if widget_class not in widget_class_map:
+                raise ValueError(f"Unknown widget_class '{widget_class}' for widget '{key}'.")
+            config_class = widget_class_map[widget_class]
+            validated_widgets[key] = config_class(**widget_config)
+        return validated_widgets
+
 
 class WidgetHandler:
     """Factory for creating and configuring BEC widgets for BECFigure."""
 
     def __init__(self):
         self.widget_factory = {
-            "PlotBase": (BECPlotBase, SubplotConfig),
-            "Waveform1D": (BECWaveform, Waveform1DConfig),
-            "ImShow": (BECImageShow, ImageConfig),
-            "MotorMap": (BECMotorMap, MotorMapConfig),
+            "BECPlotBase": (BECPlotBase, SubplotConfig),
+            "BECWaveform": (BECWaveform, Waveform1DConfig),
+            "BECImageShow": (BECImageShow, ImageConfig),
+            "BECMotorMap": (BECMotorMap, MotorMapConfig),
         }
 
     def create_widget(
@@ -90,13 +110,11 @@ class WidgetHandler:
 
 class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
+        "_get_all_rpc",
         "axes",
         "widgets",
-        "add_plot",
-        "add_image",
-        "add_motor_map",
         "plot",
         "image",
         "motor_map",
@@ -104,9 +122,15 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         "change_layout",
         "change_theme",
         "clear_all",
-        "get_all_rpc",
         "widget_list",
     ]
+    subplot_map = {
+        "PlotBase": BECPlotBase,
+        "BECWaveform": BECWaveform,
+        "BECImageShow": BECImageShow,
+        "BECMotorMap": BECMotorMap,
+    }
+    widget_method_map = {"BECWaveform": "plot", "BECImageShow": "image", "BECMotorMap": "motor_map"}
 
     clean_signal = pyqtSignal()
 
@@ -122,8 +146,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         else:
             if isinstance(config, dict):
                 config = FigureConfig(**config)
-            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
+        super().__init__(client=client, gui_id=gui_id)
         pg.GraphicsLayoutWidget.__init__(self, parent)
 
         self.widget_handler = WidgetHandler()
@@ -133,6 +156,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         # Container to keep track of the grid
         self.grid = []
+        # Create config and apply it
+        self.apply_config(config)
 
     def __getitem__(self, key: tuple | str):
         if isinstance(key, tuple) and len(key) == 2:
@@ -147,6 +172,24 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
                 "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
             )
 
+    def apply_config(self, config: dict | FigureConfig):  # ,generate_new_id: bool = False):
+        if isinstance(config, dict):
+            try:
+                config = FigureConfig(**config)
+            except ValidationError as e:
+                print(f"Error in applying config: {e}")
+                return
+        self.config = config
+        self.change_theme(self.config.theme)
+
+        # widget_config has to be reset for not have each widget config twice when added to the figure
+        widget_configs = [config for config in self.config.widgets.values()]
+        self.config.widgets = {}
+        for widget_config in widget_configs:
+            getattr(self, self.widget_method_map[widget_config.widget_class])(
+                config=widget_config.model_dump(), row=widget_config.row, col=widget_config.col
+            )
+
     @property
     def widget_list(self) -> list[BECPlotBase]:
         """
@@ -200,7 +243,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         label: str | None = None,
         validate: bool = True,
         dap: str | None = None,
-    ):
+    ) -> BECWaveform:
         """
         Configure the waveform based on the provided parameters.
 
@@ -279,75 +322,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         return waveform
 
-    def add_plot(
-        self,
-        x: list | np.ndarray = None,
-        y: list | np.ndarray = None,
-        x_name: str = None,
-        y_name: str = None,
-        z_name: str = None,
-        x_entry: str = None,
-        y_entry: str = None,
-        z_entry: str = None,
-        color: Optional[str] = None,
-        color_map_z: Optional[str] = "plasma",
-        label: Optional[str] = None,
-        validate: bool = True,
-        row: int = None,
-        col: int = None,
-        config=None,
-        dap: str | None = None,
-        **axis_kwargs,
-    ) -> BECWaveform:
-        """
-        Add a Waveform1D plot to the figure at the specified position.
-
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
-        """
-        widget_id = str(uuid.uuid4())
-        waveform = self.add_widget(
-            widget_type="Waveform1D",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
-
-        waveform = self._init_waveform(
-            waveform=waveform,
-            x=x,
-            y=y,
-            x_name=x_name,
-            y_name=y_name,
-            z_name=z_name,
-            x_entry=x_entry,
-            y_entry=y_entry,
-            z_entry=z_entry,
-            color=color,
-            color_map_z=color_map_z,
-            label=label,
-            validate=validate,
-            dap=dap,
-        )
-        return waveform
-
     @typechecked
     def plot(
         self,
@@ -363,7 +337,11 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         color_map_z: str | None = "plasma",
         label: str | None = None,
         validate: bool = True,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
         dap: str | None = None,
+        config: dict | None = None,  # TODO make logic more transparent
         **axis_kwargs,
     ) -> BECWaveform:
         """
@@ -382,21 +360,23 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             color_map_z(str): The color map to use for the z-axis.
             label(str): The label of the curve.
             validate(bool): If True, validate the device names and entries.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
             dap(str): The DAP model to use for the curve.
+            config(dict): Recreates the whole BECWaveform widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
             BECWaveform: The waveform plot widget.
         """
-        waveform = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECWaveform, can_fail=True
+        waveform = self.subplot_factory(
+            widget_type="BECWaveform", config=config, row=row, col=col, new=new, **axis_kwargs
         )
-        if waveform is not None:
-            if axis_kwargs:
-                waveform.set(**axis_kwargs)
-        else:
-            waveform = self.add_plot(**axis_kwargs)
+        if config is not None:
+            return waveform
 
+        # Passing args to init_waveform
         waveform = self._init_waveform(
             waveform=waveform,
             x=x,
@@ -413,7 +393,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             validate=validate,
             dap=dap,
         )
-        # TODO remove repetition from .plot method
         return waveform
 
     def _init_image(
@@ -460,6 +439,10 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         color_map: str = "magma",
         data: np.ndarray = None,
         vrange: tuple[float, float] = None,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        config: dict | None = None,
         **axis_kwargs,
     ) -> BECImageShow:
         """
@@ -471,78 +454,22 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             color_map(str): The color map to use for the image.
             data(np.ndarray): Custom data to display.
             vrange(tuple[float, float]): The range of values to display.
-            **axis_kwargs: Additional axis properties to set on the widget after creation.
-
-        Returns:
-            BECImageShow: The image widget.
-        """
-        image = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECImageShow, can_fail=True
-        )
-        if image is not None:
-            if axis_kwargs:
-                image.set(**axis_kwargs)
-        else:
-            image = self.add_image(color_bar=color_bar, **axis_kwargs)
-
-        image = self._init_image(
-            image=image,
-            monitor=monitor,
-            color_bar=color_bar,
-            color_map=color_map,
-            data=data,
-            vrange=vrange,
-        )
-        return image
-
-    def add_image(
-        self,
-        monitor: str = None,
-        color_bar: Literal["simple", "full"] = "full",
-        color_map: str = "magma",
-        data: np.ndarray = None,
-        vrange: tuple[float, float] = None,
-        row: int = None,
-        col: int = None,
-        config=None,
-        **axis_kwargs,
-    ) -> BECImageShow:
-        """
-        Add an image to the figure at the specified position.
-
-        Args:
-            monitor(str): The name of the monitor to display.
-            color_bar(Literal["simple","full"]): The type of color bar to display.
-            color_map(str): The color map to use for the image.
-            data(np.ndarray): Custom data to display.
-            vrange(tuple[float, float]): The range of values to display.
+            new(bool): If True, create a new plot instead of using the first plot.
             row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
             col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
             BECImageShow: The image widget.
         """
 
-        widget_id = str(uuid.uuid4())
-        if config is None:
-            config = ImageConfig(
-                widget_class="BECImageShow",
-                gui_id=widget_id,
-                parent_id=self.gui_id,
-                color_map=color_map,
-                color_bar=color_bar,
-                vrange=vrange,
-            )
-        image = self.add_widget(
-            widget_type="ImShow",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
+        image = self.subplot_factory(
+            widget_type="BECImageShow", config=config, row=row, col=col, new=new, **axis_kwargs
         )
+        if config is not None:
+            return image
+
         image = self._init_image(
             image=image,
             monitor=monitor,
@@ -553,76 +480,99 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         )
         return image
 
-    def motor_map(self, motor_x: str = None, motor_y: str = None, **axis_kwargs) -> BECMotorMap:
+    def motor_map(
+        self,
+        motor_x: str = None,
+        motor_y: str = None,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        config: dict | None = None,
+        **axis_kwargs,
+    ) -> BECMotorMap:
         """
         Add a motor map to the figure. Always access the first motor map widget in the figure.
 
         Args:
             motor_x(str): The name of the motor for the X axis.
             motor_y(str): The name of the motor for the Y axis.
+            new(bool): If True, create a new plot instead of using the first plot.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Recreates the whole BECImageShow widget from provided configuration.
             **axis_kwargs: Additional axis properties to set on the widget after creation.
 
         Returns:
             BECMotorMap: The motor map widget.
         """
-        motor_map = WidgetContainerUtils.find_first_widget_by_class(
-            self._widgets, BECMotorMap, can_fail=True
+        motor_map = self.subplot_factory(
+            widget_type="BECMotorMap", config=config, row=row, col=col, new=new, **axis_kwargs
         )
-        if motor_map is not None:
-            if axis_kwargs:
-                motor_map.set(**axis_kwargs)
-        else:
-            motor_map = self.add_motor_map(**axis_kwargs)
+        if config is not None:
+            return motor_map
 
         if motor_x is not None and motor_y is not None:
             motor_map.change_motors(motor_x, motor_y)
 
         return motor_map
 
-    def add_motor_map(
+    def subplot_factory(
         self,
-        motor_x: str = None,
-        motor_y: str = None,
+        widget_type: Literal[
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+        ] = "BECPlotBase",
         row: int = None,
         col: int = None,
         config=None,
+        new: bool = False,
         **axis_kwargs,
-    ) -> BECMotorMap:
-        """
-
-        Args:
-            motor_x(str): The name of the motor for the X axis.
-            motor_y(str): The name of the motor for the Y axis.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs:
-
-        Returns:
-            BECMotorMap: The motor map widget.
-        """
-        widget_id = str(uuid.uuid4())
-        if config is None:
-            config = MotorMapConfig(
-                widget_class="BECMotorMap", gui_id=widget_id, parent_id=self.gui_id
+    ) -> BECPlotBase:
+        # Case 1 - config provided, new plot, possible to define coordinates
+        if config is not None:
+            widget_cls = config["widget_class"]
+            if widget_cls != widget_type:
+                raise ValueError(
+                    f"Widget type '{widget_type}' does not match the provided configuration ({widget_cls})."
+                )
+            widget = self.add_widget(
+                widget_type=widget_type, config=config, row=row, col=col, **axis_kwargs
             )
-        motor_map = self.add_widget(
-            widget_type="MotorMap",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
+            return widget
 
-        if motor_x is not None and motor_y is not None:
-            motor_map.change_motors(motor_x, motor_y)
+        # Case 2 - find first plot or create first plot if no plot available, no config provided, no coordinates
+        if new is False and (row is None or col is None):
+            widget = WidgetContainerUtils.find_first_widget_by_class(
+                self._widgets, self.subplot_map[widget_type], can_fail=True
+            )
+            if widget is not None:
+                if axis_kwargs:
+                    widget.set(**axis_kwargs)
+            else:
+                widget = self.add_widget(widget_type=widget_type, **axis_kwargs)
+            return widget
 
-        return motor_map
+        # Case 3 - modifying existing plot wit coordinates provided
+        if new is False and (row is not None and col is not None):
+            try:
+                widget = self.axes(row, col)
+            except ValueError:
+                widget = None
+            if widget is not None:
+                if axis_kwargs:
+                    widget.set(**axis_kwargs)
+            else:
+                widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
+            return widget
+
+        # Case 4 - no previous plot or new plot, no config provided, possible to define coordinates
+        widget = self.add_widget(widget_type=widget_type, row=row, col=col, **axis_kwargs)
+        return widget
 
     def add_widget(
         self,
-        widget_type: Literal["PlotBase", "Waveform1D", "ImShow"] = "PlotBase",
+        widget_type: Literal[
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+        ] = "BECPlotBase",
         widget_id: str = None,
         row: int = None,
         col: int = None,
@@ -653,6 +603,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             config=config,
             **axis_kwargs,
         )
+        # has to be changed manually to ensure unique id, if config is copied from existing widget, the id could be
+        # used otherwise multiple times
+        widget.set_gui_id(widget_id)
 
         # Check if position is occupied
         if row is not None and col is not None:
@@ -756,6 +709,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             self._reindex_grid()
             if widget_id in self.config.widgets:
                 self.config.widgets.pop(widget_id)
+            widget.deleteLater()
         else:
             raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
 

bec_widgets/widgets/figure/plots/image/image.py

@@ -5,7 +5,7 @@ from typing import Any, Literal, Optional
 
 import numpy as np
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field, ValidationError
+from pydantic import BaseModel, Field, ValidationError
 from qtpy.QtCore import QThread
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
@@ -29,11 +29,9 @@ class ImageConfig(SubplotConfig):
 
 class BECImageShow(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "add_image_by_config",
-        "get_image_config",
-        "get_image_dict",
         "add_monitor_image",
         "add_custom_image",
         "set_vrange",
@@ -47,7 +45,6 @@ class BECImageShow(BECPlotBase):
         "set_log",
         "set_rotation",
         "set_transpose",
-        "toggle_threading",
         "set",
         "set_title",
         "set_x_label",
@@ -138,7 +135,8 @@ class BECImageShow(BECPlotBase):
         self.apply_axis_config()
         self._images = defaultdict(dict)
 
-        # TODO extend by adding image by config
+        for image_id, image_config in config.images.items():
+            self.add_image_by_config(image_config)
 
     def change_gui_id(self, new_gui_id: str):
         """
@@ -226,7 +224,7 @@ class BECImageShow(BECPlotBase):
         self,
         monitor: str,
         color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
         opacity: Optional[float] = 1.0,
         vrange: Optional[tuple[int, int]] = None,
@@ -241,7 +239,7 @@ class BECImageShow(BECPlotBase):
                 f"Monitor with ID '{monitor}' already exists in widget '{self.gui_id}'."
             )
 
-        monitor = self.entry_validator.validate_monitor(monitor)
+        # monitor = self.entry_validator.validate_monitor(monitor)
 
         image_config = ImageItemConfig(
             widget_class="BECImageItem",
@@ -251,12 +249,13 @@ class BECImageShow(BECPlotBase):
             downsample=downsample,
             opacity=opacity,
             vrange=vrange,
+            source=image_source,
+            monitor=monitor,
             # post_processing=post_processing,
             **kwargs,
         )
 
         image = self._add_image_object(source=image_source, name=monitor, config=image_config)
-        self._connect_device_monitor(monitor)
         return image
 
     def add_custom_image(
@@ -264,16 +263,17 @@ class BECImageShow(BECPlotBase):
         name: str,
         data: Optional[np.ndarray] = None,
         color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
         opacity: Optional[float] = 1.0,
         vrange: Optional[tuple[int, int]] = None,
         # post_processing: Optional[PostProcessingConfig] = None,
         **kwargs,
     ):
-        image_source = "device_monitor"
+        image_source = "custom"
+        # image_source = "device_monitor"
 
-        image_exits = self._check_curve_id(name, self._images)
+        image_exits = self._check_image_id(name, self._images)
         if image_exits:
             raise ValueError(f"Monitor with ID '{name}' already exists in widget '{self.gui_id}'.")
 
@@ -290,7 +290,9 @@ class BECImageShow(BECPlotBase):
             **kwargs,
         )
 
-        image = self._add_image_object(source=image_source, config=image_config, data=data)
+        image = self._add_image_object(
+            source=image_source, name=name, config=image_config, data=data
+        )
         return image
 
     def apply_setting_to_images(
@@ -313,6 +315,7 @@ class BECImageShow(BECPlotBase):
             for source, images in self._images.items():
                 for _, image in images.items():
                     getattr(image, setting_method_name)(*args, **kwargs)
+        self.refresh_image()
 
     def set_vrange(self, vmin: float, vmax: float, name: str = None):
         """
@@ -460,6 +463,27 @@ class BECImageShow(BECPlotBase):
         if self.use_threading is False and self.thread.isRunning():
             self.cleanup()
 
+    def process_image(self, device: str, image: BECImageItem, data: np.ndarray):
+        """
+        Process the image data.
+
+        Args:
+            device(str): The name of the device - image_id of image.
+            image(np.ndarray): The image data to be processed.
+            data(np.ndarray): The image data to be processed.
+
+        Returns:
+            np.ndarray: The processed image data.
+        """
+        processing_config = image.config.processing
+        self.processor.set_config(processing_config)
+        if self.use_threading:
+            self._create_thread_worker(device, data)
+        else:
+            data = self.processor.process_image(data)
+            self.update_image(device, data)
+            self.update_vrange(device, self.processor.config.stats)
+
     @pyqtSlot(dict)
     def on_image_update(self, msg: dict):
         """
@@ -470,15 +494,8 @@ class BECImageShow(BECPlotBase):
         """
         data = msg["data"]
         device = msg["device"]
-        image_to_update = self._images["device_monitor"][device]
-        processing_config = image_to_update.config.processing
-        self.processor.set_config(processing_config)
-        if self.use_threading:
-            self._create_thread_worker(device, data)
-        else:
-            data = self.processor.process_image(data)
-            self.update_image(device, data)
-            self.update_vrange(device, self.processor.config.stats)
+        image = self._images["device_monitor"][device]
+        self.process_image(device, image, data)
 
     @pyqtSlot(str, np.ndarray)
     def update_image(self, device: str, data: np.ndarray):
@@ -504,6 +521,15 @@ class BECImageShow(BECPlotBase):
         if image_to_update.config.autorange:
             image_to_update.auto_update_vrange(stats)
 
+    def refresh_image(self):
+        """
+        Refresh the image.
+        """
+        for source, images in self._images.items():
+            for image_id, image in images.items():
+                data = image.get_data()
+                self.process_image(image_id, image, data)
+
     def _connect_device_monitor(self, monitor: str):
         """
         Connect to the device monitor.
@@ -516,16 +542,18 @@ class BECImageShow(BECPlotBase):
             previous_monitor = image_item.config.monitor
         except AttributeError:
             previous_monitor = None
-        if previous_monitor != monitor:
-            if previous_monitor:
-                self.bec_dispatcher.disconnect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
-                )
-            if monitor:
-                self.bec_dispatcher.connect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(monitor)
-                )
-                image_item.set_monitor(monitor)
+        if previous_monitor and image_item.connected is True:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
+            )
+            image_item.connected = False
+        if monitor and image_item.connected is False:
+            self.entry_validator.validate_monitor(monitor)
+            self.bec_dispatcher.connect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(monitor)
+            )
+            image_item.set_monitor(monitor)
+            image_item.connected = True
 
     def _add_image_object(
         self, source: str, name: str, config: ImageItemConfig, data=None
@@ -534,6 +562,8 @@ class BECImageShow(BECPlotBase):
         image = BECImageItem(config=config, parent_image=self)
         self.plot_item.addItem(image)
         self._images[source][name] = image
+        if source == "device_monitor":
+            self._connect_device_monitor(config.monitor)
         self.config.images[name] = config
         if data is not None:
             image.setImage(data)
@@ -558,23 +588,6 @@ class BECImageShow(BECPlotBase):
                     return True
         return False
 
-    def _validate_monitor(self, monitor: str, validate_bec: bool = True):
-        """
-        Validate the monitor name.
-
-        Args:
-            monitor(str): The name of the monitor.
-            validate_bec(bool): Whether to validate the monitor name with BEC.
-
-        Returns:
-            bool: True if the monitor name is valid, False otherwise.
-        """
-        if not monitor or monitor == "":
-            return False
-        if validate_bec:
-            return monitor in self.dev
-        return True
-
     def cleanup(self):
         """
         Clean up the widget.

bec_widgets/widgets/figure/plots/image/image_item.py

@@ -20,7 +20,7 @@ class ImageItemConfig(ConnectionConfig):
     color_map: Optional[str] = Field("magma", description="The color map of the image.")
     downsample: Optional[bool] = Field(True, description="Whether to downsample the image.")
     opacity: Optional[float] = Field(1.0, description="The opacity of the image.")
-    vrange: Optional[tuple[float, float]] = Field(
+    vrange: Optional[tuple[float | int, float | int]] = Field(
         None, description="The range of the color bar. If None, the range is automatically set."
     )
     color_bar: Optional[Literal["simple", "full"]] = Field(
@@ -37,8 +37,8 @@ class ImageItemConfig(ConnectionConfig):
 
 class BECImageItem(BECConnector, pg.ImageItem):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "set",
         "set_fft",
         "set_log",
@@ -78,6 +78,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
         self.apply_config()
         if kwargs:
             self.set(**kwargs)
+        self.connected = False
 
     def apply_config(self):
         """

bec_widgets/widgets/figure/plots/motor_map/motor_map.py

@@ -6,22 +6,23 @@ from typing import Optional, Union
 import numpy as np
 import pyqtgraph as pg
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field
+from pydantic import Field, ValidationError, field_validator
+from pydantic_core import PydanticCustomError
 from qtpy import QtCore, QtGui
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.utils import EntryValidator
+from bec_widgets.utils import Colors, EntryValidator
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform import Signal, SignalData
 
 
 class MotorMapConfig(SubplotConfig):
     signals: Optional[Signal] = Field(None, description="Signals of the motor map")
-    color_map: Optional[str] = Field(
-        "Greys", description="Color scheme of the motor position gradient."
-    )  # TODO decide if useful for anything, or just keep GREYS always
+    color: Optional[str | tuple] = Field(
+        (255, 255, 255, 255), description="The color of the last point of current position."
+    )
     scatter_size: Optional[int] = Field(5, description="Size of the scatter points.")
     max_points: Optional[int] = Field(1000, description="Maximum number of points to display.")
     num_dim_points: Optional[int] = Field(
@@ -30,14 +31,26 @@ class MotorMapConfig(SubplotConfig):
     )
     precision: Optional[int] = Field(2, description="Decimal precision of the motor position.")
     background_value: Optional[int] = Field(
-        25, description="Background value of the motor map."
-    )  # TODO can be percentage from 255 calculated
+        25, description="Background value of the motor map. Has to be between 0 and 255."
+    )
+
+    model_config: dict = {"validate_assignment": True}
+
+    _validate_color = field_validator("color")(Colors.validate_color)
+
+    @field_validator("background_value")
+    def validate_background_value(cls, value):
+        if not 0 <= value <= 255:
+            raise PydanticCustomError(
+                "wrong_value", f"'{value}' hs to be between 0 and 255.", {"wrong_value": value}
+            )
+        return value
 
 
 class BECMotorMap(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "change_motors",
         "set_max_points",
         "set_precision",
@@ -69,29 +82,43 @@ class BECMotorMap(BECPlotBase):
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)
 
+        # connect update signal to update plot
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self._update_plot
+        )
+        self.apply_config(self.config)
+
+    def apply_config(self, config: dict | MotorMapConfig):
+        """
+        Apply the config to the motor map.
+
+        Args:
+            config(dict|MotorMapConfig): Config to be applied.
+        """
+        if isinstance(config, dict):
+            try:
+                config = MotorMapConfig(**config)
+            except ValidationError as e:
+                print(f"Error in applying config: {e}")
+                return
+
+        self.config = config
+        self.plot_item.clear()
+
         self.motor_x = None
         self.motor_y = None
         self.database_buffer = {"x": [], "y": []}
         self.plot_components = defaultdict(dict)  # container for plot components
 
-        # connect update signal to update plot
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self._update_plot
-        )
+        self.apply_axis_config()
 
-    # TODO decide if needed to implement, maybe there will be no children widgets for motormap for now...
-    # def find_widget_by_id(self, item_id: str) -> BECCurve:
-    #     """
-    #     Find the curve by its ID.
-    #     Args:
-    #         item_id(str): ID of the curve.
-    #
-    #     Returns:
-    #         BECCurve: The curve object.
-    #     """
-    #     for curve in self.plot_item.curves:
-    #         if curve.gui_id == item_id:
-    #             return curve
+        if self.config.signals is not None:
+            self.change_motors(
+                motor_x=self.config.signals.x.name,
+                motor_y=self.config.signals.y.name,
+                motor_x_entry=self.config.signals.x.entry,
+                motor_y_entry=self.config.signals.y.entry,
+            )
 
     @pyqtSlot(str, str, str, str, bool)
     def change_motors(
@@ -129,6 +156,8 @@ class BECMotorMap(BECPlotBase):
         # reconnect the signals
         self._connect_motor_to_slots()
 
+        self.database_buffer = {"x": [], "y": []}
+
         # Redraw the motor map
         self._make_motor_map()
 
@@ -141,7 +170,19 @@ class BECMotorMap(BECPlotBase):
         data = {"x": self.database_buffer["x"], "y": self.database_buffer["y"]}
         return data
 
-    # TODO setup all visual properties
+    def set_color(self, color: [str | tuple]):
+        """
+        Set color of the motor trace.
+
+        Args:
+            color(str|tuple): Color of the motor trace. Can be HEX(str) or RGBA(tuple).
+        """
+        if isinstance(color, str):
+            color = Colors.validate_color(color)
+            color = Colors.hex_to_rgba(color, 255)
+        self.config.color = color
+        self.update_signal.emit()
+
     def set_max_points(self, max_points: int) -> None:
         """
         Set the maximum number of points to display.
@@ -150,6 +191,7 @@ class BECMotorMap(BECPlotBase):
             max_points(int): Maximum number of points to display.
         """
         self.config.max_points = max_points
+        self.update_signal.emit()
 
     def set_precision(self, precision: int) -> None:
         """
@@ -159,6 +201,7 @@ class BECMotorMap(BECPlotBase):
             precision(int): Decimal precision of the motor position.
         """
         self.config.precision = precision
+        self.update_signal.emit()
 
     def set_num_dim_points(self, num_dim_points: int) -> None:
         """
@@ -168,6 +211,7 @@ class BECMotorMap(BECPlotBase):
             num_dim_points(int): Number of dim points.
         """
         self.config.num_dim_points = num_dim_points
+        self.update_signal.emit()
 
     def set_background_value(self, background_value: int) -> None:
         """
@@ -177,6 +221,7 @@ class BECMotorMap(BECPlotBase):
             background_value(int): Background value of the motor map.
         """
         self.config.background_value = background_value
+        self._swap_limit_map()
 
     def set_scatter_size(self, scatter_size: int) -> None:
         """
@@ -186,6 +231,7 @@ class BECMotorMap(BECPlotBase):
             scatter_size(int): Size of the scatter points.
         """
         self.config.scatter_size = scatter_size
+        self.update_signal.emit()
 
     def _disconnect_current_motors(self):
         """Disconnect the current motors from the slots."""
@@ -210,6 +256,15 @@ class BECMotorMap(BECPlotBase):
 
         self.bec_dispatcher.connect_slot(self.on_device_readback, endpoints)
 
+    def _swap_limit_map(self):
+        """Swap the limit map."""
+        self.plot_item.removeItem(self.plot_components["limit_map"])
+        self.plot_components["limit_map"] = self._make_limit_map(
+            self.config.signals.x.limits, self.config.signals.y.limits
+        )
+        self.plot_components["limit_map"].setZValue(-1)
+        self.plot_item.addItem(self.plot_components["limit_map"])
+
     def _make_motor_map(self):
         """
         Create the motor map plot.
@@ -249,6 +304,8 @@ class BECMotorMap(BECPlotBase):
         # Set default labels for the plot
         self.set(x_label=f"Motor X ({self.motor_x})", y_label=f"Motor Y ({self.motor_y})")
 
+        self.update_signal.emit()
+
     def _add_coordinantes_crosshair(self, x: float, y: float) -> None:
         """
         Add crosshair to the plot to highlight the current position.
@@ -373,19 +430,31 @@ class BECMotorMap(BECPlotBase):
 
     def _update_plot(self):
         """Update the motor map plot."""
+        # If the number of points exceeds max_points, delete the oldest points
+        if len(self.database_buffer["x"]) > self.config.max_points:
+            self.database_buffer["x"] = self.database_buffer["x"][-self.config.max_points :]
+            self.database_buffer["y"] = self.database_buffer["y"][-self.config.max_points :]
+
         x = self.database_buffer["x"]
         y = self.database_buffer["y"]
 
         # Setup gradient brush for history
         brushes = [pg.mkBrush(50, 50, 50, 255)] * len(x)
 
+        # RGB color
+        r, g, b, a = self.config.color
+
         # Calculate the decrement step based on self.num_dim_points
         num_dim_points = self.config.num_dim_points
         decrement_step = (255 - 50) / num_dim_points
+
         for i in range(1, min(num_dim_points + 1, len(x) + 1)):
             brightness = max(60, 255 - decrement_step * (i - 1))
-            brushes[-i] = pg.mkBrush(brightness, brightness, brightness, 255)
-        brushes[-1] = pg.mkBrush(255, 255, 255, 255)  # Newest point is always full brightness
+            dim_r = int(r * (brightness / 255))
+            dim_g = int(g * (brightness / 255))
+            dim_b = int(b * (brightness / 255))
+            brushes[-i] = pg.mkBrush(dim_r, dim_g, dim_b, a)
+        brushes[-1] = pg.mkBrush(r, g, b, a)  # Newest point is always full brightness
         scatter_size = self.config.scatter_size
 
         # Update the scatter plot

bec_widgets/widgets/figure/plots/plot_base.py

@@ -46,7 +46,7 @@ class SubplotConfig(ConnectionConfig):
 
 class BECPlotBase(BECConnector, pg.GraphicsLayout):
     USER_ACCESS = [
-        "config_dict",
+        "_config_dict",
         "set",
         "set_title",
         "set_x_label",

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -35,8 +35,8 @@ class Waveform1DConfig(SubplotConfig):
 
 class BECWaveform(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "plot",
         "add_dap",
         "get_dap_params",
@@ -44,8 +44,6 @@ class BECWaveform(BECPlotBase):
         "scan_history",
         "curves",
         "get_curve",
-        "get_curve_config",
-        "apply_config",
         "get_all_data",
         "set",
         "set_title",
@@ -705,14 +703,15 @@ class BECWaveform(BECPlotBase):
                 data_y = data[y_name][y_entry].val
                 if curve.config.signals.z:
                     data_z = data[z_name][z_entry].val
-                    color_z = self._make_z_gradient(
-                        data_z, curve.config.color_map_z
-                    )  # TODO decide how to implement custom gradient
+                    color_z = self._make_z_gradient(data_z, curve.config.color_map_z)
             except TypeError:
                 continue
 
             if data_z is not None and color_z is not None:
-                curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                try:
+                    curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                except:
+                    return
             else:
                 curve.setData(data_x, data_y)
 

bec_widgets/widgets/figure/plots/waveform/waveform_curve.py

@@ -65,8 +65,8 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     USER_ACCESS = [
         "remove",
         "dap_params",
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "set",
         "set_data",
         "set_color",

bec_widgets/widgets/ring_progress_bar/ring.py

@@ -79,9 +79,9 @@ class RingConfig(ProgressbarConfig):
 
 class Ring(BECConnector):
     USER_ACCESS = [
-        "get_all_rpc",
-        "rpc_id",
-        "config_dict",
+        "_get_all_rpc",
+        "_rpc_id",
+        "_config_dict",
         "set_value",
         "set_color",
         "set_background",

bec_widgets/widgets/ring_progress_bar/ring_progress_bar.py

@@ -68,9 +68,9 @@ class RingProgressBarConfig(ConnectionConfig):
 
 class RingProgressBar(BECConnector, QWidget):
     USER_ACCESS = [
-        "get_all_rpc",
-        "rpc_id",
-        "config_dict",
+        "_get_all_rpc",
+        "_rpc_id",
+        "_config_dict",
         "rings",
         "update_config",
         "add_ring",
@@ -104,7 +104,7 @@ class RingProgressBar(BECConnector, QWidget):
                 config = RingProgressBarConfig(**config, widget_class=self.__class__.__name__)
             self.config = config
         super().__init__(client=client, config=config, gui_id=gui_id)
-        QWidget.__init__(self, parent=None)
+        QWidget.__init__(self, parent=parent)
 
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)

bec_widgets/widgets/text_box/text_box.py

@@ -31,7 +31,7 @@ class TextBox(BECConnector, QTextEdit):
 
     USER_ACCESS = ["set_color", "set_text", "set_font_size"]
 
-    def __init__(self, text: str = "", parent=None, client=None, config=None, gui_id=None):
+    def __init__(self, parent=None, text: str = "", client=None, config=None, gui_id=None):
         if config is None:
             config = TextBoxConfig(widget_class=self.__class__.__name__)
         else:

bec_widgets/widgets/website/website.py

@@ -21,7 +21,7 @@ class WebsiteWidget(BECConnector, QWebEngineView):
 
     USER_ACCESS = ["set_url", "get_url", "reload", "back", "forward"]
 
-    def __init__(self, url: str = None, parent=None, config=None, client=None, gui_id=None):
+    def __init__(self, parent=None, url: str = None, config=None, client=None, gui_id=None):
         super().__init__(client=client, config=config, gui_id=gui_id)
         QWebEngineView.__init__(self, parent=parent)
         self.set_url(url)

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "0.74.1"
+version = "0.78.0"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -22,6 +22,7 @@ dependencies = [
     "pyqtdarktheme~=2.1",
     "qtconsole~=5.5, >=5.5.1",  # needed for jupyter console
     "qtpy~=2.4",
+    "pyte",                     # needed for vt100 console
 ]
 
 

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -23,14 +23,14 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
     d1 = dock.add_dock("dock_1")
     d2 = dock.add_dock("dock_2")
 
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     # Add 3 figures with some widgets
     fig0 = d0.add_widget("BECFigure")
     fig1 = d1.add_widget("BECFigure")
     fig2 = d2.add_widget("BECFigure")
 
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     assert len(dock_config["docks"]["dock_0"]["widgets"]) == 1
     assert len(dock_config["docks"]["dock_1"]["widgets"]) == 1
@@ -52,7 +52,7 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
     assert im.__class__.__name__ == "BECImageShow"
     assert im.__class__ == BECImageShow
 
-    assert mm.config_dict["signals"] == {
+    assert mm._config_dict["signals"] == {
         "dap": None,
         "source": "device_readback",
         "x": {
@@ -71,14 +71,14 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
         },
         "z": None,
     }
-    assert plt.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+    assert plt._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
         "dap": None,
         "source": "scan_segment",
         "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
         "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
         "z": None,
     }
-    assert im.config_dict["images"]["eiger"]["monitor"] == "eiger"
+    assert im._config_dict["images"]["eiger"]["monitor"] == "eiger"
 
     # check initial position of motor map
     initial_pos_x = dev.samx.read()["samx"]["value"]
@@ -126,29 +126,29 @@ def test_dock_manipulations_e2e(rpc_server_dock):
     d0 = dock.add_dock("dock_0")
     d1 = dock.add_dock("dock_1")
     d2 = dock.add_dock("dock_2")
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
 
     d0.detach()
     dock.detach_dock("dock_2")
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     assert len(dock.temp_areas) == 2
 
     d0.attach()
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 3
     assert len(dock.temp_areas) == 1
 
     d2.remove()
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 2
 
     assert ["dock_0", "dock_1"] == list(dock_config["docks"])
 
     dock.clear_all()
 
-    dock_config = dock.config_dict
+    dock_config = dock._config_dict
     assert len(dock_config["docks"]) == 0
     assert len(dock.temp_areas) == 0
 
@@ -165,11 +165,11 @@ def test_ring_bar(rpc_server_dock):
     bar.set_colors_from_map("viridis")
     bar.set_value([10, 20, 30, 40, 50])
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
 
     expected_colors = [list(color) for color in Colors.golden_angle_color("viridis", 5, "RGB")]
-    bar_colors = [ring.config_dict["color"] for ring in bar.rings]
-    bar_values = [ring.config_dict["value"] for ring in bar.rings]
+    bar_colors = [ring._config_dict["color"] for ring in bar.rings]
+    bar_values = [ring._config_dict["value"] for ring in bar.rings]
     assert bar_config["num_bars"] == 5
     assert bar_values == [10, 20, 30, 40, 50]
     assert bar_colors == expected_colors
@@ -191,7 +191,7 @@ def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
     status.wait()
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
     assert bar_config["num_bars"] == 1
     assert bar_config["rings"][0]["value"] == 10
     assert bar_config["rings"][0]["min_value"] == 0
@@ -200,7 +200,7 @@ def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
     status = scans.grid_scan(dev.samx, -5, 5, 4, dev.samy, -10, 10, 4, relative=True, exp_time=0.1)
     status.wait()
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
     assert bar_config["num_bars"] == 1
     assert bar_config["rings"][0]["value"] == 16
     assert bar_config["rings"][0]["min_value"] == 0
@@ -217,7 +217,7 @@ def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
     status = scans.umv(dev.samx, 5, dev.samy, 10, relative=True)
     status.wait()
 
-    bar_config = bar.config_dict
+    bar_config = bar._config_dict
     assert bar_config["num_bars"] == 2
     assert bar_config["rings"][0]["value"] == final_samx
     assert bar_config["rings"][1]["value"] == final_samy

tests/end-2-end/test_bec_figure_rpc_e2e.py

@@ -10,14 +10,14 @@ from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWave
 def test_rpc_waveform1d_custom_curve(rpc_server_figure):
     fig = BECFigure(rpc_server_figure)
 
-    ax = fig.add_plot()
+    ax = fig.plot()
     curve = ax.plot(x=[1, 2, 3], y=[1, 2, 3])
     curve.set_color("red")
     curve = ax.curves[0]
     curve.set_color("blue")
 
     assert len(fig.widgets) == 1
-    assert len(fig.widgets[ax.rpc_id].curves) == 1
+    assert len(fig.widgets[ax._rpc_id].curves) == 1
 
 
 def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
@@ -26,7 +26,7 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")
     motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.add_plot(x_name="samx", y_name="samy", z_name="bpm4i")
+    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
 
     # Checking if classes are correctly initialised
     assert len(fig.widgets) == 4
@@ -39,7 +39,7 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
 
     # check if the correct devices are set
     # plot
-    assert plt.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+    assert plt._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
         "dap": None,
         "source": "scan_segment",
         "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
@@ -47,9 +47,9 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
         "z": None,
     }
     # image
-    assert im.config_dict["images"]["eiger"]["monitor"] == "eiger"
+    assert im._config_dict["images"]["eiger"]["monitor"] == "eiger"
     # motor map
-    assert motor_map.config_dict["signals"] == {
+    assert motor_map._config_dict["signals"] == {
         "dap": None,
         "source": "device_readback",
         "x": {
@@ -69,7 +69,7 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
         "z": None,
     }
     # plot with z scatter
-    assert plt_z.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+    assert plt_z._config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
         "dap": None,
         "source": "scan_segment",
         "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},

tests/end-2-end/test_rpc_register_e2e.py

@@ -9,24 +9,24 @@ def test_rpc_register_list_connections(rpc_server_figure):
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")
     motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.add_plot(x_name="samx", y_name="samy", z_name="bpm4i")
+    plt_z = fig.plot(x_name="samx", y_name="samy", z_name="bpm4i", new=True)
 
     # keep only class names from objects, since objects on server and client are different
     # so the best we can do is to compare types (rpc register is unit-tested elsewhere)
-    all_connections = {obj_id: type(obj).__name__ for obj_id, obj in fig.get_all_rpc().items()}
+    all_connections = {obj_id: type(obj).__name__ for obj_id, obj in fig._get_all_rpc().items()}
 
     all_subwidgets_expected = {wid: type(widget).__name__ for wid, widget in fig.widgets.items()}
-    curve_1D = fig.widgets[plt.rpc_id]
-    curve_2D = fig.widgets[plt_z.rpc_id]
+    curve_1D = fig.widgets[plt._rpc_id]
+    curve_2D = fig.widgets[plt_z._rpc_id]
     curves_expected = {
-        curve_1D.rpc_id: type(curve_1D).__name__,
-        curve_2D.rpc_id: type(curve_2D).__name__,
+        curve_1D._rpc_id: type(curve_1D).__name__,
+        curve_2D._rpc_id: type(curve_2D).__name__,
     }
     curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_1D.curves})
     curves_expected.update({curve._gui_id: type(curve).__name__ for curve in curve_2D.curves})
-    fig_expected = {fig.rpc_id: type(fig).__name__}
+    fig_expected = {fig._rpc_id: type(fig).__name__}
     image_item_expected = {
-        fig.widgets[im.rpc_id].images[0].rpc_id: type(fig.widgets[im.rpc_id].images[0]).__name__
+        fig.widgets[im._rpc_id].images[0]._rpc_id: type(fig.widgets[im._rpc_id].images[0]).__name__
     }
 
     all_connections_expected = {

tests/unit_tests/client_mocks.py

@@ -84,6 +84,7 @@ class DMMock:
 DEVICES = [
     FakePositioner("samx", limits=[-10, 10], read_value=2.0),
     FakePositioner("samy", limits=[-5, 5], read_value=3.0),
+    FakePositioner("samz", limits=[-8, 8], read_value=4.0),
     FakePositioner("aptrx", limits=None, read_value=4.0),
     FakePositioner("aptry", limits=None, read_value=5.0),
     FakeDevice("gauss_bpm"),

tests/unit_tests/test_bec_figure.py

@@ -38,9 +38,9 @@ def test_bec_figure_add_remove_plot(bec_figure):
     initial_count = len(bec_figure._widgets)
 
     # Adding 3 widgets -  2 WaveformBase and 1 PlotBase
-    w0 = bec_figure.add_plot()
-    w1 = bec_figure.add_plot()
-    w2 = bec_figure.add_widget(widget_type="PlotBase")
+    w0 = bec_figure.plot(new=True)
+    w1 = bec_figure.plot(new=True)
+    w2 = bec_figure.add_widget(widget_type="BECPlotBase")
 
     # Check if the widgets were added
     assert len(bec_figure._widgets) == initial_count + 3
@@ -75,7 +75,7 @@ def test_add_different_types_of_widgets(bec_figure):
 
 
 def test_access_widgets_access_errors(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     # access widget by non-existent coordinates
     with pytest.raises(ValueError) as excinfo:
@@ -97,18 +97,18 @@ def test_access_widgets_access_errors(bec_figure):
 
 
 def test_add_plot_to_occupied_position(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
-        bec_figure.add_plot(row=0, col=0)
+        bec_figure.plot(row=0, col=0, new=True)
         assert "Position at row 0 and column 0 is already occupied." in str(excinfo.value)
 
 
 def test_remove_plots(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
-    w3 = bec_figure.add_plot(row=1, col=0)
-    w4 = bec_figure.add_plot(row=1, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
+    w3 = bec_figure.plot(row=1, col=0)
+    w4 = bec_figure.plot(row=1, col=1)
 
     assert bec_figure[0, 0] == w1
     assert bec_figure[0, 1] == w2
@@ -135,10 +135,10 @@ def test_remove_plots(bec_figure):
 
 
 def test_remove_plots_by_coordinates_ints(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
 
-    bec_figure.remove(0, 0)
+    bec_figure.remove(row=0, col=0)
     assert w1.gui_id not in bec_figure._widgets
     assert w2.gui_id in bec_figure._widgets
     assert bec_figure[0, 0] == w2
@@ -146,8 +146,8 @@ def test_remove_plots_by_coordinates_ints(bec_figure):
 
 
 def test_remove_plots_by_coordinates_tuple(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
 
     bec_figure.remove(coordinates=(0, 0))
     assert w1.gui_id not in bec_figure._widgets
@@ -157,7 +157,7 @@ def test_remove_plots_by_coordinates_tuple(bec_figure):
 
 
 def test_remove_plot_by_id_error(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot()
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove(widget_id="non_existent_widget")
@@ -165,7 +165,7 @@ def test_remove_plot_by_id_error(bec_figure):
 
 
 def test_remove_plot_by_coordinates_error(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove(0, 1)
@@ -173,7 +173,7 @@ def test_remove_plot_by_coordinates_error(bec_figure):
 
 
 def test_remove_plot_by_providing_nothing(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
+    bec_figure.plot(row=0, col=0)
 
     with pytest.raises(ValueError) as excinfo:
         bec_figure.remove()
@@ -193,10 +193,10 @@ def test_remove_plot_by_providing_nothing(bec_figure):
 
 
 def test_change_layout(bec_figure):
-    w1 = bec_figure.add_plot(row=0, col=0)
-    w2 = bec_figure.add_plot(row=0, col=1)
-    w3 = bec_figure.add_plot(row=1, col=0)
-    w4 = bec_figure.add_plot(row=1, col=1)
+    w1 = bec_figure.plot(row=0, col=0)
+    w2 = bec_figure.plot(row=0, col=1)
+    w3 = bec_figure.plot(row=1, col=0)
+    w4 = bec_figure.plot(row=1, col=1)
 
     bec_figure.change_layout(max_columns=1)
 
@@ -216,10 +216,10 @@ def test_change_layout(bec_figure):
 
 
 def test_clear_all(bec_figure):
-    bec_figure.add_plot(row=0, col=0)
-    bec_figure.add_plot(row=0, col=1)
-    bec_figure.add_plot(row=1, col=0)
-    bec_figure.add_plot(row=1, col=1)
+    bec_figure.plot(row=0, col=0)
+    bec_figure.plot(row=0, col=1)
+    bec_figure.plot(row=1, col=0)
+    bec_figure.plot(row=1, col=1)
 
     bec_figure.clear_all()
 
@@ -238,3 +238,26 @@ def test_shortcuts(bec_figure):
     assert im.__class__ == BECImageShow
     assert motor_map.config.widget_class == "BECMotorMap"
     assert motor_map.__class__ == BECMotorMap
+
+
+def test_plot_access_factory(bec_figure):
+    plt_00 = bec_figure.plot(x_name="samx", y_name="bpm4i")
+    plt_01 = bec_figure.plot(x_name="samx", y_name="bpm4i", row=0, col=1)
+    plt_10 = bec_figure.plot(new=True)
+
+    assert bec_figure.widget_list[0] == plt_00
+    assert bec_figure.widget_list[1] == plt_01
+    assert bec_figure.widget_list[2] == plt_10
+    assert bec_figure.axes(row=0, col=0) == plt_00
+    assert bec_figure.axes(row=0, col=1) == plt_01
+    assert bec_figure.axes(row=1, col=0) == plt_10
+
+    assert len(plt_00.curves) == 1
+    assert len(plt_01.curves) == 1
+    assert len(plt_10.curves) == 0
+
+    # update plt_00
+    bec_figure.plot(x_name="samx", y_name="bpm3a")
+    bec_figure.plot(x=[1, 2, 3], y=[1, 2, 3], row=0, col=0)
+
+    assert len(plt_00.curves) == 3

tests/unit_tests/test_bec_motor_map.py

@@ -1,100 +1,106 @@
+import numpy as np
 import pytest
 
 from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, MotorMapConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform_curve import SignalData
 
 from .client_mocks import mocked_client
+from .test_bec_figure import bec_figure
 
 
-@pytest.fixture(scope="function")
-def bec_motor_map(qtbot, mocked_client):
-    widget = BECMotorMap(client=mocked_client, gui_id="BECMotorMap_test")
-    # qtbot.addWidget(widget)
-    # qtbot.waitExposed(widget)
-    yield widget
+def test_motor_map_init(bec_figure):
+    default_config = MotorMapConfig(widget_class="BECMotorMap")
+
+    mm = bec_figure.motor_map(config=default_config.model_dump())
+    default_config.gui_id = mm.gui_id
+
+    assert mm.config == default_config
 
 
-def test_motor_map_init(bec_motor_map):
-    default_config = MotorMapConfig(widget_class="BECMotorMap", gui_id="BECMotorMap_test")
+def test_motor_map_change_motors(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
 
-    assert bec_motor_map.config == default_config
+    assert mm.motor_x == "samx"
+    assert mm.motor_y == "samy"
+    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
+    assert mm.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
+
+    mm.change_motors("samx", "samz")
+
+    assert mm.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
+    assert mm.config.signals.y == SignalData(name="samz", entry="samz", limits=[-8, 8])
 
 
-def test_motor_map_change_motors(bec_motor_map):
-    bec_motor_map.change_motors("samx", "samy")
-
-    assert bec_motor_map.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
-    assert bec_motor_map.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
-
-
-def test_motor_map_get_limits(bec_motor_map):
+def test_motor_map_get_limits(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
     expected_limits = {"samx": [-10, 10], "samy": [-5, 5]}
 
     for motor_name, expected_limit in expected_limits.items():
-        actual_limit = bec_motor_map._get_motor_limit(motor_name)
+        actual_limit = mm._get_motor_limit(motor_name)
         assert actual_limit == expected_limit
 
 
-def test_motor_map_get_init_position(bec_motor_map):
-    bec_motor_map.set_precision(2)
+def test_motor_map_get_init_position(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    mm.set_precision(2)
 
-    motor_map_dev = bec_motor_map.client.device_manager.devices
+    motor_map_dev = mm.client.device_manager.devices
 
     expected_positions = {
         ("samx", "samx"): motor_map_dev["samx"].read()["samx"]["value"],
         ("samy", "samy"): motor_map_dev["samy"].read()["samy"]["value"],
-        ("aptrx", "aptrx"): motor_map_dev["aptrx"].read()["aptrx"]["value"],
-        ("aptry", "aptry"): motor_map_dev["aptry"].read()["aptry"]["value"],
     }
 
     for (motor_name, entry), expected_position in expected_positions.items():
-        actual_position = bec_motor_map._get_motor_init_position(motor_name, entry, 2)
+        actual_position = mm._get_motor_init_position(motor_name, entry, 2)
         assert actual_position == expected_position
 
 
-def test_motor_movement_updates_position_and_database(bec_motor_map):
-    motor_map_dev = bec_motor_map.client.device_manager.devices
+def test_motor_movement_updates_position_and_database(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    motor_map_dev = mm.client.device_manager.devices
 
     init_positions = {
         "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
         "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
     }
 
-    bec_motor_map.change_motors("samx", "samy")
+    mm.change_motors("samx", "samy")
 
-    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
-    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+    assert mm.database_buffer["x"] == init_positions["samx"]
+    assert mm.database_buffer["y"] == init_positions["samy"]
 
     # Simulate motor movement for 'samx' only
     new_position_samx = 4.0
-    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+    mm.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
 
     init_positions["samx"].append(new_position_samx)
     init_positions["samy"].append(init_positions["samy"][-1])
     # Verify database update for 'samx'
-    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+    assert mm.database_buffer["x"] == init_positions["samx"]
 
     # Verify 'samy' retains its last known position
-    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+    assert mm.database_buffer["y"] == init_positions["samy"]
 
 
-def test_scatter_plot_rendering(bec_motor_map):
-    motor_map_dev = bec_motor_map.client.device_manager.devices
+def test_scatter_plot_rendering(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    motor_map_dev = mm.client.device_manager.devices
 
     init_positions = {
         "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
         "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
     }
 
-    bec_motor_map.change_motors("samx", "samy")
+    mm.change_motors("samx", "samy")
 
     # Simulate motor movement for 'samx' only
     new_position_samx = 4.0
-    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
-    bec_motor_map._update_plot()
+    mm.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+    mm._update_plot()
 
     # Get the scatter plot item
-    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+    scatter_plot_item = mm.plot_components["scatter"]
 
     # Check the scatter plot item properties
     assert len(scatter_plot_item.data) > 0, "Scatter plot data is empty"
@@ -106,16 +112,148 @@ def test_scatter_plot_rendering(bec_motor_map):
     ), "Scatter plot Y data should retain last known position"
 
 
-def test_plot_visualization_consistency(bec_motor_map):
-    bec_motor_map.change_motors("samx", "samy")
+def test_plot_visualization_consistency(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+    mm.change_motors("samx", "samy")
     # Simulate updating the plot with new data
-    bec_motor_map.on_device_readback({"signals": {"samx": {"value": 5}}})
-    bec_motor_map.on_device_readback({"signals": {"samy": {"value": 9}}})
-    bec_motor_map._update_plot()
+    mm.on_device_readback({"signals": {"samx": {"value": 5}}})
+    mm.on_device_readback({"signals": {"samy": {"value": 9}}})
+    mm._update_plot()
 
-    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+    scatter_plot_item = mm.plot_components["scatter"]
 
     # Check if the scatter plot reflects the new data correctly
     assert (
         scatter_plot_item.data["x"][-1] == 5 and scatter_plot_item.data["y"][-1] == 9
     ), "Plot not updated correctly with new data"
+
+
+def test_change_background_value(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.background_value == 25
+    assert np.all(mm.plot_components["limit_map"].image == 25.0)
+
+    mm.set_background_value(50)
+    qtbot.wait(200)
+
+    assert mm.config.background_value == 50
+    assert np.all(mm.plot_components["limit_map"].image == 50.0)
+
+
+def test_motor_map_init_from_config(bec_figure):
+    config = {
+        "widget_class": "BECMotorMap",
+        "gui_id": "mm_id",
+        "parent_id": bec_figure.gui_id,
+        "row": 0,
+        "col": 0,
+        "axis": {
+            "title": "Motor position: (-0.0, 0.0)",
+            "title_size": None,
+            "x_label": "Motor X (samx)",
+            "x_label_size": None,
+            "y_label": "Motor Y (samy)",
+            "y_label_size": None,
+            "legend_label_size": None,
+            "x_scale": "linear",
+            "y_scale": "linear",
+            "x_lim": None,
+            "y_lim": None,
+            "x_grid": True,
+            "y_grid": True,
+        },
+        "signals": {
+            "source": "device_readback",
+            "x": {
+                "name": "samx",
+                "entry": "samx",
+                "unit": None,
+                "modifier": None,
+                "limits": [-10.0, 10.0],
+            },
+            "y": {
+                "name": "samy",
+                "entry": "samy",
+                "unit": None,
+                "modifier": None,
+                "limits": [-5.0, 5.0],
+            },
+            "z": None,
+            "dap": None,
+        },
+        "color": (255, 255, 255, 255),
+        "scatter_size": 5,
+        "max_points": 50,
+        "num_dim_points": 10,
+        "precision": 5,
+        "background_value": 50,
+    }
+    mm = bec_figure.motor_map(config=config)
+    config["gui_id"] = mm.gui_id
+
+    assert mm._config_dict == config
+
+
+def test_motor_map_set_scatter_size(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.scatter_size == 5
+    assert mm.plot_components["scatter"].opts["size"] == 5
+
+    mm.set_scatter_size(10)
+    qtbot.wait(200)
+
+    assert mm.config.scatter_size == 10
+    assert mm.plot_components["scatter"].opts["size"] == 10
+
+
+def test_motor_map_change_precision(bec_figure):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.precision == 2
+    mm.set_precision(10)
+    assert mm.config.precision == 10
+
+
+def test_motor_map_set_color(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+
+    assert mm.config.color == (255, 255, 255, 255)
+
+    mm.set_color((0, 0, 0, 255))
+    qtbot.wait(200)
+    assert mm.config.color == (0, 0, 0, 255)
+
+
+def test_motor_map_get_data_max_points(bec_figure, qtbot):
+    mm = bec_figure.motor_map("samx", "samy")
+    motor_map_dev = mm.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+    mm.on_device_readback({"signals": {"samx": {"value": 5.0}}})
+    mm.on_device_readback({"signals": {"samy": {"value": 9.0}}})
+    mm.on_device_readback({"signals": {"samx": {"value": 6.0}}})
+    mm.on_device_readback({"signals": {"samy": {"value": 7.0}}})
+
+    expected_x = [init_positions["samx"][-1], 5.0, 5.0, 6.0, 6.0]
+    expected_y = [init_positions["samy"][-1], init_positions["samy"][-1], 9.0, 9.0, 7.0]
+    get_data = mm.get_data()
+
+    assert mm.database_buffer["x"] == expected_x
+    assert mm.database_buffer["y"] == expected_y
+    assert get_data["x"] == expected_x
+    assert get_data["y"] == expected_y
+
+    mm.set_max_points(3)
+    qtbot.wait(200)
+    get_data = mm.get_data()
+    assert len(get_data["x"]) == 3
+    assert len(get_data["y"]) == 3
+    assert get_data["x"] == expected_x[-3:]
+    assert get_data["y"] == expected_y[-3:]
+    assert mm.database_buffer["x"] == expected_x[-3:]
+    assert mm.database_buffer["y"] == expected_y[-3:]

tests/unit_tests/test_bec_queue.py

@@ -0,0 +1,111 @@
+import pytest
+from bec_lib import messages
+
+from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def bec_queue_msg_full():
+    content = {
+        "primary": {
+            "info": [
+                {
+                    "active_request_block": None,
+                    "is_scan": [True],
+                    "queue_id": "600163fc-5e56-4901-af25-14e9ee76817c",
+                    "request_blocks": [
+                        {
+                            "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
+                            "content": {
+                                "parameter": {
+                                    "args": {"samx": [-0.1, 0.1]},
+                                    "kwargs": {
+                                        "exp_time": 0.5,
+                                        "relative": True,
+                                        "steps": 20,
+                                        "system_config": {
+                                            "file_directory": None,
+                                            "file_suffix": None,
+                                        },
+                                    },
+                                },
+                                "queue": "primary",
+                                "scan_type": "line_scan",
+                            },
+                            "is_scan": True,
+                            "metadata": {
+                                "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
+                                "file_directory": None,
+                                "file_suffix": None,
+                                "user_metadata": {"sample_name": "testA"},
+                            },
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": "testA"},
+                                    "RID": "89a76021-28c0-4297-828e-74ae40b941e5",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-0.1, 0.1]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "exp_time": 0.5,
+                                        "relative": True,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "readout_priority": {
+                                "async": [],
+                                "baseline": [],
+                                "monitored": ["samx"],
+                                "on_request": [],
+                            },
+                            "report_instructions": [{"scan_progress": 20}],
+                            "scan_id": "2d704cc3-c172-404c-866d-608ce09fce40",
+                            "scan_motors": ["samx"],
+                            "scan_number": 1289,
+                        }
+                    ],
+                    "scan_id": ["2d704cc3-c172-404c-866d-608ce09fce40"],
+                    "scan_number": [1289],
+                    "status": "COMPLETED",
+                }
+            ],
+            "status": "RUNNING",
+        }
+    }
+    msg = messages.ScanQueueStatusMessage(metadata={}, queue=content)
+    return msg
+
+
+@pytest.fixture
+def bec_queue(qtbot, mocked_client):
+    widget = BECQueue(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_bec_queue(bec_queue, bec_queue_msg_full):
+    bec_queue.update_queue(bec_queue_msg_full.content, {})
+    assert bec_queue.rowCount() == 1
+    assert bec_queue.item(0, 0).text() == "1289"
+    assert bec_queue.item(0, 1).text() == "line_scan"
+    assert bec_queue.item(0, 2).text() == "COMPLETED"
+
+
+def test_bec_queue_empty(bec_queue):
+    bec_queue.update_queue({}, {})
+    assert bec_queue.rowCount() == 1
+    assert bec_queue.item(0, 0).text() == ""
+    assert bec_queue.item(0, 1).text() == ""
+    assert bec_queue.item(0, 2).text() == ""

tests/unit_tests/test_color_validation.py

@@ -58,3 +58,18 @@ def test_color_validation_RGBA():
     assert "The color values must be between 0 and 255 in RGBA format (R,G,B,A)" in str(
         excinfo.value
     )
+
+
+def test_hex_to_rgba():
+    assert Colors.hex_to_rgba("#FF5733") == (255, 87, 51, 255)
+    assert Colors.hex_to_rgba("#FF573380") == (255, 87, 51, 128)
+    assert Colors.hex_to_rgba("#FF5733", 128) == (255, 87, 51, 128)
+
+    with pytest.raises(ValueError):
+        Colors.hex_to_rgba("#FF573")
+
+
+def test_rgba_to_hex():
+    assert Colors.rgba_to_hex(255, 87, 51, 255) == "#FF5733FF"
+    assert Colors.rgba_to_hex(255, 87, 51, 128) == "#FF573380"
+    assert Colors.rgba_to_hex(255, 87, 51) == "#FF5733FF"

tests/unit_tests/test_device_input_base.py

@@ -58,7 +58,7 @@ def test_device_input_base_set_default_device_error(device_input_base):
 
 def test_device_input_base_get_device_list(device_input_base):
     devices = device_input_base.get_device_list("FakePositioner")
-    assert devices == ["samx", "samy", "aptrx", "aptry"]
+    assert devices == ["samx", "samy", "samz", "aptrx", "aptry"]
 
 
 def test_device_input_base_get_filters(device_input_base):

tests/unit_tests/test_device_input_widgets.py

@@ -56,6 +56,7 @@ def test_device_input_combobox_init(device_input_combobox):
     assert device_input_combobox.devices == [
         "samx",
         "samy",
+        "samz",
         "aptrx",
         "aptry",
         "gauss_bpm",
@@ -141,6 +142,7 @@ def test_device_input_line_edit_init(device_input_line_edit):
     assert device_input_line_edit.devices == [
         "samx",
         "samy",
+        "samz",
         "aptrx",
         "aptry",
         "gauss_bpm",

tests/unit_tests/test_generate_plugin.py

@@ -0,0 +1,155 @@
+import importlib
+import inspect
+import os
+import sys
+
+import pytest
+
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
+
+
+def load_plugin(dir_path, content, plugin_name="MyWidget"):
+    plugin_path = dir_path.mkdir("plugin").join("plugin.py")
+    plugin_path.write(content)
+    sys.path.append(str(dir_path))
+    plugin = importlib.import_module("plugin.plugin")
+    importlib.reload(plugin)
+    yield getattr(plugin, plugin_name)
+    sys.path.pop()
+
+
+@pytest.fixture(
+    params=[
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent=parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super(QWidget, self).__init__(parent)"""
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super(QWidget, self).__init__(parent=parent)
+""",
+    ]
+)
+def plugin_with_correct_parent(tmpdir, request):
+    yield from load_plugin(tmpdir, request.param)
+
+
+@pytest.fixture(
+    params=[
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__()
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, parent=None):
+        super(QWidget, self).__init__()
+        """,
+    ]
+)
+def plugin_with_missing_parent(tmpdir, request):
+    yield from load_plugin(tmpdir, request.param)
+
+
+def test_generate_plugin(plugin_with_correct_parent):
+    generator = DesignerPluginGenerator(plugin_with_correct_parent)
+    generator.run()
+    assert os.path.exists(f"{generator.info.base_path}/register_my_widget.py")
+    assert os.path.exists(f"{generator.info.base_path}/my_widget_plugin.py")
+    assert os.path.exists(f"{generator.info.base_path}/my_widget.pyproject")
+
+
+def test_generate_plugin_with_missing_parent(plugin_with_missing_parent):
+    with pytest.raises(ValueError) as excinfo:
+        generator = DesignerPluginGenerator(plugin_with_missing_parent)
+        generator.run()
+    assert "Widget class MyWidget must call the super constructor with parent." in str(
+        excinfo.value
+    )
+
+
+@pytest.fixture()
+def plugin_with_excluded_widget(tmpdir):
+    content = """
+from qtpy.QtWidgets import QWidget
+class BECDock(QWidget):
+    def __init__(self, parent=None):
+        QWidget.__init__(self, parent)
+"""
+    yield from load_plugin(tmpdir, content, plugin_name="BECDock")
+
+
+def test_generate_plugin_with_excluded_widget(plugin_with_excluded_widget, capsys):
+    generator = DesignerPluginGenerator(plugin_with_excluded_widget)
+    generator.run()
+    captured = capsys.readouterr()
+
+    assert "Plugin BECDock is excluded from generation." in captured.out
+    assert not os.path.exists(f"{generator.info.base_path}/register_bec_dock.py")
+    assert not os.path.exists(f"{generator.info.base_path}/bec_dock_plugin.py")
+    assert not os.path.exists(f"{generator.info.base_path}/bec_dock.pyproject")
+
+
+@pytest.fixture(
+    params=[
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self):
+        QWidget.__init__(self)
+""",
+        """
+from qtpy.QtWidgets import QWidget
+class MyWidget(QWidget):
+    def __init__(self, config, parent=None):
+        super().__init__()
+""",
+    ]
+)
+def plugin_with_no_parent_as_first_arg(tmpdir, request):
+    yield from load_plugin(tmpdir, request.param)
+
+
+def test_generate_plugin_raises_exception_when_first_argument_is_not_parent(
+    plugin_with_no_parent_as_first_arg,
+):
+    with pytest.raises(ValueError) as excinfo:
+        generator = DesignerPluginGenerator(plugin_with_no_parent_as_first_arg)
+        generator.run()
+    assert "Widget class MyWidget must have parent as the first argument." in str(excinfo.value)

tests/unit_tests/test_motor_control.py

@@ -74,7 +74,7 @@ def test_motor_thread_initialization(mocked_client):
 def test_get_all_motors_names(mocked_client):
     motor_thread = MotorThread(client=mocked_client)
     motor_names = motor_thread.get_all_motors_names()
-    expected_names = ["samx", "samy", "aptrx", "aptry"]
+    expected_names = ["samx", "samy", "samz", "aptrx", "aptry"]
     assert sorted(motor_names) == sorted(expected_names)
     assert all(name in motor_names for name in expected_names)
     assert len(motor_names) == len(expected_names)  # Ensure only these motors are returned
@@ -155,11 +155,12 @@ def motor_selection_widget(qtbot, mocked_client, motor_thread):
 
 
 def test_initialization_and_population(motor_selection_widget):
-    assert motor_selection_widget.comboBox_motor_x.count() == 4
+    assert motor_selection_widget.comboBox_motor_x.count() == 5
     assert motor_selection_widget.comboBox_motor_x.itemText(0) == "samx"
     assert motor_selection_widget.comboBox_motor_y.itemText(1) == "samy"
-    assert motor_selection_widget.comboBox_motor_x.itemText(2) == "aptrx"
-    assert motor_selection_widget.comboBox_motor_y.itemText(3) == "aptry"
+    assert motor_selection_widget.comboBox_motor_y.itemText(2) == "samz"
+    assert motor_selection_widget.comboBox_motor_x.itemText(3) == "aptrx"
+    assert motor_selection_widget.comboBox_motor_y.itemText(4) == "aptry"
 
 
 def test_selection_and_signal_emission(motor_selection_widget):

tests/unit_tests/test_plot_base.py

@@ -9,14 +9,14 @@ from .test_bec_figure import bec_figure
 
 
 def test_init_plot_base(bec_figure):
-    plot_base = bec_figure.add_widget(widget_type="PlotBase", widget_id="test_plot")
+    plot_base = bec_figure.add_widget(widget_type="BECPlotBase", widget_id="test_plot")
     assert plot_base is not None
     assert plot_base.config.widget_class == "BECPlotBase"
     assert plot_base.config.gui_id == "test_plot"
 
 
 def test_plot_base_axes_by_separate_methods(bec_figure):
-    plot_base = bec_figure.add_widget(widget_type="PlotBase", widget_id="test_plot")
+    plot_base = bec_figure.add_widget(widget_type="BECPlotBase", widget_id="test_plot")
 
     plot_base.set_title("Test Title")
     plot_base.set_x_label("Test x Label")
@@ -66,7 +66,7 @@ def test_plot_base_axes_by_separate_methods(bec_figure):
 
 
 def test_plot_base_axes_added_by_kwargs(bec_figure):
-    plot_base = bec_figure.add_widget(widget_type="PlotBase", widget_id="test_plot")
+    plot_base = bec_figure.add_widget(widget_type="BECPlotBase", widget_id="test_plot")
 
     plot_base.set(
         title="Test Title",

tests/unit_tests/test_waveform1d.py

@@ -11,7 +11,7 @@ from .test_bec_figure import bec_figure
 
 
 def test_adding_curve_to_waveform(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     # adding curve which is in bec - only names
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
@@ -39,7 +39,7 @@ def test_adding_curve_to_waveform(bec_figure):
 
 
 def test_adding_curve_with_same_id(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
 
     with pytest.raises(ValueError) as excinfo:
@@ -122,9 +122,10 @@ def test_create_waveform1D_by_config(bec_figure):
         },
     }
 
-    w1 = bec_figure.add_plot(config=w1_config_input)
+    w1 = bec_figure.plot(config=w1_config_input)
 
     w1_config_output = w1.get_config()
+    w1_config_input["gui_id"] = w1.gui_id
 
     assert w1_config_input == w1_config_output
     assert w1.plot_item.titleLabel.text == "Widget 1"
@@ -132,7 +133,7 @@ def test_create_waveform1D_by_config(bec_figure):
 
 
 def test_change_gui_id(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
     w1.change_gui_id("new_id")
 
@@ -141,7 +142,7 @@ def test_change_gui_id(bec_figure):
 
 
 def test_getting_curve(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
     c1_expected_config = CurveConfig(
         widget_class="BECCurve",
@@ -171,7 +172,7 @@ def test_getting_curve(bec_figure):
 
 
 def test_getting_curve_errors(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
 
     with pytest.raises(ValueError) as excinfo:
@@ -188,7 +189,7 @@ def test_getting_curve_errors(bec_figure):
 
 
 def test_add_curve(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -199,7 +200,7 @@ def test_add_curve(bec_figure):
 
 
 def test_change_legend_font_size(bec_figure):
-    plot = bec_figure.add_plot()
+    plot = bec_figure.plot()
 
     w1 = plot.add_curve_scan(x_name="samx", y_name="bpm4i")
     my_func = plot.plot_item.legend
@@ -211,7 +212,7 @@ def test_change_legend_font_size(bec_figure):
 
 
 def test_remove_curve(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     w1.add_curve_scan(x_name="samx", y_name="bpm4i")
     w1.add_curve_scan(x_name="samx", y_name="bpm3a")
@@ -229,7 +230,7 @@ def test_remove_curve(bec_figure):
 
 
 def test_change_curve_appearance_methods(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -258,7 +259,7 @@ def test_change_curve_appearance_methods(bec_figure, qtbot):
 
 
 def test_change_curve_appearance_args(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -288,7 +289,7 @@ def test_change_curve_appearance_args(bec_figure):
 
 
 def test_set_custom_curve_data(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_custom(
         x=[1, 2, 3],
@@ -336,7 +337,7 @@ def test_custom_data_2D_array(bec_figure, qtbot):
 
 
 def test_get_all_data(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_custom(
         x=[1, 2, 3],
@@ -371,7 +372,7 @@ def test_get_all_data(bec_figure):
 
 
 def test_curve_add_by_config(bec_figure):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1_config_input = {
         "widget_class": "BECCurve",
@@ -411,7 +412,7 @@ def test_curve_add_by_config(bec_figure):
 
 
 def test_scan_update(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -445,7 +446,7 @@ def test_scan_update(bec_figure, qtbot):
 
 
 def test_scan_history_with_val_access(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
 
@@ -470,7 +471,7 @@ def test_scan_history_with_val_access(bec_figure, qtbot):
 
 
 def test_scatter_2d_update(bec_figure, qtbot):
-    w1 = bec_figure.add_plot()
+    w1 = bec_figure.plot()
 
     c1 = w1.add_curve_scan(x_name="samx", y_name="samx", z_name="bpm4i")
 

tests/unit_tests/test_yaml_dialog.py

@@ -7,7 +7,7 @@ import pytest
 import yaml
 from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
 
-from bec_widgets.utils.yaml_dialog import load_yaml, save_yaml
+from bec_widgets.utils.yaml_dialog import load_yaml_gui, save_yaml_gui
 
 
 @pytest.fixture(scope="function")
@@ -33,7 +33,7 @@ def test_load_yaml(qtbot, example_widget):
         temp_file.write(b"name: test\nvalue: 42")
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -49,7 +49,7 @@ def test_load_yaml(qtbot, example_widget):
 
 def test_load_yaml_file_not_found(qtbot, example_widget, capsys):
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -76,7 +76,7 @@ def test_load_yaml_general_exception(qtbot, example_widget, capsys, monkeypatch)
     monkeypatch.setattr("builtins.open", mock_open)
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -96,7 +96,7 @@ def test_load_yaml_permission_error(qtbot, example_widget, monkeypatch, capsys):
     os.chmod(temp_file_path, 0o000)  # Remove permissions
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -120,7 +120,7 @@ def test_load_yaml_invalid_yaml(qtbot, example_widget, capsys):
         temp_file.write(b"\tinvalid_yaml: [unbalanced_brackets: ]")
 
     def load_yaml_wrapper():
-        config = load_yaml(example_widget)
+        config = load_yaml_gui(example_widget)
         if config:
             example_widget.config.update(config)
 
@@ -147,7 +147,7 @@ def test_save_yaml(qtbot, example_widget):
     example_widget.saved_config = {"name": "test", "value": 42}
 
     def save_yaml_wrapper():
-        save_yaml(example_widget, example_widget.saved_config)
+        save_yaml_gui(example_widget, example_widget.saved_config)
 
     example_widget.export_button.clicked.connect(save_yaml_wrapper)