fix(test): add a temporary test

Automatically generated by python-semantic-release

CHANGELOG.md

@@ -2,6 +2,52 @@
 
 <!--next-version-placeholder-->
 
+## v0.41.1 (2024-02-26)
+
+### Fix
+
+* **bec_dispatcher:** Handle redis connection errors more gracefully ([`a2ed2eb`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a2ed2ebe00c623eb183b03f8182ffd672fbf9e1e))
+* **bec_dispatcher:** Adapt code to redis connector refactoring ([`8127fc2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8127fc2960bebd3e862dbe55ac9401af4a6dccb6))
+
+## v0.41.0 (2024-02-26)
+
+### Feature
+
+* **widgets/waveform1d:** Data can be exported from rendered curve ([`5fc8047`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5fc8047c8ff971cdc2807d02743eae56d288f4d7))
+* **widgets/figure:** Clear_all method for BECFigure ([`0363fd5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0363fd5194320a7ea868ef883f8022ea464d0298))
+* **widgets/Waveform1D:** Waveform1D can be fully constructed by config ([`9a5c86e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9a5c86ea35178b9cab270fc35e668dd22f3ec8da))
+* **widgets/figure.py:** Dark/light theme changer ([`08534a4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/08534a4739ec8e85d82a00ab639411dd0198e9d8))
+* **utils/entry_validator:** Possibility to validate add_scan_curve with current BEC session ([`1db77b9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1db77b969bcf9b38716ae3d38bf4695b2b8c1f37))
+* **cli:** Added cli interface, rebased ([`a61bf36`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a61bf36df5d54ad44f78479c2474c4e38e68ed26))
+* Curve can be modified after adding to the plot ([`684592a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/684592ae37e9dd5328a96018c78ca242e10395b2))
+* Waveform1d.py curves can be removed by identifier by order(int) or by curve_id(str) ([`f0ed243`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f0ed243c9197b7d1aab0d99a15e9ba175708ec90))
+* Waveform1d.py curves can be stylised; access scan history by index or scanID ([`cba3863`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cba3863e5a9ac1187ea643be67db6cfc36b44ee2))
+* Start method for BECFigure, jupyter console .ui added to git ([`1d26b23`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1d26b2322147d9ea5a6a245e1648c00986f80881))
+* Added @user_access from bec_lib.utils ([`b827e9e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b827e9eaa77f8b64433bb7a54e40ab5ccd86f4b6))
+* Plot can be removed from BECFigure ([`60d150a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/60d150a41193aa7659285cf3612965f1a3c57244))
+* Figure.py create widget factory ([`c781b1b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c781b1b4e4121c4ec6fc8871a4cdf6f494913138))
+* Waveform1d.py draft ([`565e475`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/565e475ace72ccc103d71ea98af1dcaf04f37861))
+* Rpc decorator to add methods to USER_ACCESS ([`b676877`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b6768772424a3ad5ee7e271de19131f8065eef09))
+* BECFigure and BECPlotBase created ([`9ef331c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9ef331c272b88f725de9b8497fdf906056c0738b))
+* BECConnector -> mixin class for all BEC Widget to hook them to BEC client ([`91447a2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/91447a2d6234de1e8f2bac792e822bfda556abba))
+
+### Fix
+
+* **cli/client_utils:** "__rpc__" pop from msg_results ([`ebb36f6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ebb36f62ddc1c5013435f9e7727648b977b6b732))
+* **tests:** BECDispatcher fixture putted back ([`644f103`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/644f1031f6ff27064111565b0882cb8b2544aa2f))
+* **cli/rpc:** Rpc client can return any type of object + config dict of the widgets ([`fd711b4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fd711b475f268fbdb59739da0a428f0355b25bac))
+* **cli/rpc:** Server access children widget.find_widget_by_id(gui_id) ([`57132a4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/57132a472165c55bf99e1994d09f5fe3586c24da))
+* **cli:** Fixed property access, rebased ([`f71dc5c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f71dc5c5abdd6b8b585cb9b502b11ef513d7813e))
+* **rpc_server:** Fixed gui_id lookup ([`4630d78`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4630d78fc28109da7daf53e49dd3cdb9b8084941))
+* **cli:** Fixed rpc construction of nested widgets ([`da640e8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/da640e888d575b536fdd5d7adbf1df3eda802219))
+* **plots/waveform1d:** Pandas import clean up, export curves with none skipped ([`35cd4fd`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/35cd4fd6f176ba670fad5d9fec44b305094280d6))
+* **widgets/plots:** Added placeholder for cleanup method to BECPlotBase ([`24c7737`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/24c77376b232c3846a1d6be360ec46acc077b48d))
+* **widget/figure:** Add cleanup method to disconnect all slots before removing Waveform1D from layout ([`a28b9c8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a28b9c8981d1058e4dc4146463f16c53413e8db9))
+* **rpc:** Added annotations to pass py3.9 tests ([`c6bdf0b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c6bdf0b6a5b12c054863b101a3944efc366686cb))
+* **rpc:** Connection to on_rpc_update done through bec_dispatcher ([`1c2fb8b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1c2fb8b972d4cb28cead11989461aea010c4571d))
+* After removing plot from BECFigure, the coordinates are correctly resigned ([`d678a85`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d678a85957c13c1fda2b52692c0d3b9b7ff40834))
+* Removed DI references, fixed set when adding plot by fig ([`7c15d75`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7c15d750117aec9e75111853074630a44dca87ae))
+
 ## v0.40.1 (2024-02-23)
 
 ### Fix

bec_widgets/cli/client.py

@@ -0,0 +1,386 @@
+# This file was automatically generated by generate_cli.py
+
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+from typing import Literal, Optional, overload
+
+
+class BECPlotBase(RPCBase):
+    @rpc_call
+    def set(self, **kwargs) -> "None":
+        """
+        Set the properties of the plot widget.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+        """
+
+    @rpc_call
+    def set_title(self, title: "str"):
+        """
+        Set the title of the plot widget.
+        Args:
+            title(str): Title of the plot widget.
+        """
+
+    @rpc_call
+    def set_x_label(self, label: "str"):
+        """
+        Set the label of the x-axis.
+        Args:
+            label(str): Label of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_label(self, label: "str"):
+        """
+        Set the label of the y-axis.
+        Args:
+            label(str): Label of the y-axis.
+        """
+
+    @rpc_call
+    def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
+        """
+        Set the scale of the x-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
+        """
+        Set the scale of the y-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the y-axis.
+        """
+
+    @rpc_call
+    def set_x_lim(self, *args) -> "None":
+        """
+        Set the limits of the x-axis. This method can accept either two separate arguments
+        for the minimum and maximum x-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_x_lim(x_min, x_max)
+            set_x_lim((x_min, x_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (x_min and x_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    def set_y_lim(self, *args) -> "None":
+        """
+        Set the limits of the y-axis. This method can accept either two separate arguments
+        for the minimum and maximum y-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_y_lim(y_min, y_max)
+            set_y_lim((y_min, y_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (y_min and y_max)
+                   or a single tuple with two integers.
+        """
+
+    @rpc_call
+    def set_grid(self, x: "bool" = False, y: "bool" = False):
+        """
+        Set the grid of the plot widget.
+        Args:
+            x(bool): Show grid on the x-axis.
+            y(bool): Show grid on the y-axis.
+        """
+
+    @rpc_call
+    def plot_data(self, data_x: "list | np.ndarray", data_y: "list | np.ndarray", **kwargs):
+        """
+        Plot custom data on the plot widget. These data are not saved in config.
+        Args:
+            data_x(list|np.ndarray): x-axis data
+            data_y(list|np.ndarray): y-axis data
+            **kwargs: Keyword arguments for the plot.
+        """
+
+    @rpc_call
+    def remove(self):
+        """
+        Remove the plot widget from the figure.
+        """
+
+
+class BECWaveform1D(RPCBase):
+    @rpc_call
+    def add_curve_scan(
+        self,
+        x_name: "str",
+        y_name: "str",
+        x_entry: "Optional[str]" = None,
+        y_entry: "Optional[str]" = None,
+        color: "Optional[str]" = None,
+        label: "Optional[str]" = None,
+        validate_bec: "bool" = True,
+        **kwargs
+    ) -> "BECCurve":
+        """
+        Add a curve to the plot widget from the scan segment.
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            label(str, optional): Label of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def add_curve_custom(
+        self,
+        x: "list | np.ndarray",
+        y: "list | np.ndarray",
+        label: "str" = None,
+        color: "str" = None,
+        **kwargs
+    ) -> "BECCurve":
+        """
+        Add a custom data curve to the plot widget.
+        Args:
+            x(list|np.ndarray): X data of the curve.
+            y(list|np.ndarray): Y data of the curve.
+            label(str, optional): Label of the curve. Defaults to None.
+            color(str, optional): Color of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def remove_curve(self, *identifiers):
+        """
+        Remove a curve from the plot widget.
+        Args:
+            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
+        """
+
+    @rpc_call
+    def scan_history(self, scan_index: "int" = None, scanID: "str" = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        Provide only one of scanID or scan_index.
+        Args:
+            scanID(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+        """
+
+    @property
+    @rpc_call
+    def curves(self) -> "list[BECCurve]":
+        """
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
+        """
+
+    @property
+    @rpc_call
+    def curves_data(self) -> "dict":
+        """
+        Get the curves data of the plot widget as a dictionary
+        Returns:
+            dict: Dictionary of curves data.
+        """
+
+    @rpc_call
+    def get_curve(self, identifier) -> "BECCurve":
+        """
+        Get the curve by its index or ID.
+        Args:
+            identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
+        Returns:
+            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 | WidgetConfig", replot_last_scan: "bool" = False):
+        """
+        Apply the configuration to the 1D waveform widget.
+        Args:
+            config(dict|WidgetConfig): 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":
+        """
+        Extract all curve data into a dictionary or a pandas DataFrame.
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
+        Returns:
+            dict | pd.DataFrame: Data of all curves in the specified format.
+        """
+
+
+class BECFigure(RPCBase, BECFigureClientMixin):
+    @rpc_call
+    def add_plot(
+        self,
+        widget_id: "str" = None,
+        row: "int" = None,
+        col: "int" = None,
+        config=None,
+        **axis_kwargs
+    ) -> "BECWaveform1D":
+        """
+        Add a Waveform1D plot to the figure at the specified position.
+        Args:
+            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
+            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 remove(
+        self,
+        row: "int" = None,
+        col: "int" = None,
+        widget_id: "str" = None,
+        coordinates: "tuple[int, int]" = None,
+    ) -> "None":
+        """
+        Remove a widget from the figure. Can be removed by its unique identifier or by its coordinates.
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+            widget_id(str): The unique identifier of the widget to remove.
+            coordinates(tuple[int, int], optional): The coordinates of the widget to remove.
+        """
+
+    @rpc_call
+    def change_layout(self, max_columns=None, max_rows=None):
+        """
+        Reshuffle the layout of the figure to adjust to a new number of max_columns or max_rows.
+        If both max_columns and max_rows are provided, max_rows is ignored.
+
+        Args:
+            max_columns (Optional[int]): The new maximum number of columns in the figure.
+            max_rows (Optional[int]): The new maximum number of rows in the figure.
+        """
+
+    @rpc_call
+    def change_theme(self, theme: "Literal['dark', 'light']") -> "None":
+        """
+        Change the theme of the figure widget.
+        Args:
+            theme(Literal["dark","light"]): The theme to set for the figure widget.
+        """
+
+    @rpc_call
+    def clear_all(self):
+        """
+        Clear all widgets from the figure and reset to default state
+        """
+
+
+class BECCurve(RPCBase):
+    @rpc_call
+    def set(self, **kwargs):
+        """
+        Set the properties of the curve.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - color: str
+            - symbol: str
+            - symbol_color: str
+            - symbol_size: int
+            - pen_width: int
+            - pen_style: Literal["solid", "dash", "dot", "dashdot"]
+        """
+
+    @rpc_call
+    def set_data(self, x, y):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_color(self, color: "str", symbol_color: "Optional[str]" = None):
+        """
+        Change the color of the curve.
+        Args:
+            color(str): Color of the curve.
+            symbol_color(str, optional): Color of the symbol. Defaults to None.
+        """
+
+    @rpc_call
+    def set_symbol(self, symbol: "str"):
+        """
+        Change the symbol of the curve.
+        Args:
+            symbol(str): Symbol of the curve.
+        """
+
+    @rpc_call
+    def set_symbol_color(self, symbol_color: "str"):
+        """
+        Change the symbol color of the curve.
+        Args:
+            symbol_color(str): Color of the symbol.
+        """
+
+    @rpc_call
+    def set_symbol_size(self, symbol_size: "int"):
+        """
+        Change the symbol size of the curve.
+        Args:
+            symbol_size(int): Size of the symbol.
+        """
+
+    @rpc_call
+    def set_pen_width(self, pen_width: "int"):
+        """
+        Change the pen width of the curve.
+        Args:
+            pen_width(int): Width of the pen.
+        """
+
+    @rpc_call
+    def set_pen_style(self, pen_style: "Literal['solid', 'dash', 'dot', 'dashdot']"):
+        """
+        Change the pen style of the curve.
+        Args:
+            pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
+        """
+
+    @rpc_call
+    def get_data(self) -> "tuple[np.ndarray, np.ndarray]":
+        """
+        Get the data of the curve.
+        Returns:
+            tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
+        """

bec_widgets/cli/client_utils.py

@@ -0,0 +1,175 @@
+import importlib
+import select
+import subprocess
+import uuid
+
+from functools import wraps
+
+from qtpy.QtCore import QCoreApplication
+
+import bec_widgets.cli.client as client
+from bec_lib import MessageEndpoints, messages
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+def rpc_call(func):
+    """
+    A decorator for calling a function on the server.
+
+    Args:
+        func: The function to call.
+
+    Returns:
+        The result of the function call.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        return self._run_rpc(func.__name__, *args, **kwargs)
+
+    return wrapper
+
+
+class BECFigureClientMixin:
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._process = None
+
+    def show(self) -> None:
+        """
+        Show the figure.
+        """
+        if self._process is None or self._process.poll() is not None:
+            self._start_plot_process()
+
+    def close(self) -> None:
+        """
+        Close the figure.
+        """
+        if self._process is None:
+            return
+        self._run_rpc("close", (), wait_for_rpc_response=False)
+        self._process.kill()
+        self._process = None
+
+    def _start_plot_process(self) -> None:
+        """
+        Start the plot in a new process.
+        """
+        # pylint: disable=subprocess-run-check
+        monitor_module = importlib.import_module("bec_widgets.cli.server")
+        monitor_path = monitor_module.__file__
+
+        command = f"python {monitor_path} --id {self._gui_id}"
+        self._process = subprocess.Popen(
+            command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+
+    def print_log(self) -> None:
+        """
+        Print the log of the plot process.
+        """
+        if self._process is None:
+            return
+        print(self._get_stderr_output())
+
+    def _get_stderr_output(self) -> str:
+        stderr_output = []
+        while self._process.poll() is not None:
+            readylist, _, _ = select.select([self._process.stderr], [], [], 0.1)
+            if not readylist:
+                break
+            line = self._process.stderr.readline()
+            if not line:
+                break
+            stderr_output.append(line.decode("utf-8"))
+        return "".join(stderr_output)
+
+    def __del__(self) -> None:
+        self.close()
+
+
+class RPCBase:
+    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
+        self._client = BECDispatcher().client
+        self._config = config if config is not None else {}
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())
+        self._parent = parent
+        super().__init__()
+        print(f"RPCBase: {self._gui_id}")
+
+    @property
+    def _root(self):
+        """
+        Get the root widget. This is the BECFigure widget that holds
+        the anchor gui_id.
+        """
+        parent = self
+        # pylint: disable=protected-access
+        while parent._parent is not None:
+            parent = parent._parent
+        return parent
+
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, **kwargs):
+        """
+        Run the RPC call.
+
+        Args:
+            method: The method to call.
+            args: The arguments to pass to the method.
+            wait_for_rpc_response: Whether to wait for the RPC response.
+            kwargs: The keyword arguments to pass to the method.
+
+        Returns:
+            The result of the RPC call.
+        """
+        request_id = str(uuid.uuid4())
+        rpc_msg = messages.GUIInstructionMessage(
+            action=method,
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            metadata={"request_id": request_id},
+        )
+        print(f"RPCBase: {rpc_msg}")
+        # pylint: disable=protected-access
+        receiver = self._root._gui_id
+        self._client.connector.send(MessageEndpoints.gui_instructions(receiver), rpc_msg)
+
+        if not wait_for_rpc_response:
+            return None
+        response = self._wait_for_response(request_id)
+        # get class name
+        if not response.content["accepted"]:
+            raise ValueError(response.content["message"]["error"])
+        msg_result = response.content["message"].get("result")
+        return self._create_widget_from_msg_result(msg_result)
+
+    def _create_widget_from_msg_result(self, msg_result):
+        if msg_result is None:
+            return None
+        if isinstance(msg_result, list):
+            return [self._create_widget_from_msg_result(res) for res in msg_result]
+        if isinstance(msg_result, dict):
+            if "__rpc__" not in msg_result:
+                return msg_result
+            cls = msg_result.pop("widget_class", None)
+            msg_result.pop("__rpc__", None)
+
+            if not cls:
+                return msg_result
+
+            cls = getattr(client, cls)
+            print(msg_result)
+            return cls(parent=self, **msg_result)
+        return msg_result
+
+    def _wait_for_response(self, request_id):
+        """
+        Wait for the response from the server.
+        """
+        response = None
+        while response is None:
+            response = self._client.connector.get(
+                MessageEndpoints.gui_instruction_response(request_id)
+            )
+            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
+        return response

bec_widgets/cli/generate_cli.py

@@ -0,0 +1,96 @@
+import inspect
+import typing
+
+
+class ClientGenerator:
+    def __init__(self):
+        self.header = """# This file was automatically generated by generate_cli.py\n
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+from typing import Literal, Optional, overload"""
+
+        self.content = ""
+
+    def generate_client(self, published_classes: list):
+        """
+        Generate the client for the published classes.
+
+        Args:
+            published_classes(list): The list of published classes (e.g. [BECWaveform1D, BECFigure]).
+        """
+        for cls in published_classes:
+            self.content += "\n\n"
+            self.generate_content_for_class(cls)
+
+    def generate_content_for_class(self, cls):
+        """
+        Generate the content for the class.
+        Args:
+            cls: The class for which to generate the content.
+        """
+
+        class_name = cls.__name__
+        module = cls.__module__
+
+        # Generate the header
+        #         self.header += f"""
+        # from {module} import {class_name}"""
+
+        # Generate the content
+        if cls.__name__ == "BECFigure":
+            self.content += f"""
+class {class_name}(RPCBase, BECFigureClientMixin):"""
+        else:
+            self.content += f"""
+class {class_name}(RPCBase):"""
+        for method in cls.USER_ACCESS:
+            obj = getattr(cls, method)
+            if isinstance(obj, property):
+                self.content += """
+    @property
+    @rpc_call"""
+                sig = str(inspect.signature(obj.fget))
+                doc = inspect.getdoc(obj.fget)
+            else:
+                sig = str(inspect.signature(obj))
+                doc = inspect.getdoc(obj)
+                overloads = typing.get_overloads(obj)
+                for overload in overloads:
+                    sig_overload = str(inspect.signature(overload))
+                    self.content += f"""
+    @overload
+    def {method}{str(sig_overload)}: ...
+    """
+
+                self.content += """
+    @rpc_call"""
+            self.content += f"""
+    def {method}{str(sig)}:
+        \"\"\"
+{doc}
+        \"\"\""""
+
+    def write(self, file_name: str):
+        """
+        Write the content to a file.
+
+        Args:
+            file_name(str): The name of the file to write to.
+        """
+        with open(file_name, "w", encoding="utf-8") as file:
+            file.write(self.header)
+            file.write(self.content)
+
+
+if __name__ == "__main__":
+    import os
+
+    from bec_widgets.widgets.figure import BECFigure
+    from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D  # ,BECCurve
+    from bec_widgets.widgets.plots.waveform1d import BECCurve
+
+    current_path = os.path.dirname(__file__)
+    client_path = os.path.join(current_path, "client.py")
+    clss = [BECPlotBase, BECWaveform1D, BECFigure, BECCurve]
+    generator = ClientGenerator()
+    generator.generate_client(clss)
+    generator.write(client_path)

bec_widgets/cli/server.py

@@ -0,0 +1,110 @@
+import inspect
+
+from bec_lib import MessageEndpoints, messages
+
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.plots import BECCurve, BECWaveform1D
+
+
+class BECWidgetsCLIServer:
+    WIDGETS = [BECWaveform1D, BECFigure, BECCurve]
+
+    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None) -> None:
+        self.dispatcher = BECDispatcher() if dispatcher is None else dispatcher
+        self.client = self.dispatcher.client
+        self.client.start()
+        self.gui_id = gui_id
+        self.fig = BECFigure(gui_id=self.gui_id)
+        print(f"Server started with gui_id {self.gui_id}")
+
+        self.dispatcher.connect_slot(
+            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
+        )
+
+    def start(self):
+        """Start the figure window."""
+        self.fig.start()
+
+    def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
+        try:
+            method = msg["action"]
+            args = msg["parameter"].get("args", [])
+            kwargs = msg["parameter"].get("kwargs", {})
+            obj = self.get_object_from_config(msg["parameter"])
+            res = self.run_rpc(obj, method, args, kwargs)
+        except Exception as e:
+            print(e)
+            self.send_response(request_id, False, {"error": str(e)})
+        else:
+            self.send_response(request_id, True, {"result": res})
+
+    def send_response(self, request_id: str, accepted: bool, msg: dict):
+        self.client.connector.set(
+            MessageEndpoints.gui_instruction_response(request_id),
+            messages.RequestResponseMessage(accepted=accepted, message=msg),
+            expire=60,
+        )
+
+    def get_object_from_config(self, config: dict):
+        gui_id = config.get("gui_id")
+        # check if the object is the figure
+        if gui_id == self.fig.gui_id:
+            return self.fig
+        # check if the object is a widget
+        if gui_id in self.fig.widgets:
+            obj = self.fig.widgets[config["gui_id"]]
+            return obj
+        if self.fig.widgets:
+            for widget in self.fig.widgets.values():
+                item = widget.find_widget_by_id(gui_id)
+                if item:
+                    return item
+                raise NotImplementedError(
+                    f"gui_id lookup for widget of type {widget.__class__.__name__} not implemented"
+                )
+
+        raise ValueError(f"Object with gui_id {gui_id} not found")
+
+    def run_rpc(self, obj, method, args, kwargs):
+        method_obj = getattr(obj, method)
+        # check if the method accepts args and kwargs
+        if not callable(method_obj):
+            res = method_obj
+        else:
+            sig = inspect.signature(method_obj)
+            if sig.parameters:
+                res = method_obj(*args, **kwargs)
+            else:
+                res = method_obj()
+
+        if isinstance(res, list):
+            res = [self.serialize_object(obj) for obj in res]
+        else:
+            res = self.serialize_object(res)
+        return res
+
+    def serialize_object(self, obj):
+        if isinstance(obj, BECConnector):
+            return {
+                "gui_id": obj.gui_id,
+                "widget_class": obj.__class__.__name__,
+                "config": obj.config.model_dump(),
+                "__rpc__": True,
+            }
+        return obj
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
+    parser.add_argument("--id", type=str, help="The id of the server")
+
+    args = parser.parse_args()
+
+    server = BECWidgetsCLIServer(gui_id=args.id)
+    # server = BECWidgetsCLIServer(gui_id="test")
+    server.start()

bec_widgets/examples/mca_readout/mca_sim.py

@@ -2,7 +2,6 @@ from bec_lib import messages, MessageEndpoints, RedisConnector
 import time
 
 connector = RedisConnector("localhost:6379")
-producer = connector.producer()
 metadata = {}
 
 scanID = "ScanID1"
@@ -20,13 +19,11 @@ for ii in range(20):
         metadata=metadata,
     ).dumps()
 
-    # producer.send(topic=MessageEndpoints.device_status(device="mca"), msg=msg)
-
-    producer.xadd(
+    connector.xadd(
         topic=MessageEndpoints.device_async_readback(
             scanID=scanID, device="mca"
         ),  # scanID will be different for each scan
-        msg={"data": msg},
+        msg={"data": msg},  # TODO should be msg_dict
         expire=1800,
     )
 

bec_widgets/examples/stream_plot/stream_plot.py

@@ -40,7 +40,7 @@ class StreamPlot(QtWidgets.QWidget):
         uic.loadUi(os.path.join(current_path, "line_plot.ui"), self)
 
         self._idle_time = 100
-        self.producer = RedisConnector(["localhost:6379"]).producer()
+        self.connector = RedisConnector(["localhost:6379"])
 
         self.y_value_list = y_value_list
         self.previous_y_value_list = None
@@ -214,7 +214,7 @@ class StreamPlot(QtWidgets.QWidget):
             ]
         }
         msg = messages.DeviceMessage(signals=return_dict).dumps()
-        self.producer.set_and_publish("px_stream/gui_event", msg=msg)
+        self.connector.set_and_publish("px_stream/gui_event", msg=msg)
         self.roi_signal.emit(region)
 
     def init_table(self):
@@ -270,7 +270,7 @@ class StreamPlot(QtWidgets.QWidget):
                 time.sleep(0.1)
                 continue
             endpoint = f"px_stream/projection_{self._current_proj}/data"
-            msgs = self.client.producer.lrange(topic=endpoint, start=-1, end=-1)
+            msgs = self.client.connector.lrange(topic=endpoint, start=-1, end=-1)
             data = msgs
             if not data:
                 continue
@@ -295,7 +295,7 @@ class StreamPlot(QtWidgets.QWidget):
     def new_proj(self, content: dict, _metadata: dict):
         proj_nr = content["signals"]["proj_nr"]
         endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = self.client.producer.get(topic=endpoint)
+        msg_raw = self.client.connector.get(topic=endpoint)
         msg = messages.DeviceMessage.loads(msg_raw)
         self._current_q = msg.content["signals"]["q"]
         self._current_norm = msg.content["signals"]["norm_sum"]

bec_widgets/utils/__init__.py

@@ -2,3 +2,7 @@ from .crosshair import Crosshair
 from .colors import Colors
 from .validator_delegate import DoubleValidationDelegate
 from .bec_table import BECTable
+from .bec_connector import BECConnector, ConnectionConfig
+from .bec_dispatcher import BECDispatcher
+from .rpc_decorator import rpc_public, register_rpc_methods
+from .entry_validator import EntryValidator

bec_widgets/utils/bec_connector.py

@@ -0,0 +1,108 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import time
+from typing import Type, Optional
+
+from pydantic import BaseModel, Field, field_validator
+from qtpy.QtCore import Slot as pyqtSlot
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+class ConnectionConfig(BaseModel):
+    """Configuration for BECConnector mixin class"""
+
+    widget_class: str = Field(default="NonSpecifiedWidget", description="The class of the widget.")
+    gui_id: Optional[str] = Field(
+        default=None, validate_default=True, description="The GUI ID of the widget."
+    )
+
+    @field_validator("gui_id")
+    def generate_gui_id(cls, v, values):
+        """Generate a GUI ID if none is provided."""
+        if v is None:
+            widget_class = values.data["widget_class"]
+            v = f"{widget_class}_{str(time.time())}"
+            return v
+        return v
+
+
+class BECConnector:
+    """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
+
+    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
+        # BEC related connections
+        self.bec_dispatcher = BECDispatcher()
+        self.client = self.bec_dispatcher.client if client is None else client
+
+        if config:
+            self.config = config
+        else:
+            print(
+                f"No initial config found for {self.__class__.__name__}.\n"
+                f"Initializing with default config."
+            )
+            self.config = ConnectionConfig(widget_class=self.__class__.__name__)
+
+        if gui_id:
+            self.config.gui_id = gui_id
+            self.gui_id = gui_id
+        else:
+            self.gui_id = self.config.gui_id
+
+    @pyqtSlot(str)
+    def set_gui_id(self, gui_id: str) -> None:
+        """
+        Set the GUI ID for the widget.
+        Args:
+            gui_id(str): GUI ID
+        """
+        self.config.gui_id = gui_id
+        self.gui_id = gui_id
+
+    def get_obj_by_id(self, obj_id: str):
+        if obj_id == self.gui_id:
+            return self
+
+    def get_bec_shortcuts(self):
+        """Get BEC shortcuts for the widget."""
+        self.dev = self.client.device_manager.devices
+        self.scans = self.client.scans
+        self.queue = self.client.queue
+        self.scan_storage = self.queue.scan_storage
+        self.dap = self.client.dap
+
+    def update_client(self, client) -> None:
+        """Update the client and device manager from BEC and create object for BEC shortcuts.
+        Args:
+            client: BEC client
+        """
+        self.client = client
+        self.get_bec_shortcuts()
+
+    @pyqtSlot(ConnectionConfig)  # TODO can be also dict
+    def on_config_update(self, config: ConnectionConfig | dict) -> None:
+        """
+        Update the configuration for the widget.
+        Args:
+            config(ConnectionConfig): Configuration settings.
+        """
+        if isinstance(config, dict):
+            config = ConnectionConfig(**config)
+            # TODO add error handler
+
+        self.config = config
+
+    def get_config(self, dict_output: bool = True) -> dict | BaseModel:
+        """
+        Get the configuration of the widget.
+        Args:
+            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
+        Returns:
+            dict: The configuration of the plot widget.
+        """
+        if dict_output:
+            return self.config.model_dump()
+        else:
+            return self.config

bec_widgets/utils/bec_dispatcher.py

@@ -6,9 +6,10 @@ import os
 from collections.abc import Callable
 from typing import Union
 
+import redis
 from bec_lib import BECClient, ServiceConfig
-from bec_lib.redis_connector import RedisConsumerThreaded
-from qtpy.QtCore import QObject, Signal as pyqtSignal
+from qtpy.QtCore import QObject
+from qtpy.QtCore import Signal as pyqtSignal
 
 # Adding a new pyqt signal requires a class factory, as they must be part of the class definition
 # and cannot be dynamically added as class attributes after the class has been defined.
@@ -18,10 +19,11 @@ _signal_class_factory = (
 
 
 class _Connection:
-    """Utility class to keep track of slots connected to a particular redis consumer"""
+    """Utility class to keep track of slots connected to a particular redis connector"""
+
+    def __init__(self, callback) -> None:
+        self.callback = callback
 
-    def __init__(self, consumer) -> None:
-        self.consumer: RedisConsumerThreaded = consumer
         self.slots = set()
         # keep a reference to a new signal class, so it is not gc'ed
         self._signal_container = next(_signal_class_factory)()
@@ -29,18 +31,21 @@ class _Connection:
 
 
 class _BECDispatcher(QObject):
-    """Utility class to keep track of slots connected to a particular redis consumer"""
+    """Utility class to keep track of slots connected to a particular redis connector"""
 
     def __init__(self, bec_config=None):
         super().__init__()
-        self.client = BECClient()
+        self.client = BECClient(forced=True)  # make a new instance
 
         # TODO: this is a workaround for now to provide service config within qtdesigner, but is
         # it possible to provide config via a cli arg?
         if bec_config is None and os.path.isfile("bec_config.yaml"):
             bec_config = "bec_config.yaml"
 
-        self.client.initialize(config=ServiceConfig(config_path=bec_config))
+        try:
+            self.client.initialize(config=ServiceConfig(config_path=bec_config))
+        except redis.exceptions.ConnectionError as e:
+            print(f"Failed to initialize BECClient: {e}")
         self._connections = {}
 
     def connect_slot(
@@ -73,18 +78,16 @@ class _BECDispatcher(QObject):
 
         def cb(msg):
             msg = msg.value
-            if not isinstance(msg, list):
-                msg = [msg]
-            for msg_i in msg:
-                for connection_key, connection in self._connections.items():
-                    if set(topics).intersection(
-                        connection_key if isinstance(connection_key, tuple) else [connection_key]
-                    ):
-                        connection.signal.emit(msg_i.content, msg_i.metadata)
+            for connection_key, connection in self._connections.items():
+                if set(topics).intersection(connection_key):
+                    connection.signal.emit(msg.content, msg.metadata)
 
-        consumer = self.client.connector.consumer(topics=topics, cb=cb)
-        consumer.start()
-        return _Connection(consumer)
+        try:
+            self.client.connector.register(topics=topics, cb=cb)
+        except redis.exceptions.ConnectionError:
+            print("Could not connect to Redis, skipping registration of topics.")
+
+        return _Connection(cb)
 
     def _do_disconnect_slot(self, topic, slot):
         print(f"Disconnecting {slot} from {topic}")
@@ -96,9 +99,6 @@ class _BECDispatcher(QObject):
             print("Continue to remove slot:'{slot}' from 'connection.slots'.")
         connection.slots.remove(slot)
         if not connection.slots:
-            print(f"{connection.consumer} is shutting down")
-            connection.consumer.shutdown()
-            connection.consumer.join()
             del self._connections[topic]
 
     def _disconnect_slot_from_topic(self, slot: Callable, topic: str) -> None:

bec_widgets/utils/entry_validator.py

@@ -0,0 +1,17 @@
+class EntryValidator:
+    def __init__(self, devices):
+        self.devices = devices
+
+    def validate_signal(self, name: str, entry: str = None) -> str:
+        if name not in self.devices:
+            raise ValueError(f"Device '{name}' not found in current BEC session")
+
+        device = self.devices[name]
+        description = device.describe()
+
+        if entry is None:
+            entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
+        if entry not in description:
+            raise ValueError(f"Entry '{entry}' not found in device '{name}' signals")
+
+        return entry

bec_widgets/utils/rpc_decorator.py

@@ -0,0 +1,15 @@
+def rpc_public(func):
+    func.rpc_public = True  # Mark the function for later processing by the class decorator
+    return func
+
+
+def register_rpc_methods(cls):
+    """
+    Class decorator to scan for rpc_public methods and add them to USER_ACCESS.
+    """
+    if not hasattr(cls, "USER_ACCESS"):
+        cls.USER_ACCESS = set()
+    for name, method in cls.__dict__.items():
+        if getattr(method, "rpc_public", False):
+            cls.USER_ACCESS.add(name)
+    return cls

bec_widgets/widgets/__init__.py

@@ -11,3 +11,5 @@ from .motor_control import (
     MotorThread,
     MotorCoordinateTable,
 )
+from .figure import FigureConfig, BECFigure
+from .plots import BECWaveform1D, BECCurve, BECPlotBase

bec_widgets/widgets/figure/__init__.py

@@ -0,0 +1 @@
+from .figure import FigureConfig, BECFigure

bec_widgets/widgets/figure/figure.py

@@ -0,0 +1,524 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import itertools
+import os
+from collections import defaultdict
+from typing import Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+import qdarktheme
+from pydantic import Field
+from pyqtgraph.Qt import uic
+from qtpy.QtWidgets import QApplication, QWidget
+from qtpy.QtWidgets import QVBoxLayout, QMainWindow
+
+from bec_widgets.utils import BECConnector, BECDispatcher, ConnectionConfig
+from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D, Waveform1DConfig, WidgetConfig
+
+
+class FigureConfig(ConnectionConfig):
+    """Configuration for BECFigure. Inheriting from ConnectionConfig widget_class and gui_id"""
+
+    theme: Literal["dark", "light"] = Field("dark", description="The theme of the figure widget.")
+    num_cols: int = Field(1, description="The number of columns in the figure widget.")
+    num_rows: int = Field(1, description="The number of rows in the figure widget.")
+    widgets: dict[str, WidgetConfig] = Field(
+        {}, description="The list of widgets to be added to the figure widget."
+    )
+
+
+class WidgetHandler:
+    """Factory for creating and configuring BEC widgets for BECFigure."""
+
+    def __init__(self):
+        self.widget_factory = {
+            "PlotBase": (BECPlotBase, WidgetConfig),
+            "Waveform1D": (BECWaveform1D, Waveform1DConfig),
+        }
+
+    def create_widget(
+        self,
+        widget_type: str,
+        widget_id: str,
+        parent_figure,
+        parent_id: str,
+        config: dict = None,
+        **axis_kwargs,
+    ) -> BECPlotBase:
+        """
+        Create and configure a widget based on its type.
+
+        Args:
+            widget_type (str): The type of the widget to create.
+            widget_id (str): Unique identifier for the widget.
+            parent_id (str): Identifier of the parent figure.
+            config (dict, optional): Additional configuration for the widget.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECPlotBase: The created and configured widget instance.
+        """
+        entry = self.widget_factory.get(widget_type)
+        if not entry:
+            raise ValueError(f"Unsupported widget type: {widget_type}")
+
+        widget_class, config_class = entry
+        widget_config_dict = {
+            "widget_class": widget_class.__name__,
+            "parent_id": parent_id,
+            "gui_id": widget_id,
+            **(config if config is not None else {}),
+        }
+        widget_config = config_class(**widget_config_dict)
+        widget = widget_class(
+            config=widget_config, parent_figure=parent_figure, client=parent_figure.client
+        )
+
+        if axis_kwargs:
+            widget.set(**axis_kwargs)
+
+        return widget
+
+
+class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
+    USER_ACCESS = ["add_plot", "remove", "change_layout", "change_theme", "clear_all"]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        config: Optional[FigureConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ) -> None:
+        if config is None:
+            config = FigureConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = FigureConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        pg.GraphicsLayoutWidget.__init__(self, parent)
+
+        self.widget_handler = WidgetHandler()
+
+        # Widget container to reference widgets by 'widget_id'
+        self.widgets = defaultdict(dict)
+
+        # Container to keep track of the grid
+        self.grid = []
+
+    def change_theme(self, theme: Literal["dark", "light"]) -> None:
+        """
+        Change the theme of the figure widget.
+        Args:
+            theme(Literal["dark","light"]): The theme to set for the figure widget.
+        """
+        qdarktheme.setup_theme(theme)
+        self.setBackground("k" if theme == "dark" else "w")
+        self.config.theme = theme
+
+    def add_plot(
+        self, widget_id: str = None, row: int = None, col: int = None, config=None, **axis_kwargs
+    ) -> BECWaveform1D:
+        """
+        Add a Waveform1D plot to the figure at the specified position.
+        Args:
+            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
+            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.
+        """
+        return self.add_widget(
+            widget_type="Waveform1D",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+
+    def add_widget(
+        self,
+        widget_type: Literal["PlotBase", "Waveform1D"] = "PlotBase",
+        widget_id: str = None,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECPlotBase:
+        """
+        Add a widget to the figure at the specified position.
+        Args:
+            widget_type(Literal["PlotBase","Waveform1D"]): The type of the widget to add.
+            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
+            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.
+        """
+        if not widget_id:
+            widget_id = self._generate_unique_widget_id()
+        if widget_id in self.widgets:
+            raise ValueError(f"Widget with ID '{widget_id}' already exists.")
+
+        widget = self.widget_handler.create_widget(
+            widget_type=widget_type,
+            widget_id=widget_id,
+            parent_figure=self,
+            parent_id=self.gui_id,
+            config=config,
+            **axis_kwargs,
+        )
+
+        # Check if position is occupied
+        if row is not None and col is not None:
+            if self.getItem(row, col):
+                raise ValueError(f"Position at row {row} and column {col} is already occupied.")
+            else:
+                widget.config.row = row
+                widget.config.col = col
+
+                # Add widget to the figure
+                self.addItem(widget, row=row, col=col)
+        else:
+            row, col = self._find_next_empty_position()
+            widget.config.row = row
+            widget.config.col = col
+
+            # Add widget to the figure
+            self.addItem(widget, row=row, col=col)
+
+        # Update num_cols and num_rows based on the added widget
+        self.config.num_rows = max(self.config.num_rows, row + 1)
+        self.config.num_cols = max(self.config.num_cols, col + 1)
+
+        # Saving config for future referencing
+        self.config.widgets[widget_id] = widget.config
+        self.widgets[widget_id] = widget
+
+        # Reflect the grid coordinates
+        self._change_grid(widget_id, row, col)
+
+        return widget
+
+    def remove(
+        self,
+        row: int = None,
+        col: int = None,
+        widget_id: str = None,
+        coordinates: tuple[int, int] = None,
+    ) -> None:
+        """
+        Remove a widget from the figure. Can be removed by its unique identifier or by its coordinates.
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+            widget_id(str): The unique identifier of the widget to remove.
+            coordinates(tuple[int, int], optional): The coordinates of the widget to remove.
+        """
+        if widget_id:
+            self._remove_by_id(widget_id)
+        elif row is not None and col is not None:
+            self._remove_by_coordinates(row, col)
+        elif coordinates:
+            self._remove_by_coordinates(*coordinates)
+        else:
+            raise ValueError("Must provide either widget_id or coordinates for removal.")
+
+    def _remove_by_coordinates(self, row: int, col: int) -> None:
+        """
+        Remove a widget from the figure by its coordinates.
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+        """
+        widget = self._get_widget_by_coordinates(row, col)
+        if widget:
+            widget_id = widget.config.gui_id
+            if widget_id in self.widgets:
+                self._remove_by_id(widget_id)
+
+    def _remove_by_id(self, widget_id: str) -> None:
+        """
+        Remove a widget from the figure by its unique identifier.
+        Args:
+            widget_id(str): The unique identifier of the widget to remove.
+        """
+        if widget_id in self.widgets:
+            widget = self.widgets.pop(widget_id)
+            widget.cleanup()
+            self.removeItem(widget)
+            self.grid[widget.config.row][widget.config.col] = None
+            self._reindex_grid()
+            if widget_id in self.config.widgets:
+                self.config.widgets.pop(widget_id)
+            print(f"Removed widget {widget_id}.")
+        else:
+            raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
+
+    def __getitem__(self, key: tuple | str):
+        if isinstance(key, tuple) and len(key) == 2:
+            return self._get_widget_by_coordinates(*key)
+        elif isinstance(key, str):
+            widget = self.widgets.get(key)
+            if widget is None:
+                raise KeyError(f"No widget with ID {key}")
+            return self.widgets.get(key)
+        else:
+            raise TypeError(
+                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
+            )
+
+    def _get_widget_by_coordinates(self, row: int, col: int) -> BECPlotBase:
+        """
+        Get widget by its coordinates in the figure.
+        Args:
+            row(int): the row coordinate
+            col(int): the column coordinate
+
+        Returns:
+            BECPlotBase: the widget at the given coordinates
+        """
+        widget = self.getItem(row, col)
+        if widget is None:
+            raise ValueError(f"No widget at coordinates ({row}, {col})")
+        return widget
+
+    def _find_next_empty_position(self):
+        """Find the next empty position (new row) in the figure."""
+        row, col = 0, 0
+        while self.getItem(row, col):
+            row += 1
+        return row, col
+
+    def _generate_unique_widget_id(self):
+        """Generate a unique widget ID."""
+        existing_ids = set(self.widgets.keys())
+        for i in itertools.count(1):
+            widget_id = f"widget_{i}"
+            if widget_id not in existing_ids:
+                return widget_id
+
+    def _change_grid(self, widget_id: str, row: int, col: int):
+        """
+        Change the grid to reflect the new position of the widget.
+        Args:
+            widget_id(str): The unique identifier of the widget.
+            row(int): The new row coordinate of the widget in the figure.
+            col(int): The new column coordinate of the widget in the figure.
+        """
+        while len(self.grid) <= row:
+            self.grid.append([])
+        row = self.grid[row]
+        while len(row) <= col:
+            row.append(None)
+        row[col] = widget_id
+
+    def _reindex_grid(self):
+        """Reindex the grid to remove empty rows and columns."""
+        print(f"old grid: {self.grid}")
+        new_grid = []
+        for row in self.grid:
+            new_row = [widget for widget in row if widget is not None]
+            if new_row:
+                new_grid.append(new_row)
+        #
+        # Update the config of each object to reflect its new position
+        for row_idx, row in enumerate(new_grid):
+            for col_idx, widget in enumerate(row):
+                self.widgets[widget].config.row, self.widgets[widget].config.col = row_idx, col_idx
+
+        self.grid = new_grid
+        self._replot_layout()
+
+    def _replot_layout(self):
+        """Replot the layout based on the current grid configuration."""
+        self.clear()
+        for row_idx, row in enumerate(self.grid):
+            for col_idx, widget in enumerate(row):
+                self.addItem(self.widgets[widget], row=row_idx, col=col_idx)
+
+    def change_layout(self, max_columns=None, max_rows=None):
+        """
+        Reshuffle the layout of the figure to adjust to a new number of max_columns or max_rows.
+        If both max_columns and max_rows are provided, max_rows is ignored.
+
+        Args:
+            max_columns (Optional[int]): The new maximum number of columns in the figure.
+            max_rows (Optional[int]): The new maximum number of rows in the figure.
+        """
+        # Calculate total number of widgets
+        total_widgets = len(self.widgets)
+
+        if max_columns:
+            # Calculate the required number of rows based on max_columns
+            required_rows = (total_widgets + max_columns - 1) // max_columns
+            new_grid = [[None for _ in range(max_columns)] for _ in range(required_rows)]
+        elif max_rows:
+            # Calculate the required number of columns based on max_rows
+            required_columns = (total_widgets + max_rows - 1) // max_rows
+            new_grid = [[None for _ in range(required_columns)] for _ in range(max_rows)]
+        else:
+            # If neither max_columns nor max_rows is specified, just return without changing the layout
+            return
+
+        # Populate the new grid with widgets' IDs
+        current_idx = 0
+        for widget_id, widget in self.widgets.items():
+            row = current_idx // len(new_grid[0])
+            col = current_idx % len(new_grid[0])
+            new_grid[row][col] = widget_id
+            current_idx += 1
+
+        self.config.num_rows = row
+        self.config.num_cols = col
+
+        # Update widgets' positions and replot them according to the new grid
+        self.grid = new_grid
+        self._reindex_grid()  # This method should be updated to handle reshuffling correctly
+        self._replot_layout()  # Assumes this method re-adds widgets to the layout based on self.grid
+
+    def clear_all(self):
+        """Clear all widgets from the figure and reset to default state"""
+        self.clear()
+        self.widgets = defaultdict(dict)
+        self.grid = []
+        theme = self.config.theme
+        self.config = FigureConfig(
+            widget_class=self.__class__.__name__, gui_id=self.gui_id, theme=theme
+        )
+
+    def start(self):
+        import sys
+
+        app = QApplication(sys.argv)
+        win = QMainWindow()
+        win.setCentralWidget(self)
+        win.show()
+
+        sys.exit(app.exec_())
+
+
+##################################################
+##################################################
+# Debug window
+##################################################
+##################################################
+
+from qtconsole.inprocess import QtInProcessKernelManager
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+
+
+class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
+    def __init__(self):
+        super().__init__()
+
+        self.kernel_manager = QtInProcessKernelManager()
+        self.kernel_manager.start_kernel(show_banner=False)
+        self.kernel_client = self.kernel_manager.client()
+        self.kernel_client.start_channels()
+
+        self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
+
+    def shutdown_kernel(self):
+        self.kernel_client.stop_channels()
+        self.kernel_manager.shutdown_kernel()
+
+
+class DebugWindow(QWidget):  # pragma: no cover:
+    """Debug window for BEC widgets"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        current_path = os.path.dirname(__file__)
+        uic.loadUi(os.path.join(current_path, "figure_debug_minimal.ui"), self)
+
+        self._init_ui()
+
+        self.splitter.setSizes([200, 100])
+
+        # console push
+        self.console.kernel_manager.kernel.shell.push(
+            {"fig": self.figure, "w1": self.w1, "w2": self.w2}
+        )
+
+    def _init_ui(self):
+        # Plotting window
+        self.glw_1_layout = QVBoxLayout(self.glw)  # Create a new QVBoxLayout
+        self.figure = BECFigure(parent=self)  # Create a new BECDeviceMonitor
+        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
+
+        # add stuff to figure
+        self._init_figure()
+
+        self.console_layout = QVBoxLayout(self.widget_console)
+        self.console = JupyterConsoleWidget()
+        self.console_layout.addWidget(self.console)
+        self.console.set_default_style("linux")
+
+    def _init_figure(self):
+        self.figure.add_widget(widget_type="Waveform1D", row=0, col=0, title="Widget 1")
+        self.figure.add_widget(widget_type="Waveform1D", row=1, col=0, title="Widget 2")
+        self.figure.add_widget(widget_type="Waveform1D", row=0, col=1, title="Widget 3")
+        self.figure.add_widget(widget_type="Waveform1D", row=1, col=1, title="Widget 4")
+
+        self.w1 = self.figure[0, 0]
+        self.w2 = self.figure[1, 0]
+        self.w3 = self.figure[0, 1]
+        self.w4 = self.figure[1, 1]
+
+        # curves for w1
+        self.w1.add_curve_scan("samx", "bpm4i", pen_style="dash")
+        self.w1.add_curve_custom(
+            x=[1, 2, 3, 4, 5],
+            y=[1, 2, 3, 4, 5],
+            label="curve-custom",
+            color="blue",
+            pen_style="dashdot",
+        )
+        self.c1 = self.w1.get_config()
+
+        # curves for w2
+        self.w2.add_curve_scan("samx", "bpm3a", pen_style="solid")
+        self.w2.add_curve_scan("samx", "bpm4d", pen_style="dot")
+        self.w2.add_curve_custom(
+            x=[1, 2, 3, 4, 5], y=[5, 4, 3, 2, 1], color="red", pen_style="dashdot"
+        )
+
+        # curves for w3
+        self.w3.add_curve_scan("samx", "bpm4i", pen_style="dash")
+        self.w3.add_curve_custom(
+            x=[1, 2, 3, 4, 5],
+            y=[1, 2, 3, 4, 5],
+            label="curve-custom",
+            color="blue",
+            pen_style="dashdot",
+        )
+
+        # curves for w4
+        self.w4.add_curve_scan("samx", "bpm4i", pen_style="dash")
+        self.w4.add_curve_custom(
+            x=[1, 2, 3, 4, 5],
+            y=[1, 2, 3, 4, 5],
+            label="curve-custom",
+            color="blue",
+            pen_style="dashdot",
+        )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication(sys.argv)
+    win = DebugWindow()
+    win.show()
+
+    sys.exit(app.exec_())

bec_widgets/widgets/figure/figure_debug_minimal.ui

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>901</width>
+    <height>1000</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_3">
+   <item>
+    <widget class="QSplitter" name="splitter_2">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <widget class="QSplitter" name="splitter">
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+      <widget class="QWidget" name="glw" native="true"/>
+     </widget>
+     <widget class="QWidget" name="widget_console" native="true"/>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/plots/__init__.py

@@ -0,0 +1,2 @@
+from .plot_base import AxisConfig, WidgetConfig, BECPlotBase
+from .waveform1d import Waveform1DConfig, BECWaveform1D, BECCurve

bec_widgets/widgets/plots/plot_base.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+
+from pydantic import BaseModel, Field
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+class AxisConfig(BaseModel):
+    title: Optional[str] = Field(None, description="The title of the axes.")
+    x_label: Optional[str] = Field(None, description="The label for the x-axis.")
+    y_label: Optional[str] = Field(None, description="The label for the y-axis.")
+    x_scale: Literal["linear", "log"] = Field("linear", description="The scale of the x-axis.")
+    y_scale: Literal["linear", "log"] = Field("linear", description="The scale of the y-axis.")
+    x_lim: Optional[tuple] = Field(None, description="The limits of the x-axis.")
+    y_lim: Optional[tuple] = Field(None, description="The limits of the y-axis.")
+    x_grid: bool = Field(False, description="Show grid on the x-axis.")
+    y_grid: bool = Field(False, description="Show grid on the y-axis.")
+
+
+class WidgetConfig(ConnectionConfig):
+    parent_id: Optional[str] = Field(None, description="The parent figure of the plot.")
+
+    # Coordinates in the figure
+    row: int = Field(0, description="The row coordinate in the figure.")
+    col: int = Field(0, description="The column coordinate in the figure.")
+
+    # Appearance settings
+    axis: AxisConfig = Field(
+        default_factory=AxisConfig, description="The axis configuration of the plot."
+    )
+
+
+class BECPlotBase(BECConnector, pg.PlotItem):
+    USER_ACCESS = [
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "plot_data",
+        "remove",
+    ]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,  # TODO decide if needed for this class
+        parent_figure=None,
+        config: Optional[WidgetConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = WidgetConfig(widget_class=self.__class__.__name__)
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        pg.PlotItem.__init__(self, parent)
+
+        self.figure = parent_figure
+
+        self.add_legend()
+
+    def set(self, **kwargs) -> None:
+        """
+        Set the properties of the plot widget.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+        """
+        # Mapping of keywords to setter methods
+        method_map = {
+            "title": self.set_title,
+            "x_label": self.set_x_label,
+            "y_label": self.set_y_label,
+            "x_scale": self.set_x_scale,
+            "y_scale": self.set_y_scale,
+            "x_lim": self.set_x_lim,
+            "y_lim": self.set_y_lim,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def apply_axis_config(self):
+        """Apply the axis configuration to the plot widget."""
+        config_mappings = {
+            "title": self.config.axis.title,
+            "x_label": self.config.axis.x_label,
+            "y_label": self.config.axis.y_label,
+            "x_scale": self.config.axis.x_scale,
+            "y_scale": self.config.axis.y_scale,
+            "x_lim": self.config.axis.x_lim,
+            "y_lim": self.config.axis.y_lim,
+        }
+
+        self.set(**{k: v for k, v in config_mappings.items() if v is not None})
+
+    def set_title(self, title: str):
+        """
+        Set the title of the plot widget.
+        Args:
+            title(str): Title of the plot widget.
+        """
+        self.setTitle(title)
+        self.config.axis.title = title
+
+    def set_x_label(self, label: str):
+        """
+        Set the label of the x-axis.
+        Args:
+            label(str): Label of the x-axis.
+        """
+        self.setLabel("bottom", label)
+        self.config.axis.x_label = label
+
+    def set_y_label(self, label: str):
+        """
+        Set the label of the y-axis.
+        Args:
+            label(str): Label of the y-axis.
+        """
+        self.setLabel("left", label)
+        self.config.axis.y_label = label
+
+    def set_x_scale(self, scale: Literal["linear", "log"] = "linear"):
+        """
+        Set the scale of the x-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the x-axis.
+        """
+        self.setLogMode(x=(scale == "log"))
+        self.config.axis.x_scale = scale
+
+    def set_y_scale(self, scale: Literal["linear", "log"] = "linear"):
+        """
+        Set the scale of the y-axis.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the y-axis.
+        """
+        self.setLogMode(y=(scale == "log"))
+        self.config.axis.y_scale = scale
+
+    def set_x_lim(self, *args) -> None:
+        """
+        Set the limits of the x-axis. This method can accept either two separate arguments
+        for the minimum and maximum x-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_x_lim(x_min, x_max)
+            set_x_lim((x_min, x_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (x_min and x_max)
+                   or a single tuple with two integers.
+        """
+        if len(args) == 1 and isinstance(args[0], tuple):
+            x_min, x_max = args[0]
+        elif len(args) == 2:
+            x_min, x_max = args
+        else:
+            raise ValueError("set_x_lim expects either two separate arguments or a single tuple")
+
+        self.setXRange(x_min, x_max)
+        self.config.axis.x_lim = (x_min, x_max)
+
+    def set_y_lim(self, *args) -> None:
+        """
+        Set the limits of the y-axis. This method can accept either two separate arguments
+        for the minimum and maximum y-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_y_lim(y_min, y_max)
+            set_y_lim((y_min, y_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (y_min and y_max)
+                   or a single tuple with two integers.
+        """
+        if len(args) == 1 and isinstance(args[0], tuple):
+            y_min, y_max = args[0]
+        elif len(args) == 2:
+            y_min, y_max = args
+        else:
+            raise ValueError("set_y_lim expects either two separate arguments or a single tuple")
+
+        self.setYRange(y_min, y_max)
+        self.config.axis.y_lim = (y_min, y_max)
+
+    def set_grid(self, x: bool = False, y: bool = False):
+        """
+        Set the grid of the plot widget.
+        Args:
+            x(bool): Show grid on the x-axis.
+            y(bool): Show grid on the y-axis.
+        """
+        self.showGrid(x, y)
+        self.config.axis.x_grid = x
+        self.config.axis.y_grid = y
+
+    def add_legend(self):
+        self.addLegend()
+
+    def plot_data(self, data_x: list | np.ndarray, data_y: list | np.ndarray, **kwargs):
+        """
+        Plot custom data on the plot widget. These data are not saved in config.
+        Args:
+            data_x(list|np.ndarray): x-axis data
+            data_y(list|np.ndarray): y-axis data
+            **kwargs: Keyword arguments for the plot.
+        """
+        # TODO very basic so far, add more options
+        # TODO decide name of the method
+        self.plot(data_x, data_y, **kwargs)
+
+    def remove(self):
+        """Remove the plot widget from the figure."""
+        if self.figure is not None:
+            self.figure.remove(widget_id=self.gui_id)
+
+    def cleanup(self):
+        """Cleanup the plot widget."""

bec_widgets/widgets/plots/waveform1d.py

@@ -0,0 +1,731 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Literal, Optional, Any
+
+import numpy as np
+import pyqtgraph as pg
+from pydantic import Field, BaseModel, ValidationError
+from pyqtgraph import mkBrush
+from qtpy import QtCore
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
+
+from bec_lib import MessageEndpoints
+from bec_lib.scan_data import ScanData
+from bec_widgets.utils import Colors, ConnectionConfig, BECConnector, EntryValidator
+from bec_widgets.widgets.plots import BECPlotBase, WidgetConfig
+
+
+class SignalData(BaseModel):
+    """The data configuration of a signal in the 1D waveform widget for x and y axis."""
+
+    # TODO add validator on name and entry
+    name: str
+    entry: str
+    unit: Optional[str] = None  # todo implement later
+    modifier: Optional[str] = None  # todo implement later
+
+
+class Signal(BaseModel):
+    """The configuration of a signal in the 1D waveform widget."""
+
+    source: str  # TODO add validator on the source type
+    x: SignalData
+    y: SignalData
+
+
+class CurveConfig(ConnectionConfig):
+    parent_id: Optional[str] = Field(None, description="The parent plot of the curve.")
+    label: Optional[str] = Field(None, description="The label of the curve.")
+    color: Optional[Any] = Field(None, description="The color of the curve.")
+    symbol: Optional[str] = Field("o", description="The symbol of the curve.")
+    symbol_color: Optional[str] = Field(None, description="The color of the symbol of the curve.")
+    symbol_size: Optional[int] = Field(5, description="The size of the symbol of the curve.")
+    pen_width: Optional[int] = Field(2, description="The width of the pen of the curve.")
+    pen_style: Optional[Literal["solid", "dash", "dot", "dashdot"]] = Field(
+        "solid", description="The style of the pen of the curve."
+    )
+    source: Optional[str] = Field(
+        None, description="The source of the curve."
+    )  # TODO here on or curve??
+    signals: Optional[Signal] = Field(None, description="The signal of the curve.")
+
+
+class Waveform1DConfig(WidgetConfig):
+    color_palette: Literal["plasma", "viridis", "inferno", "magma"] = Field(
+        "plasma", description="The color palette of the figure widget."
+    )
+    curves: dict[str, CurveConfig] = Field(
+        {}, description="The list of curves to be added to the 1D waveform widget."
+    )
+
+
+class BECCurve(BECConnector, pg.PlotDataItem):
+    USER_ACCESS = [
+        "set",
+        "set_data",
+        "set_color",
+        "set_symbol",
+        "set_symbol_color",
+        "set_symbol_size",
+        "set_pen_width",
+        "set_pen_style",
+        "get_data",
+    ]
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        config: Optional[CurveConfig] = None,
+        gui_id: Optional[str] = None,
+        **kwargs,
+    ):
+        if config is None:
+            config = CurveConfig(label=name, widget_class=self.__class__.__name__)
+            self.config = config
+        else:
+            self.config = config
+            # config.widget_class = self.__class__.__name__
+        super().__init__(config=config, gui_id=gui_id)
+        pg.PlotDataItem.__init__(self, name=name)
+
+        self.apply_config()
+        if kwargs:
+            self.set(**kwargs)
+
+    def apply_config(self):
+        pen_style_map = {
+            "solid": QtCore.Qt.SolidLine,
+            "dash": QtCore.Qt.DashLine,
+            "dot": QtCore.Qt.DotLine,
+            "dashdot": QtCore.Qt.DashDotLine,
+        }
+        pen_style = pen_style_map.get(self.config.pen_style, QtCore.Qt.SolidLine)
+
+        pen = pg.mkPen(color=self.config.color, width=self.config.pen_width, style=pen_style)
+        self.setPen(pen)
+
+        if self.config.symbol:
+            symbol_color = self.config.symbol_color or self.config.color
+            brush = mkBrush(color=symbol_color)
+            self.setSymbolBrush(brush)
+            self.setSymbolSize(self.config.symbol_size)
+            self.setSymbol(self.config.symbol)
+
+    def set_data(self, x, y):
+        if self.config.source == "custom":
+            self.setData(x, y)
+        else:
+            raise ValueError(f"Source {self.config.source} do not allow custom data setting.")
+
+    def set(self, **kwargs):
+        """
+        Set the properties of the curve.
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - color: str
+            - symbol: str
+            - symbol_color: str
+            - symbol_size: int
+            - pen_width: int
+            - pen_style: Literal["solid", "dash", "dot", "dashdot"]
+        """
+
+        # Mapping of keywords to setter methods
+        method_map = {
+            "color": self.set_color,
+            "symbol": self.set_symbol,
+            "symbol_color": self.set_symbol_color,
+            "symbol_size": self.set_symbol_size,
+            "pen_width": self.set_pen_width,
+            "pen_style": self.set_pen_style,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def set_color(self, color: str, symbol_color: Optional[str] = None):
+        """
+        Change the color of the curve.
+        Args:
+            color(str): Color of the curve.
+            symbol_color(str, optional): Color of the symbol. Defaults to None.
+        """
+        self.config.color = color
+        self.config.symbol_color = symbol_color or color
+        self.apply_config()
+
+    def set_symbol(self, symbol: str):
+        """
+        Change the symbol of the curve.
+        Args:
+            symbol(str): Symbol of the curve.
+        """
+        self.config.symbol = symbol
+        self.apply_config()
+
+    def set_symbol_color(self, symbol_color: str):
+        """
+        Change the symbol color of the curve.
+        Args:
+            symbol_color(str): Color of the symbol.
+        """
+        self.config.symbol_color = symbol_color
+        self.apply_config()
+
+    def set_symbol_size(self, symbol_size: int):
+        """
+        Change the symbol size of the curve.
+        Args:
+            symbol_size(int): Size of the symbol.
+        """
+        self.config.symbol_size = symbol_size
+        self.apply_config()
+
+    def set_pen_width(self, pen_width: int):
+        """
+        Change the pen width of the curve.
+        Args:
+            pen_width(int): Width of the pen.
+        """
+        self.config.pen_width = pen_width
+        self.apply_config()
+
+    def set_pen_style(self, pen_style: Literal["solid", "dash", "dot", "dashdot"]):
+        """
+        Change the pen style of the curve.
+        Args:
+            pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
+        """
+        self.config.pen_style = pen_style
+        self.apply_config()
+
+    def get_data(self) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Get the data of the curve.
+        Returns:
+            tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
+        """
+        x_data, y_data = self.getData()
+        return x_data, y_data
+
+
+class BECWaveform1D(BECPlotBase):
+    USER_ACCESS = [
+        "add_curve_scan",
+        "add_curve_custom",
+        "remove_curve",
+        "scan_history",
+        "curves",
+        "curves_data",
+        "get_curve",
+        "get_curve_config",
+        "apply_config",
+        "get_all_data",
+    ]
+    scan_signal_update = pyqtSignal()
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[Waveform1DConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = Waveform1DConfig(widget_class=self.__class__.__name__)
+        super().__init__(
+            parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
+        )
+
+        self.curves_data = defaultdict(dict)
+        self.scanID = None
+
+        # Scan segment update proxy
+        self.proxy_update_plot = pg.SignalProxy(
+            self.scan_signal_update, rateLimit=25, slot=self._update_scan_segment_plot
+        )
+
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+
+        # Connect dispatcher signals
+        self.bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+
+        self.entry_validator = EntryValidator(self.dev)
+
+        self.addLegend()
+        self.apply_config(self.config)
+
+    # TODO check config assigning
+    # TODO check the functionality of config generator
+    def find_widget_by_id(
+        self, item_id: str
+    ):  # TODO implement this on level of BECConnector and all other widgets
+        for curve in self.curves:
+            if curve.gui_id == item_id:
+                return curve
+
+    def apply_config(self, config: dict | WidgetConfig, replot_last_scan: bool = False):
+        """
+        Apply the configuration to the 1D waveform widget.
+        Args:
+            config(dict|WidgetConfig): Configuration settings.
+            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
+        """
+        if isinstance(config, dict):
+            try:
+                config = Waveform1DConfig(**config)
+            except ValidationError as e:
+                print(f"Validation error when applying config to BECWaveform1D: {e}")
+                return
+
+        self.config = config
+        self.clear()
+
+        self.apply_axis_config()
+        # Reset curves
+        self._curves_data = defaultdict(dict)
+        self._curves = []
+        for curve_id, curve_config in self.config.curves.items():
+            self.add_curve_by_config(curve_config)
+        if replot_last_scan:
+            self.scan_history(scan_index=-1)
+
+    def change_gui_id(self, new_gui_id: str):
+        """
+        Change the GUI ID of the waveform widget and update the parent_id in all associated curves.
+
+        Args:
+            new_gui_id (str): The new GUI ID to be set for the waveform widget.
+        """
+        # Update the gui_id in the waveform widget itself
+        self.gui_id = new_gui_id
+        self.config.gui_id = new_gui_id
+
+        for curve in self.curves:
+            curve.config.parent_id = new_gui_id
+
+    def add_curve_by_config(self, curve_config: CurveConfig | dict) -> BECCurve:
+        """
+        Add a curve to the plot widget by its configuration.
+        Args:
+            curve_config(CurveConfig|dict): Configuration of the curve to be added.
+        Returns:
+            BECCurve: The curve object.
+        """
+        if isinstance(curve_config, dict):
+            curve_config = CurveConfig(**curve_config)
+        curve = self._add_curve_object(
+            name=curve_config.label, source=curve_config.source, config=curve_config
+        )
+        return curve
+
+    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.
+        """
+        for source, curves in self.curves_data.items():
+            if curve_id in curves:
+                if dict_output:
+                    return curves[curve_id].config.model_dump()
+                else:
+                    return curves[curve_id].config
+
+    @property
+    def curves(self) -> list[BECCurve]:  # TODO discuss if it should be marked as @property for RPC
+        """
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
+        """
+        return self._curves
+
+    @curves.setter
+    def curves(self, value: list[BECCurve]):
+        self._curves = value
+
+    @property
+    def curves_data(self) -> dict:  # TODO discuss if it should be marked as @property for RPC
+        """
+        Get the curves data of the plot widget as a dictionary
+        Returns:
+            dict: Dictionary of curves data.
+        """
+        return self._curves_data
+
+    @curves_data.setter
+    def curves_data(self, value: dict):
+        self._curves_data = value
+
+    def get_curve(self, identifier) -> BECCurve:
+        """
+        Get the curve by its index or ID.
+        Args:
+            identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
+        Returns:
+            BECCurve: The curve object.
+        """
+        if isinstance(identifier, int):
+            return self.curves[identifier]
+        elif isinstance(identifier, str):
+            for source_type, curves in self.curves_data.items():
+                if identifier in curves:
+                    return curves[identifier]
+            raise ValueError(f"Curve with ID '{identifier}' not found.")
+        else:
+            raise ValueError("Identifier must be either an integer (index) or a string (curve_id).")
+
+    def add_curve_custom(
+        self,
+        x: list | np.ndarray,
+        y: list | np.ndarray,
+        label: str = None,
+        color: str = None,
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add a custom data curve to the plot widget.
+        Args:
+            x(list|np.ndarray): X data of the curve.
+            y(list|np.ndarray): Y data of the curve.
+            label(str, optional): Label of the curve. Defaults to None.
+            color(str, optional): Color of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        curve_source = "custom"
+        curve_id = label or f"Curve {len(self.curves) + 1}"
+
+        curve_exits = self._check_curve_id(curve_id, self.curves_data)
+        if curve_exits:
+            raise ValueError(
+                f"Curve with ID '{curve_id}' already exists in widget '{self.gui_id}'."
+            )
+
+        color = (
+            color
+            or Colors.golden_angle_color(
+                colormap=self.config.color_palette, num=len(self.curves) + 1, format="HEX"
+            )[-1]
+        )
+
+        # Create curve by config
+        curve_config = CurveConfig(
+            widget_class="BECCurve",
+            parent_id=self.gui_id,
+            label=curve_id,
+            color=color,
+            source=curve_source,
+            **kwargs,
+        )
+
+        curve = self._add_curve_object(
+            name=curve_id, source=curve_source, config=curve_config, data=(x, y)
+        )
+        return curve
+
+    def _add_curve_object(
+        self,
+        name: str,
+        source: str,
+        config: CurveConfig,
+        data: tuple[list | np.ndarray, list | np.ndarray] = None,
+    ) -> BECCurve:
+        """
+        Add a curve object to the plot widget.
+        Args:
+            name(str): ID of the curve.
+            source(str): Source of the curve.
+            config(CurveConfig): Configuration of the curve.
+            data(tuple[list|np.ndarray,list|np.ndarray], optional): Data (x,y) to be plotted. Defaults to None.
+        Returns:
+            BECCurve: The curve object.
+        """
+        curve = BECCurve(config=config, name=name)
+        self.curves_data[source][name] = curve
+        self.addItem(curve)
+        self.config.curves[name] = curve.config
+        if data is not None:
+            curve.setData(data[0], data[1])
+        return curve
+
+    def add_curve_scan(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: Optional[str] = None,
+        y_entry: Optional[str] = None,
+        color: Optional[str] = None,
+        label: Optional[str] = None,
+        validate_bec: bool = True,
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add a curve to the plot widget from the scan segment.
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            label(str, optional): Label of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        # Check if curve already exists
+        curve_source = "scan_segment"
+
+        # Get entry if not provided and validate
+        x_entry, y_entry = self._validate_signal_entries(
+            x_name, y_name, x_entry, y_entry, validate_bec
+        )
+
+        label = label or f"{y_name}-{y_entry}"
+
+        curve_exits = self._check_curve_id(label, self.curves_data)
+        if curve_exits:
+            raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
+
+        color = (
+            color
+            or Colors.golden_angle_color(
+                colormap=self.config.color_palette, num=len(self.curves) + 1, format="HEX"
+            )[-1]
+        )
+
+        # Create curve by config
+        curve_config = CurveConfig(
+            widget_class="BECCurve",
+            parent_id=self.gui_id,
+            label=label,
+            color=color,
+            source=curve_source,
+            signals=Signal(
+                source=curve_source,
+                x=SignalData(name=x_name, entry=x_entry),
+                y=SignalData(name=y_name, entry=y_entry),
+            ),
+            **kwargs,
+        )
+        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
+        return curve
+
+    def _validate_signal_entries(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: str | None,
+        y_entry: str | None,
+        validate_bec: bool = True,
+    ) -> tuple[str, str]:
+        """
+        Validate the signal name and entry.
+        Args:
+            x_name(str): Name of the x signal.
+            y_name(str): Name of the y signal.
+            x_entry(str|None): Entry of the x signal.
+            y_entry(str|None): Entry of the y signal.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        Returns:
+            tuple[str,str]: Validated x and y entries.
+        """
+        if validate_bec:
+            x_entry = self.entry_validator.validate_signal(x_name, x_entry)
+            y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+        else:
+            x_entry = x_name if x_entry is None else x_entry
+            y_entry = y_name if y_entry is None else y_entry
+        return x_entry, y_entry
+
+    def _check_curve_id(self, val: Any, dict_to_check: dict) -> bool:
+        """
+        Check if val is in the values of the dict_to_check or in the values of the nested dictionaries.
+        Args:
+            val(Any): Value to check.
+            dict_to_check(dict): Dictionary to check.
+
+        Returns:
+            bool: True if val is in the values of the dict_to_check or in the values of the nested dictionaries, False otherwise.
+        """
+        if val in dict_to_check.keys():
+            return True
+        for key in dict_to_check:
+            if isinstance(dict_to_check[key], dict):
+                if self._check_curve_id(val, dict_to_check[key]):
+                    return True
+        return False
+
+    def remove_curve(self, *identifiers):
+        """
+        Remove a curve from the plot widget.
+        Args:
+            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
+        """
+        for identifier in identifiers:
+            if isinstance(identifier, int):
+                self._remove_curve_by_order(identifier)
+            elif isinstance(identifier, str):
+                self._remove_curve_by_id(identifier)
+            else:
+                raise ValueError(
+                    "Each identifier must be either an integer (index) or a string (curve_id)."
+                )
+
+    def _remove_curve_by_id(self, curve_id):
+        """
+        Remove a curve by its ID from the plot widget.
+        Args:
+            curve_id(str): ID of the curve to be removed.
+        """
+        for source, curves in self.curves_data.items():
+            if curve_id in curves:
+                curve = curves.pop(curve_id)
+                self.removeItem(curve)
+                del self.config.curves[curve_id]
+                if curve in self.curves:
+                    self.curves.remove(curve)
+                return
+        raise KeyError(f"Curve with ID '{curve_id}' not found.")
+
+    def _remove_curve_by_order(self, N):
+        """
+        Remove a curve by its order from the plot widget.
+        Args:
+            N(int): Order of the curve to be removed.
+        """
+        if N < len(self.curves):
+            curve = self.curves[N]
+            curve_id = curve.name()  # Assuming curve's name is used as its ID
+            self.removeItem(curve)
+            del self.config.curves[curve_id]
+            # Remove from self.curve_data
+            for source, curves in self.curves_data.items():
+                if curve_id in curves:
+                    del curves[curve_id]
+                    break
+        else:
+            raise IndexError(f"Curve order {N} out of range.")
+
+    @pyqtSlot(dict, dict)
+    def on_scan_segment(self, msg: dict, metadata: dict):
+        """
+        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
+
+        Args:
+            msg (dict): Message received with scan data.
+            metadata (dict): Metadata of the scan.
+        """
+        current_scanID = msg.get("scanID", None)
+        if current_scanID is None:
+            return
+
+        if current_scanID != self.scanID:
+            self.scanID = current_scanID
+            self.scan_segment_data = self.queue.scan_storage.find_scan_by_ID(
+                self.scanID
+            )  # TODO do scan access through BECFigure
+
+        self.scan_signal_update.emit()
+
+    def _update_scan_segment_plot(self):
+        """Update the plot with the data from the scan segment."""
+        data = self.scan_segment_data.data
+        self._update_scan_curves(data)
+
+    def _update_scan_curves(self, data: ScanData):
+        """
+        Update the scan curves with the data from the scan segment.
+        Args:
+            data(ScanData): Data from the scan segment.
+        """
+        for curve_id, curve in self.curves_data["scan_segment"].items():
+            x_name = curve.config.signals.x.name
+            x_entry = curve.config.signals.x.entry
+            y_name = curve.config.signals.y.name
+            y_entry = curve.config.signals.y.entry
+
+            try:
+                data_x = data[x_name][x_entry].val
+                data_y = data[y_name][y_entry].val
+            except TypeError:
+                continue
+
+            curve.setData(data_x, data_y)
+
+    def scan_history(self, scan_index: int = None, scanID: str = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        Provide only one of scanID or scan_index.
+        Args:
+            scanID(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+        """
+        if scan_index is not None and scanID is not None:
+            raise ValueError("Only one of scanID or scan_index can be provided.")
+
+        if scan_index is not None:
+            self.scanID = self.queue.scan_storage.storage[scan_index].scanID
+            data = self.queue.scan_storage.find_scan_by_ID(self.scanID).data
+        elif scanID is not None:
+            self.scanID = scanID
+            data = self.queue.scan_storage.find_scan_by_ID(self.scanID).data
+
+        self._update_scan_curves(data)
+
+    def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict | pd.DataFrame:
+        """
+        Extract all curve data into a dictionary or a pandas DataFrame.
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
+        Returns:
+            dict | pd.DataFrame: Data of all curves in the specified format.
+        """
+
+        data = {}
+        try:
+            import pandas as pd
+        except ImportError:
+            pd = None
+            if output == "pandas":
+                print(
+                    "Pandas is not installed. "
+                    "Please install pandas using 'pip install pandas'."
+                    "Output will be dictionary instead."
+                )
+                output = "dict"
+
+        for curve in self.curves:
+            x_data, y_data = curve.get_data()
+            if x_data is not None or y_data is not None:
+                if output == "dict":
+                    data[curve.name()] = {"x": x_data.tolist(), "y": y_data.tolist()}
+                elif output == "pandas" and pd is not None:
+                    data[curve.name()] = pd.DataFrame({"x": x_data, "y": y_data})
+
+        if output == "pandas" and pd is not None:
+            combined_data = pd.concat(
+                [data[curve.name()] for curve in self.curves],
+                axis=1,
+                keys=[curve.name() for curve in self.curves],
+            )
+            return combined_data
+        return data
+
+    def cleanup(self):
+        """Cleanup the widget connection from BECDispatcher."""
+        self.bec_dispatcher.disconnect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())

setup.py

@@ -1,7 +1,7 @@
 # pylint: disable= missing-module-docstring
 from setuptools import setup, find_packages
 
-__version__ = "0.40.1"
+__version__ = "0.41.1"
 
 # Default to PyQt6 if no other Qt binding is installed
 QT_DEPENDENCY = "PyQt6>=6.0"
@@ -32,7 +32,14 @@ if __name__ == "__main__":
             "pyqtdarktheme",
         ],
         extras_require={
-            "dev": ["pytest", "pytest-random-order", "coverage", "pytest-qt", "black"],
+            "dev": [
+                "pytest",
+                "pytest-random-order",
+                "pytest-timeout",
+                "coverage",
+                "pytest-qt",
+                "black",
+            ],
             "pyqt5": ["PyQt5>=5.9"],
             "pyqt6": ["PyQt6>=6.0"],
         },

tests/client_mocks.py

@@ -0,0 +1,77 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+
+import pytest
+from unittest.mock import MagicMock
+
+
+class FakeDevice:
+    """Fake minimal positioner class for testing."""
+
+    def __init__(self, name, enabled=True):
+        self.name = name
+        self.enabled = enabled
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name}}
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.signals[self.name]["value"] = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+
+def get_mocked_device(device_name: str):
+    """
+    Helper function to mock the devices
+    Args:
+        device_name(str): Name of the device to mock
+    """
+    return FakeDevice(name=device_name, enabled=True)
+
+
+@pytest.fixture(scope="function")
+def mocked_client():
+    # Create a dictionary of mocked devices
+    device_names = [
+        "samx",
+        "samy",
+        "gauss_bpm",
+        "gauss_adc1",
+        "gauss_adc2",
+        "gauss_adc3",
+        "bpm4i",
+        "bpm3a",
+        "bpm3i",
+    ]
+    mocked_devices = {name: get_mocked_device(name) for name in device_names}
+
+    # Create a MagicMock object
+    client = MagicMock()
+
+    # Mock the device_manager.devices attribute
+    client.device_manager.devices = MagicMock()
+    client.device_manager.devices.__getitem__.side_effect = lambda x: mocked_devices.get(x)
+    client.device_manager.devices.__contains__.side_effect = lambda x: x in mocked_devices
+
+    # Set each device as an attribute of the mock
+    for name, device in mocked_devices.items():
+        setattr(client.device_manager.devices, name, device)
+
+    return client

tests/test_bec_connector.py

@@ -0,0 +1,56 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+import pytest
+
+from .client_mocks import mocked_client
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+@pytest.fixture
+def bec_connector(mocked_client):
+    connector = BECConnector(client=mocked_client)
+    return connector
+
+
+def test_bec_connector_init(bec_connector):
+    assert bec_connector is not None
+    assert bec_connector.client is not None
+    assert isinstance(bec_connector, BECConnector)
+    assert bec_connector.config.widget_class == "BECConnector"
+
+
+def test_bec_connector_init_with_gui_id(mocked_client):
+    bc = BECConnector(client=mocked_client, gui_id="test_gui_id")
+    assert bc.config.gui_id == "test_gui_id"
+    assert bc.gui_id == "test_gui_id"
+
+
+def test_bec_connector_set_gui_id(bec_connector):
+    bec_connector.set_gui_id("test_gui_id")
+    assert bec_connector.config.gui_id == "test_gui_id"
+
+
+def test_bec_connector_change_config(bec_connector):
+    bec_connector.on_config_update({"gui_id": "test_gui_id"})
+    assert bec_connector.config.gui_id == "test_gui_id"
+
+
+def test_bec_connector_get_obj_by_id(bec_connector):
+    bec_connector.set_gui_id("test_gui_id")
+    assert bec_connector.get_obj_by_id("test_gui_id") == bec_connector
+    assert bec_connector.get_obj_by_id("test_gui_id_2") is None
+
+
+def test_bec_connector_update_client(bec_connector, mocked_client):
+    client_new = mocked_client
+    bec_connector.update_client(client_new)
+    assert bec_connector.client == client_new
+    assert bec_connector.dev is not None
+    assert bec_connector.scans is not None
+    assert bec_connector.queue is not None
+    assert bec_connector.scan_storage is not None
+    assert bec_connector.dap is not None
+
+
+def test_bec_connector_get_config(bec_connector):
+    assert bec_connector.get_config(dict_output=False) == bec_connector.config
+    assert bec_connector.get_config() == bec_connector.config.model_dump()

tests/test_bec_dispatcher.py

@@ -6,25 +6,24 @@ from bec_lib.messages import ScanMessage
 from bec_lib.connector import MessageObject
 
 
-msg = MessageObject(topic="", value=ScanMessage(point_id=0, scanID=0, data={}).dumps())
+msg = MessageObject(topic="", value=ScanMessage(point_id=0, scanID=0, data={}))
 
 
 @pytest.fixture(name="consumer")
 def _consumer(bec_dispatcher):
-    bec_dispatcher.client.connector.consumer = Mock()
-    consumer = bec_dispatcher.client.connector.consumer
-    yield consumer
+    bec_dispatcher.client.connector = Mock()
+    yield bec_dispatcher.client.connector
 
 
 @pytest.mark.filterwarnings("ignore:Failed to connect to redis.")
 def test_connect_one_slot(bec_dispatcher, consumer):
     slot1 = Mock()
     bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.assert_called_once()
+    consumer.register.assert_called_once()
     # trigger consumer callback as if a message was published
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     slot1.assert_called_once()
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 2
 
 
@@ -32,23 +31,23 @@ def test_connect_identical(bec_dispatcher, consumer):
     slot1 = Mock()
     bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
     bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.assert_called_once()
+    consumer.register.assert_called_once()
 
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     slot1.assert_called_once()
 
 
 def test_connect_many_slots_one_topic(bec_dispatcher, consumer):
     slot1, slot2 = Mock(), Mock()
     bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.assert_called_once()
+    consumer.register.assert_called_once()
     bec_dispatcher.connect_slot(slot=slot2, topics="topic0")
-    consumer.assert_called_once()
+    consumer.register.assert_called_once()
     # trigger consumer callback as if a message was published
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     slot1.assert_called_once()
     slot2.assert_called_once()
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 2
     assert slot2.call_count == 2
 
@@ -56,13 +55,13 @@ def test_connect_many_slots_one_topic(bec_dispatcher, consumer):
 def test_connect_one_slot_many_topics(bec_dispatcher, consumer):
     slot1 = Mock()
     bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    assert consumer.call_count == 1
+    assert consumer.register.call_count == 1
     bec_dispatcher.connect_slot(slot=slot1, topics="topic1")
-    assert consumer.call_count == 2
+    assert consumer.register.call_count == 2
     # trigger consumer callback as if a message was published
-    consumer.call_args_list[0].kwargs["cb"](msg)
+    consumer.register.call_args_list[0].kwargs["cb"](msg)
     slot1.assert_called_once()
-    consumer.call_args_list[1].kwargs["cb"](msg)
+    consumer.register.call_args_list[1].kwargs["cb"](msg)
     assert slot1.call_count == 2
 
 
@@ -72,19 +71,19 @@ def test_disconnect_one_slot_one_topic(bec_dispatcher, consumer):
 
     # disconnect using a different topic
     bec_dispatcher.disconnect_slot(slot=slot1, topics="topic1")
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 1
 
     # disconnect using a different slot
     bec_dispatcher.disconnect_slot(slot=slot2, topics="topic0")
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 2
 
     # disconnect using the right slot and topics
     bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
-    # reset count to 0 for slot
+    # reset count to  for slot
     slot1.reset_mock()
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 0
 
 
@@ -95,14 +94,14 @@ def test_disconnect_identical(bec_dispatcher, consumer):
     bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
 
     # Test to call the slot once (slot should be not connected twice)
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 1
 
     # Disconnect the slot
     bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
 
     # Test to call the slot once (slot should be not connected anymore), count remains 1
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 1
 
 
@@ -113,19 +112,19 @@ def test_disconnect_many_slots_one_topic(bec_dispatcher, consumer):
 
     # disconnect using a different slot
     bec_dispatcher.disconnect_slot(slot3, topics="topic0")
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 1
     assert slot2.call_count == 1
 
     # disconnect using a different topics
     bec_dispatcher.disconnect_slot(slot1, topics="topic1")
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 2
     assert slot2.call_count == 2
 
     # disconnect using the right slot and topics
     bec_dispatcher.disconnect_slot(slot1, topics="topic0")
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 2
     assert slot2.call_count == 3
 
@@ -137,31 +136,31 @@ def test_disconnect_one_slot_many_topics(bec_dispatcher, consumer):
 
     # disconnect using a different slot
     bec_dispatcher.disconnect_slot(slot=slot2, topics="topic0")
-    consumer.call_args_list[0].kwargs["cb"](msg)
+    consumer.register.call_args_list[0].kwargs["cb"](msg)
     assert slot1.call_count == 1
-    consumer.call_args_list[1].kwargs["cb"](msg)
+    consumer.register.call_args_list[1].kwargs["cb"](msg)
     assert slot1.call_count == 2
 
     # disconnect using a different topics
     bec_dispatcher.disconnect_slot(slot=slot1, topics="topic3")
-    consumer.call_args_list[0].kwargs["cb"](msg)
+    consumer.register.call_args_list[0].kwargs["cb"](msg)
     assert slot1.call_count == 3
-    consumer.call_args_list[1].kwargs["cb"](msg)
+    consumer.register.call_args_list[1].kwargs["cb"](msg)
     assert slot1.call_count == 4
 
     # disconnect using the right slot and topics
     bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
     # Calling disconnected topic0 should not call slot1
-    consumer.call_args_list[0].kwargs["cb"](msg)
+    consumer.register.call_args_list[0].kwargs["cb"](msg)
     assert slot1.call_count == 4
     # Calling topic1 should still call slot1
-    consumer.call_args_list[1].kwargs["cb"](msg)
+    consumer.register.call_args_list[1].kwargs["cb"](msg)
     assert slot1.call_count == 5
 
     # disconnect remaining topic1 from slot1, calling any topic should not increase count
     bec_dispatcher.disconnect_slot(slot=slot1, topics="topic1")
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    consumer.call_args_list[1].kwargs["cb"](msg)
+    consumer.register.call_args_list[0].kwargs["cb"](msg)
+    consumer.register.call_args_list[1].kwargs["cb"](msg)
     assert slot1.call_count == 5
 
 
@@ -178,9 +177,9 @@ def test_disconnect_all(bec_dispatcher, consumer):
     bec_dispatcher.disconnect_all()
 
     # Simulate messages and verify that none of the slots are called
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    consumer.call_args_list[1].kwargs["cb"](msg)
-    consumer.call_args_list[2].kwargs["cb"](msg)
+    consumer.register.call_args_list[0].kwargs["cb"](msg)
+    consumer.register.call_args_list[1].kwargs["cb"](msg)
+    consumer.register.call_args_list[2].kwargs["cb"](msg)
 
     # Ensure that the slots have not been called
     assert slot1.call_count == 0
@@ -209,13 +208,13 @@ def test_connect_one_slot_multiple_topics_single_callback(bec_dispatcher, consum
         msg_with_topic = MessageObject(
             topic=topic, value=ScanMessage(point_id=0, scanID=0, data={}).dumps()
         )
-        consumer.call_args.kwargs["cb"](msg_with_topic)
+        consumer.register.call_args.kwargs["cb"](msg_with_topic)
 
     # Verify that the slot is called once for each topic
     assert slot1.call_count == len(topics)
 
     # Verify that a single consumer is created for all topics
-    consumer.assert_called_once()
+    consumer.register.assert_called_once()
 
 
 def test_disconnect_all_with_single_callback_for_multiple_topics(bec_dispatcher, consumer):
@@ -237,5 +236,5 @@ def test_disconnect_all_with_single_callback_for_multiple_topics(bec_dispatcher,
     assert slot1.call_count == 0  # Slot has not been called
 
     # Simulate messages and verify that the slot is not called
-    consumer.call_args.kwargs["cb"](msg)
+    consumer.register.call_args.kwargs["cb"](msg)
     assert slot1.call_count == 0  # Slot has not been called

tests/test_bec_figure.py

@@ -0,0 +1,226 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+import os
+
+import numpy as np
+import pytest
+from unittest.mock import MagicMock
+
+from .client_mocks import mocked_client
+from bec_widgets.widgets import BECFigure
+
+
+@pytest.fixture
+def bec_figure(qtbot, mocked_client):
+    widget = BECFigure(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    return widget
+
+
+def test_bec_figure_init(bec_figure):
+    assert bec_figure is not None
+    assert bec_figure.client is not None
+    assert isinstance(bec_figure, BECFigure)
+    assert bec_figure.config.widget_class == "BECFigure"
+
+
+def test_bec_figure_init_with_config(mocked_client):
+    config = {
+        "widget_class": "BECFigure",
+        "gui_id": "test_gui_id",
+        "theme": "dark",
+    }
+    widget = BECFigure(client=mocked_client, config=config)
+    assert widget.config.gui_id == "test_gui_id"
+    assert widget.config.theme == "dark"
+
+
+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(widget_id="test_waveform")
+    w2 = bec_figure.add_widget(widget_id="test_plot", widget_type="PlotBase")
+
+    # Check if the widgets were added
+    assert len(bec_figure.widgets) == initial_count + 3
+    assert "widget_1" in bec_figure.widgets
+    assert "test_plot" in bec_figure.widgets
+    assert "test_waveform" in bec_figure.widgets
+    assert bec_figure.widgets["widget_1"].config.widget_class == "BECWaveform1D"
+    assert bec_figure.widgets["test_plot"].config.widget_class == "BECPlotBase"
+    assert bec_figure.widgets["test_waveform"].config.widget_class == "BECWaveform1D"
+
+    # Check accessing positions by the grid in figure
+    assert bec_figure[0, 0] == w0
+    assert bec_figure[1, 0] == w1
+    assert bec_figure[2, 0] == w2
+
+    # Removing 1 widget - PlotBase
+    bec_figure.remove(widget_id="test_plot")
+    assert len(bec_figure.widgets) == initial_count + 2
+    assert "test_plot" not in bec_figure.widgets
+    assert "test_waveform" in bec_figure.widgets
+    assert bec_figure.widgets["test_waveform"].config.widget_class == "BECWaveform1D"
+
+
+def test_access_widgets_access_errors(bec_figure):
+    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+
+    # access widget by non-existent coordinates
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure[0, 2]
+        assert "No widget at coordinates (0, 2)" in str(excinfo.value)
+
+    # access widget by non-existent widget_id
+    with pytest.raises(KeyError) as excinfo:
+        bec_figure["non_existent_widget"]
+        assert "Widget with id 'non_existent_widget' not found" in str(excinfo.value)
+
+    # access widget by wrong type
+    with pytest.raises(TypeError) as excinfo:
+        bec_figure[1.2]
+        assert (
+            "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
+            in str(excinfo.value)
+        )
+
+
+def test_add_plot_to_occupied_position(bec_figure):
+    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=0)
+        assert "Position at row 0 and column 0 is already occupied." in str(excinfo.value)
+
+
+def test_add_plot_to_occupied_id(bec_figure):
+    bec_figure.add_plot(widget_id="test_waveform", row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.add_plot(widget_id="test_waveform", row=0, col=1)
+        assert "Widget with ID 'test_waveform' already exists" in str(excinfo.value)
+
+
+def test_remove_plots(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
+    w3 = bec_figure.add_plot(widget_id="test_waveform_3", row=1, col=0)
+    w4 = bec_figure.add_plot(widget_id="test_waveform_4", row=1, col=1)
+
+    assert bec_figure[0, 0] == w1
+    assert bec_figure[0, 1] == w2
+    assert bec_figure[1, 0] == w3
+    assert bec_figure[1, 1] == w4
+
+    # remove by coordinates
+    bec_figure[0, 0].remove()
+    assert "test_waveform_1" not in bec_figure.widgets
+
+    # remove by widget_id
+    bec_figure.remove(widget_id="test_waveform_2")
+    assert "test_waveform_2" not in bec_figure.widgets
+
+    # remove by widget object
+    w3.remove()
+    assert "test_waveform_3" not in bec_figure.widgets
+
+    # check the remaining widget 4
+    assert bec_figure[0, 0] == w4
+    assert bec_figure["test_waveform_4"] == w4
+    assert "test_waveform_4" in bec_figure.widgets
+    assert len(bec_figure.widgets) == 1
+
+
+def test_remove_plots_by_coordinates_ints(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
+
+    bec_figure.remove(0, 0)
+    assert "test_waveform_1" not in bec_figure.widgets
+    assert "test_waveform_2" in bec_figure.widgets
+    assert bec_figure[0, 0] == w2
+    assert len(bec_figure.widgets) == 1
+
+
+def test_remove_plots_by_coordinates_tuple(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
+
+    bec_figure.remove(coordinates=(0, 0))
+    assert "test_waveform_1" not in bec_figure.widgets
+    assert "test_waveform_2" in bec_figure.widgets
+    assert bec_figure[0, 0] == w2
+    assert len(bec_figure.widgets) == 1
+
+
+def test_remove_plot_by_id_error(bec_figure):
+    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.remove(widget_id="non_existent_widget")
+        assert "Widget with ID 'non_existent_widget' does not exist." in str(excinfo.value)
+
+
+def test_remove_plot_by_coordinates_error(bec_figure):
+    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.remove(0, 1)
+        assert "No widget at coordinates (0, 1)" in str(excinfo.value)
+
+
+def test_remove_plot_by_providing_nothing(bec_figure):
+    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.remove()
+        assert "Must provide either widget_id or coordinates for removal." in str(excinfo.value)
+
+
+def test_change_theme(bec_figure):
+    bec_figure.change_theme("dark")
+    assert bec_figure.config.theme == "dark"
+    assert bec_figure.backgroundBrush().color().name() == "#000000"
+    bec_figure.change_theme("light")
+    assert bec_figure.config.theme == "light"
+    assert bec_figure.backgroundBrush().color().name() == "#ffffff"
+    bec_figure.change_theme("dark")
+    assert bec_figure.config.theme == "dark"
+    assert bec_figure.backgroundBrush().color().name() == "#000000"
+
+
+def test_change_layout(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    w2 = bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
+    w3 = bec_figure.add_plot(widget_id="test_waveform_3", row=1, col=0)
+    w4 = bec_figure.add_plot(widget_id="test_waveform_4", row=1, col=1)
+
+    bec_figure.change_layout(max_columns=1)
+
+    assert np.shape(bec_figure.grid) == (4, 1)
+    assert bec_figure[0, 0] == w1
+    assert bec_figure[1, 0] == w2
+    assert bec_figure[2, 0] == w3
+    assert bec_figure[3, 0] == w4
+
+    bec_figure.change_layout(max_rows=1)
+
+    assert np.shape(bec_figure.grid) == (1, 4)
+    assert bec_figure[0, 0] == w1
+    assert bec_figure[0, 1] == w2
+    assert bec_figure[0, 2] == w3
+    assert bec_figure[0, 3] == w4
+
+
+def test_clear_all(bec_figure):
+    bec_figure.add_plot(widget_id="test_waveform_1", row=0, col=0)
+    bec_figure.add_plot(widget_id="test_waveform_2", row=0, col=1)
+    bec_figure.add_plot(widget_id="test_waveform_3", row=1, col=0)
+    bec_figure.add_plot(widget_id="test_waveform_4", row=1, col=1)
+
+    bec_figure.clear_all()
+
+    assert len(bec_figure.widgets) == 0
+    assert np.shape(bec_figure.grid) == (0,)

tests/test_bec_monitor.py

@@ -80,7 +80,7 @@ def mocked_client():
 
 
 @pytest.fixture(scope="function")
-def monitor(qtbot, mocked_client):
+def monitor(bec_dispatcher, qtbot, mocked_client):
     # client = MagicMock()
     widget = BECMonitor(client=mocked_client)
     qtbot.addWidget(widget)

tests/test_plot_base.py

@@ -0,0 +1,62 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+import pytest
+from .client_mocks import mocked_client
+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")
+    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.set_title("Test Title")
+    plot_base.set_x_label("Test x Label")
+    plot_base.set_y_label("Test y Label")
+    plot_base.set_x_lim(1, 100)
+    plot_base.set_y_lim(5, 500)
+    plot_base.set_grid(True, True)
+    plot_base.set_x_scale("log")
+    plot_base.set_y_scale("log")
+
+    assert plot_base.titleLabel.text == "Test Title"
+    assert plot_base.config.axis.title == "Test Title"
+    assert plot_base.getAxis("bottom").labelText == "Test x Label"
+    assert plot_base.config.axis.x_label == "Test x Label"
+    assert plot_base.getAxis("left").labelText == "Test y Label"
+    assert plot_base.config.axis.y_label == "Test y Label"
+    assert plot_base.config.axis.x_lim == (1, 100)
+    assert plot_base.config.axis.y_lim == (5, 500)
+    assert plot_base.ctrl.xGridCheck.isChecked() == True
+    assert plot_base.ctrl.yGridCheck.isChecked() == True
+    assert plot_base.ctrl.logXCheck.isChecked() == True
+    assert plot_base.ctrl.logYCheck.isChecked() == True
+
+
+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.set(
+        title="Test Title",
+        x_label="Test x Label",
+        y_label="Test y Label",
+        x_lim=(1, 100),
+        y_lim=(5, 500),
+        x_scale="log",
+        y_scale="log",
+    )
+
+    assert plot_base.titleLabel.text == "Test Title"
+    assert plot_base.config.axis.title == "Test Title"
+    assert plot_base.getAxis("bottom").labelText == "Test x Label"
+    assert plot_base.config.axis.x_label == "Test x Label"
+    assert plot_base.getAxis("left").labelText == "Test y Label"
+    assert plot_base.config.axis.y_label == "Test y Label"
+    assert plot_base.config.axis.x_lim == (1, 100)
+    assert plot_base.config.axis.y_lim == (5, 500)
+    assert plot_base.ctrl.logXCheck.isChecked() == True
+    assert plot_base.ctrl.logYCheck.isChecked() == True

tests/test_problem.py

@@ -0,0 +1,26 @@
+import pytest
+
+from bec_widgets.cli.client import BECFigure
+from bec_widgets.cli.server import BECWidgetsCLIServer
+from bec_widgets.utils.bec_dispatcher import _BECDispatcher
+
+
+@pytest.fixture
+def rpc_server(qtbot):
+    # make a new dispatcher (not using the singleton), since the server is supposed to run in another process
+    dispatcher = _BECDispatcher()
+    server = BECWidgetsCLIServer(gui_id="id_test", dispatcher=dispatcher)
+    qtbot.addWidget(server.fig)
+    qtbot.waitExposed(server.fig)
+    qtbot.wait(200)
+    yield server
+    server.client.shutdown()
+
+
+def test_rpc_waveform1d(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.gui_id)
+    ax = fig.add_plot()
+    curve = ax.add_curve_custom([1, 2, 3], [1, 2, 3])
+    curve.set_color("red")
+    curve = ax.curves[0]
+    curve.set_color("blue")

tests/test_waveform1d.py

@@ -0,0 +1,411 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+from bec_widgets.widgets.plots.waveform1d import SignalData, Signal, CurveConfig
+from .client_mocks import mocked_client
+from .test_bec_figure import bec_figure
+
+
+def test_adding_curve_to_waveform(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    # adding curve which is in bec - only names
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+    assert c1.config.label == "bpm4i-bpm4i"
+
+    # adding curve which is in bec - names and entry
+    c2 = w1.add_curve_scan(x_name="samx", x_entry="samx", y_name="bpm3a", y_entry="bpm3a")
+    assert c2.config.label == "bpm3a-bpm3a"
+
+    # adding curve which is not in bec
+    with pytest.raises(ValueError) as excinfo:
+        w1.add_curve_scan(x_name="non_existent_device", y_name="non_existent_device")
+    assert "Device 'non_existent_device' not found in current BEC session" in str(excinfo.value)
+
+    # adding wrong entry for samx
+    with pytest.raises(ValueError) as excinfo:
+        w1.add_curve_scan(
+            x_name="samx", x_entry="non_existent_entry", y_name="bpm3a", y_entry="bpm3a"
+        )
+    assert "Entry 'non_existent_entry' not found in device 'samx' signals" in str(excinfo.value)
+
+    # adding wrong device with validation switched off
+    c3 = w1.add_curve_scan(x_name="samx", y_name="non_existent_device", validate_bec=False)
+    assert c3.config.label == "non_existent_device-non_existent_device"
+
+
+def test_adding_curve_with_same_id(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
+
+    with pytest.raises(ValueError) as excinfo:
+        w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
+        assert "Curve with ID 'test_curve' already exists." in str(excinfo.value)
+
+
+def test_create_waveform1D_by_config(bec_figure):
+    w1_config_input = {
+        "widget_class": "BECWaveform1D",
+        "gui_id": "widget_1",
+        "parent_id": "BECFigure_1708689320.788527",
+        "row": 0,
+        "col": 0,
+        "axis": {
+            "title": "Widget 1",
+            "x_label": None,
+            "y_label": None,
+            "x_scale": "linear",
+            "y_scale": "linear",
+            "x_lim": (1, 10),
+            "y_lim": None,
+            "x_grid": False,
+            "y_grid": False,
+        },
+        "color_palette": "plasma",
+        "curves": {
+            "bpm4i-bpm4i": {
+                "widget_class": "BECCurve",
+                "gui_id": "BECCurve_1708689321.226847",
+                "parent_id": "widget_1",
+                "label": "bpm4i-bpm4i",
+                "color": "#cc4778",
+                "symbol": "o",
+                "symbol_color": None,
+                "symbol_size": 5,
+                "pen_width": 2,
+                "pen_style": "dash",
+                "source": "scan_segment",
+                "signals": {
+                    "source": "scan_segment",
+                    "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
+                    "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+                },
+            },
+            "curve-custom": {
+                "widget_class": "BECCurve",
+                "gui_id": "BECCurve_1708689321.22867",
+                "parent_id": "widget_1",
+                "label": "curve-custom",
+                "color": "blue",
+                "symbol": "o",
+                "symbol_color": None,
+                "symbol_size": 5,
+                "pen_width": 2,
+                "pen_style": "dashdot",
+                "source": "custom",
+                "signals": None,
+            },
+        },
+    }
+
+    w1 = bec_figure.add_plot(widget_id="test_waveform", config=w1_config_input)
+
+    w1_config_output = w1.get_config()
+
+    assert w1_config_input == w1_config_output
+    assert w1.titleLabel.text == "Widget 1"
+    assert w1.config.axis.title == "Widget 1"
+
+
+def test_change_gui_id(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+    w1.change_gui_id("new_id")
+
+    assert w1.config.gui_id == "new_id"
+    assert c1.config.parent_id == "new_id"
+
+
+def test_getting_curve(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
+    c1_expected_config = CurveConfig(
+        widget_class="BECCurve",
+        gui_id="test_curve",
+        parent_id="test_waveform",
+        label="bpm4i-bpm4i",
+        color="#cc4778",
+        symbol="o",
+        symbol_color=None,
+        symbol_size=5,
+        pen_width=2,
+        pen_style="solid",
+        source="scan_segment",
+        signals=Signal(
+            source="scan_segment",
+            x=SignalData(name="samx", entry="samx", unit=None, modifier=None),
+            y=SignalData(name="bpm4i", entry="bpm4i", unit=None, modifier=None),
+        ),
+    )
+
+    assert w1.curves[0].config == c1_expected_config
+    assert w1.curves_data["scan_segment"]["bpm4i-bpm4i"].config == c1_expected_config
+    assert w1.get_curve(0).config == c1_expected_config
+    assert w1.get_curve("bpm4i-bpm4i").config == c1_expected_config
+    assert c1.get_config(False) == c1_expected_config
+    assert c1.get_config() == c1_expected_config.model_dump()
+
+
+def test_getting_curve_errors(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i", gui_id="test_curve")
+
+    with pytest.raises(ValueError) as excinfo:
+        w1.get_curve("non_existent_curve")
+        assert "Curve with ID 'non_existent_curve' not found." in str(excinfo.value)
+    with pytest.raises(IndexError) as excinfo:
+        w1.get_curve(1)
+        assert "list index out of range" in str(excinfo.value)
+    with pytest.raises(ValueError) as excinfo:
+        w1.get_curve(1.2)
+        assert "Identifier must be either an integer (index) or a string (curve_id)." in str(
+            excinfo.value
+        )
+
+
+def test_add_curve(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+
+    assert len(w1.curves) == 1
+    assert w1.curves_data["scan_segment"] == {"bpm4i-bpm4i": c1}
+    assert c1.config.label == "bpm4i-bpm4i"
+    assert c1.config.source == "scan_segment"
+
+
+def test_remove_curve(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+    w1.add_curve_scan(x_name="samx", y_name="bpm3a")
+    w1.remove_curve(0)
+    w1.remove_curve("bpm3a-bpm3a")
+
+    assert len(w1.curves) == 0
+    assert w1.curves_data["scan_segment"] == {}
+
+    with pytest.raises(ValueError) as excinfo:
+        w1.remove_curve(1.2)
+        assert "Each identifier must be either an integer (index) or a string (curve_id)." in str(
+            excinfo.value
+        )
+
+
+def test_change_curve_appearance_methods(bec_figure, qtbot):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+
+    c1.set_color("#0000ff")
+    c1.set_symbol("x")
+    c1.set_symbol_color("#ff0000")
+    c1.set_symbol_size(10)
+    c1.set_pen_width(3)
+    c1.set_pen_style("dashdot")
+
+    qtbot.wait(500)
+    assert c1.config.color == "#0000ff"
+    assert c1.config.symbol == "x"
+    assert c1.config.symbol_color == "#ff0000"
+    assert c1.config.symbol_size == 10
+    assert c1.config.pen_width == 3
+    assert c1.config.pen_style == "dashdot"
+    assert c1.config.source == "scan_segment"
+    assert c1.config.signals.model_dump() == {
+        "source": "scan_segment",
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
+        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+    }
+
+
+def test_change_curve_appearance_args(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+
+    c1.set(
+        color="#0000ff",
+        symbol="x",
+        symbol_color="#ff0000",
+        symbol_size=10,
+        pen_width=3,
+        pen_style="dashdot",
+    )
+
+    assert c1.config.color == "#0000ff"
+    assert c1.config.symbol == "x"
+    assert c1.config.symbol_color == "#ff0000"
+    assert c1.config.symbol_size == 10
+    assert c1.config.pen_width == 3
+    assert c1.config.pen_style == "dashdot"
+    assert c1.config.source == "scan_segment"
+    assert c1.config.signals.model_dump() == {
+        "source": "scan_segment",
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
+        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+    }
+
+
+def test_set_custom_curve_data(bec_figure, qtbot):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    c1 = w1.add_curve_custom(
+        x=[1, 2, 3],
+        y=[4, 5, 6],
+        label="custom_curve",
+        color="#0000ff",
+        symbol="x",
+        symbol_color="#ff0000",
+        symbol_size=10,
+        pen_width=3,
+        pen_style="dashdot",
+    )
+
+    x_init, y_init = c1.get_data()
+
+    assert np.array_equal(x_init, [1, 2, 3])
+    assert np.array_equal(y_init, [4, 5, 6])
+    assert c1.config.label == "custom_curve"
+    assert c1.config.color == "#0000ff"
+    assert c1.config.symbol == "x"
+    assert c1.config.symbol_color == "#ff0000"
+    assert c1.config.symbol_size == 10
+    assert c1.config.pen_width == 3
+    assert c1.config.pen_style == "dashdot"
+    assert c1.config.source == "custom"
+    assert c1.config.signals == None
+
+    c1.set_data(x=[4, 5, 6], y=[7, 8, 9])
+
+    x_new, y_new = c1.get_data()
+    assert np.array_equal(x_new, [4, 5, 6])
+    assert np.array_equal(y_new, [7, 8, 9])
+
+
+def test_get_all_data(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    c1 = w1.add_curve_custom(
+        x=[1, 2, 3],
+        y=[4, 5, 6],
+        label="custom_curve-1",
+        color="#0000ff",
+        symbol="x",
+        symbol_color="#ff0000",
+        symbol_size=10,
+        pen_width=3,
+        pen_style="dashdot",
+    )
+
+    c2 = w1.add_curve_custom(
+        x=[4, 5, 6],
+        y=[7, 8, 9],
+        label="custom_curve-2",
+        color="#00ff00",
+        symbol="o",
+        symbol_color="#00ff00",
+        symbol_size=20,
+        pen_width=4,
+        pen_style="dash",
+    )
+
+    all_data = w1.get_all_data()
+
+    assert all_data == {
+        "custom_curve-1": {"x": [1, 2, 3], "y": [4, 5, 6]},
+        "custom_curve-2": {"x": [4, 5, 6], "y": [7, 8, 9]},
+    }
+
+
+def test_curve_add_by_config(bec_figure):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    c1_config_input = {
+        "widget_class": "BECCurve",
+        "gui_id": "BECCurve_1708689321.226847",
+        "parent_id": "widget_1",
+        "label": "bpm4i-bpm4i",
+        "color": "#cc4778",
+        "symbol": "o",
+        "symbol_color": None,
+        "symbol_size": 5,
+        "pen_width": 2,
+        "pen_style": "dash",
+        "source": "scan_segment",
+        "signals": {
+            "source": "scan_segment",
+            "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None},
+            "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None},
+        },
+    }
+
+    c1 = w1.add_curve_by_config(c1_config_input)
+
+    c1_config_dict = c1.get_config()
+
+    assert c1_config_dict == c1_config_input
+    assert c1.config == CurveConfig(**c1_config_input)
+    assert c1.get_config(False) == CurveConfig(**c1_config_input)
+
+
+def test_scan_update(bec_figure, qtbot):
+    w1 = bec_figure.add_plot(widget_id="test_waveform")
+
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+
+    msg_waveform = {
+        "data": {
+            "samx": {"samx": {"value": 10}},
+            "bpm4i": {"bpm4i": {"value": 5}},
+            "gauss_bpm": {"gauss_bpm": {"value": 6}},
+            "gauss_adc1": {"gauss_adc1": {"value": 8}},
+            "gauss_adc2": {"gauss_adc2": {"value": 9}},
+        },
+        "scanID": 1,
+    }
+    # Mock scan_storage.find_scan_by_ID
+    mock_scan_data_waveform = MagicMock()
+    mock_scan_data_waveform.data = {
+        device_name: {
+            entry: MagicMock(val=[msg_waveform["data"][device_name][entry]["value"]])
+            for entry in msg_waveform["data"][device_name]
+        }
+        for device_name in msg_waveform["data"]
+    }
+
+    metadata_waveform = {"scan_name": "line_scan"}
+
+    w1.queue.scan_storage.find_scan_by_ID.return_value = mock_scan_data_waveform
+
+    w1.on_scan_segment(msg_waveform, metadata_waveform)
+    qtbot.wait(500)
+    assert c1.get_data() == ([10], [5])
+
+
+def test_scan_history_with_val_access(bec_figure, qtbot):
+    w1 = bec_figure.add_plot(widget_id="test_waveform_history_val")
+
+    c1 = w1.add_curve_scan(x_name="samx", y_name="bpm4i")
+
+    mock_scan_data = {
+        "samx": {"samx": MagicMock(val=np.array([1, 2, 3]))},  # Use MagicMock for .val
+        "bpm4i": {"bpm4i": MagicMock(val=np.array([4, 5, 6]))},  # Use MagicMock for .val
+    }
+
+    mock_scan_storage = MagicMock()
+    mock_scan_storage.find_scan_by_ID.return_value = MagicMock(data=mock_scan_data)
+    w1.queue.scan_storage = mock_scan_storage
+
+    fake_scanID = "fake_scanID"
+    w1.scan_history(scanID=fake_scanID)
+
+    qtbot.wait(500)
+
+    x_data, y_data = c1.get_data()
+
+    assert np.array_equal(x_data, [1, 2, 3])
+    assert np.array_equal(y_data, [4, 5, 6])