bec-widgets 0.59.0__py3-none-any.whl → 0.60.0__py3-none-any.whl

bec_widgets/cli/client.py

@@ -1,11 +1,39 @@
 # This file was automatically generated by generate_cli.py
 
+import enum
 from typing import Literal, Optional, overload
 
 from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
 
+# pylint: skip-file
+
+
+class Widgets(str, enum.Enum):
+    """
+    Enum for the available widgets.
+    """
+
+    BECDock = "BECDock"
+    BECDockArea = "BECDockArea"
+    BECFigure = "BECFigure"
+    SpiralProgressBar = "SpiralProgressBar"
+    WebsiteWidget = "WebsiteWidget"
+
+
+class BECCurve(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        Remove the curve from the plot.
+        """
+
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
 
-class BECPlotBase(RPCBase):
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -17,125 +45,112 @@ class BECPlotBase(RPCBase):
         """
 
     @rpc_call
-    def set(self, **kwargs) -> "None":
+    def set(self, **kwargs):
         """
-        Set the properties of the plot widget.
+        Set the properties of the curve.
 
         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
+            - color: str
+            - symbol: str
+            - symbol_color: str
+            - symbol_size: int
+            - pen_width: int
+            - pen_style: Literal["solid", "dash", "dot", "dashdot"]
         """
 
     @rpc_call
-    def set_title(self, title: "str"):
+    def set_data(self, x, y):
         """
-        Set the title of the plot widget.
-
-        Args:
-            title(str): Title of the plot widget.
+        None
         """
 
     @rpc_call
-    def set_x_label(self, label: "str"):
+    def set_color(self, color: "str", symbol_color: "Optional[str]" = None):
         """
-        Set the label of the x-axis.
+        Change the color of the curve.
 
         Args:
-            label(str): Label of the x-axis.
+            color(str): Color of the curve.
+            symbol_color(str, optional): Color of the symbol. Defaults to None.
         """
 
     @rpc_call
-    def set_y_label(self, label: "str"):
+    def set_color_map_z(self, colormap: "str"):
         """
-        Set the label of the y-axis.
+        Set the colormap for the scatter plot z gradient.
 
         Args:
-            label(str): Label of the y-axis.
+            colormap(str): Colormap for the scatter plot.
         """
 
     @rpc_call
-    def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
+    def set_symbol(self, symbol: "str"):
         """
-        Set the scale of the x-axis.
+        Change the symbol of the curve.
 
         Args:
-            scale(Literal["linear", "log"]): Scale of the x-axis.
+            symbol(str): Symbol of the curve.
         """
 
     @rpc_call
-    def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
+    def set_symbol_color(self, symbol_color: "str"):
         """
-        Set the scale of the y-axis.
+        Change the symbol color of the curve.
 
         Args:
-            scale(Literal["linear", "log"]): Scale of the y-axis.
+            symbol_color(str): Color of the symbol.
         """
 
     @rpc_call
-    def set_x_lim(self, *args) -> "None":
+    def set_symbol_size(self, symbol_size: "int"):
         """
-        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))
+        Change the symbol size of the curve.
 
         Args:
-            *args: A variable number of arguments. Can be two integers (x_min and x_max)
-                   or a single tuple with two integers.
+            symbol_size(int): Size of the symbol.
         """
 
     @rpc_call
-    def set_y_lim(self, *args) -> "None":
+    def set_pen_width(self, pen_width: "int"):
         """
-        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))
+        Change the pen width of the curve.
 
         Args:
-            *args: A variable number of arguments. Can be two integers (y_min and y_max)
-                   or a single tuple with two integers.
+            pen_width(int): Width of the pen.
         """
 
     @rpc_call
-    def set_grid(self, x: "bool" = False, y: "bool" = False):
+    def set_pen_style(self, pen_style: "Literal['solid', 'dash', 'dot', 'dashdot']"):
         """
-        Set the grid of the plot widget.
+        Change the pen style of the curve.
 
         Args:
-            x(bool): Show grid on the x-axis.
-            y(bool): Show grid on the y-axis.
+            pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
         """
 
     @rpc_call
-    def lock_aspect_ratio(self, lock):
+    def get_data(self) -> "tuple[np.ndarray, np.ndarray]":
         """
-        Lock aspect ratio.
-
-        Args:
-            lock(bool): True to lock, False to unlock.
+        Get the data of the curve.
+        Returns:
+            tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
         """
 
+
+class BECDock(RPCBase):
+    @property
     @rpc_call
-    def remove(self):
-        """
-        Remove the plot widget from the figure.
+    def config_dict(self) -> "dict":
         """
+        Get the configuration of the widget.
 
+        Returns:
+            dict: The configuration of the widget.
+        """
 
-class BECWaveform(RPCBase):
     @property
     @rpc_call
     def rpc_id(self) -> "str":
@@ -145,277 +160,238 @@ class BECWaveform(RPCBase):
 
     @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def widget_list(self) -> "list[BECConnector]":
         """
-        Get the configuration of the widget.
+        Get the widgets in the dock.
 
         Returns:
-            dict: The configuration of the widget.
+            widgets(list): The widgets in the dock.
         """
 
     @rpc_call
-    def plot(
-        self,
-        x: "list | np.ndarray | None" = None,
-        y: "list | np.ndarray | None" = None,
-        x_name: "str | None" = None,
-        y_name: "str | None" = None,
-        z_name: "str | None" = None,
-        x_entry: "str | None" = None,
-        y_entry: "str | None" = None,
-        z_entry: "str | None" = None,
-        color: "str | None" = None,
-        color_map_z: "str | None" = "plasma",
-        label: "str | None" = None,
-        validate: "bool" = True,
-    ) -> "BECCurve":
+    def show_title_bar(self):
         """
-        Plot a curve to the plot widget.
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
+        Hide the title bar of the dock.
+        """
+
+    @rpc_call
+    def hide_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+
+    @rpc_call
+    def get_widgets_positions(self) -> "dict":
+        """
+        Get the positions of the widgets in the dock.
 
         Returns:
-            BECCurve: The curve object.
+            dict: The positions of the widgets in the dock as dict -> {(row, col, rowspan, colspan):widget}
         """
 
     @rpc_call
-    def remove_curve(self, *identifiers):
+    def set_title(self, title: "str"):
         """
-        Remove a curve from the plot widget.
+        Set the title of the dock.
 
         Args:
-            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
+            title(str): The title of the dock.
         """
 
     @rpc_call
-    def scan_history(self, scan_index: "int" = None, scan_id: "str" = None):
+    def add_widget(
+        self,
+        widget: "BECConnector | str",
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: "Literal['down', 'up', 'left', 'right']" = "down",
+    ) -> "BECConnector":
         """
-        Update the scan curves with the data from the scan storage.
-        Provide only one of scan_id or scan_index.
+        Add a widget to the dock.
 
         Args:
-            scan_id(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.
+            widget(QWidget): The widget to add.
+            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
+            col(int): The column to add the widget to.
+            rowspan(int): The number of rows the widget should span.
+            colspan(int): The number of columns the widget should span.
+            shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
         """
 
-    @property
     @rpc_call
-    def curves(self) -> "list[BECCurve]":
+    def list_eligible_widgets(self) -> "list":
         """
-        Get the curves of the plot widget as a list
+        List all widgets that can be added to the dock.
+
         Returns:
-            list: List of curves.
+            list: The list of eligible widgets.
         """
 
     @rpc_call
-    def get_curve(self, identifier) -> "BECCurve":
+    def move_widget(self, widget: "QWidget", new_row: "int", new_col: "int"):
         """
-        Get the curve by its index or ID.
+        Move a widget to a new position in the layout.
 
         Args:
-            identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
-
-        Returns:
-            BECCurve: The curve object.
+            widget(QWidget): The widget to move.
+            new_row(int): The new row to move the widget to.
+            new_col(int): The new column to move the widget to.
         """
 
     @rpc_call
-    def get_curve_config(self, curve_id: "str", dict_output: "bool" = True) -> "CurveConfig | dict":
+    def remove_widget(self, widget_rpc_id: "str"):
         """
-        Get the configuration of a curve by its ID.
+        Remove a widget from the dock.
 
         Args:
-            curve_id(str): ID of the curve.
-
-        Returns:
-            CurveConfig|dict: Configuration of the curve.
+            widget_rpc_id(str): The ID of the widget to remove.
         """
 
     @rpc_call
-    def apply_config(self, config: "dict | SubplotConfig", replot_last_scan: "bool" = False):
+    def remove(self):
+        """
+        Remove the dock from the parent dock area.
         """
-        Apply the configuration to the 1D waveform widget.
 
-        Args:
-            config(dict|SubplotConfig): Configuration settings.
-            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
+    @rpc_call
+    def attach(self):
+        """
+        Attach the dock to the parent dock area.
         """
 
     @rpc_call
-    def get_all_data(self, output: "Literal['dict', 'pandas']" = "dict") -> "dict | pd.DataFrame":
+    def detach(self):
+        """
+        Detach the dock from the parent dock area.
         """
-        Extract all curve data into a dictionary or a pandas DataFrame.
 
-        Args:
-            output (Literal["dict", "pandas"]): Format of the output data.
+
+class BECDockArea(RPCBase, BECGuiClientMixin):
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
 
         Returns:
-            dict | pd.DataFrame: Data of all curves in the specified format.
+            dict: The configuration of the widget.
         """
 
+    @property
     @rpc_call
-    def set(self, **kwargs) -> "None":
+    def panels(self) -> "dict[str, BECDock]":
         """
-        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
+        Get the docks in the dock area.
+        Returns:
+            dock_dict(dict): The docks in the dock area.
         """
 
     @rpc_call
-    def set_title(self, title: "str"):
+    def save_state(self) -> "dict":
         """
-        Set the title of the plot widget.
+        Save the state of the dock area.
 
-        Args:
-            title(str): Title of the plot widget.
+        Returns:
+            dict: The state of the dock area.
         """
 
     @rpc_call
-    def set_x_label(self, label: "str"):
+    def remove_dock(self, name: "str"):
         """
-        Set the label of the x-axis.
+        Remove a dock by name and ensure it is properly closed and cleaned up.
 
         Args:
-            label(str): Label of the x-axis.
+            name(str): The name of the dock to remove.
         """
 
     @rpc_call
-    def set_y_label(self, label: "str"):
+    def restore_state(
+        self, state: "dict" = None, missing: "Literal['ignore', 'error']" = "ignore", extra="bottom"
+    ):
         """
-        Set the label of the y-axis.
+        Restore the state of the dock area. If no state is provided, the last state is restored.
 
         Args:
-            label(str): Label of the y-axis.
+            state(dict): The state to restore.
+            missing(Literal['ignore','error']): What to do if a dock is missing.
+            extra(str): Extra docks that are in the dockarea but that are not mentioned in state will be added to the bottom of the dockarea, unless otherwise specified by the extra argument.
         """
 
     @rpc_call
-    def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
+    def add_dock(
+        self,
+        name: "str" = None,
+        position: "Literal['bottom', 'top', 'left', 'right', 'above', 'below']" = None,
+        relative_to: "BECDock | None" = None,
+        closable: "bool" = False,
+        floating: "bool" = False,
+        prefix: "str" = "dock",
+        widget: "str | QWidget | None" = None,
+        row: "int" = None,
+        col: "int" = 0,
+        rowspan: "int" = 1,
+        colspan: "int" = 1,
+    ) -> "BECDock":
         """
-        Set the scale of the x-axis.
+        Add a dock to the dock area. Dock has QGridLayout as layout manager by default.
 
         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.
+            name(str): The name of the dock to be displayed and for further references. Has to be unique.
+            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
+            relative_to(BECDock): The dock to which the new dock should be added relative to.
+            closable(bool): Whether the dock is closable.
+            floating(bool): Whether the dock is detached after creating.
+            prefix(str): The prefix for the dock name if no name is provided.
+            widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
+            row(int): The row of the added widget.
+            col(int): The column of the added widget.
+            rowspan(int): The rowspan of the added widget.
+            colspan(int): The colspan of the added widget.
 
-        Args:
-            scale(Literal["linear", "log"]): Scale of the y-axis.
+        Returns:
+            BECDock: The created dock.
         """
 
     @rpc_call
-    def set_x_lim(self, *args) -> "None":
+    def clear_all(self):
         """
-        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.
+        Close all docks and remove all temp areas.
         """
 
     @rpc_call
-    def set_y_lim(self, *args) -> "None":
+    def detach_dock(self, dock_name: "str") -> "BECDock":
         """
-        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))
+        Undock a dock from the dock area.
 
         Args:
-            *args: A variable number of arguments. Can be two integers (y_min and y_max)
-                   or a single tuple with two integers.
+            dock_name(str): The dock to undock.
+
+        Returns:
+            BECDock: The undocked dock.
         """
 
     @rpc_call
-    def set_grid(self, x: "bool" = False, y: "bool" = False):
+    def attach_all(self):
         """
-        Set the grid of the plot widget.
-
-        Args:
-            x(bool): Show grid on the x-axis.
-            y(bool): Show grid on the y-axis.
+        Return all floating docks to the dock area.
         """
 
     @rpc_call
-    def lock_aspect_ratio(self, lock):
+    def get_all_rpc(self) -> "dict":
         """
-        Lock aspect ratio.
-
-        Args:
-            lock(bool): True to lock, False to unlock.
+        Get all registered RPC objects.
         """
 
+    @property
     @rpc_call
-    def plot(
-        self,
-        x: "list | np.ndarray | None" = None,
-        y: "list | np.ndarray | None" = None,
-        x_name: "str | None" = None,
-        y_name: "str | None" = None,
-        z_name: "str | None" = None,
-        x_entry: "str | None" = None,
-        y_entry: "str | None" = None,
-        z_entry: "str | None" = None,
-        color: "str | None" = None,
-        color_map_z: "str | None" = "plasma",
-        label: "str | None" = None,
-        validate: "bool" = True,
-    ) -> "BECCurve":
+    def temp_areas(self) -> "list":
         """
-        Plot a curve to the plot widget.
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
+        Get the temporary areas in the dock area.
 
         Returns:
-            BECCurve: The curve object.
-        """
-
-    @rpc_call
-    def remove(self):
-        """
-        Remove the plot widget from the figure.
+            list: The temporary areas in the dock area.
         """
 
 
@@ -695,13 +671,7 @@ class BECFigure(RPCBase):
         """
 
 
-class BECCurve(RPCBase):
-    @rpc_call
-    def remove(self):
-        """
-        Remove the curve from the plot.
-        """
-
+class BECImageItem(RPCBase):
     @property
     @rpc_call
     def rpc_id(self) -> "str":
@@ -722,105 +692,131 @@ class BECCurve(RPCBase):
     @rpc_call
     def set(self, **kwargs):
         """
-        Set the properties of the curve.
+        Set the properties of the image.
 
         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"]
+            - downsample
+            - color_map
+            - monitor
+            - opacity
+            - vrange
+            - fft
+            - log
+            - rot
+            - transpose
         """
 
     @rpc_call
-    def set_data(self, x, y):
+    def set_fft(self, enable: "bool" = False):
         """
-        None
+        Set the FFT of the image.
+
+        Args:
+            enable(bool): Whether to perform FFT on the monitor data.
         """
 
     @rpc_call
-    def set_color(self, color: "str", symbol_color: "Optional[str]" = None):
+    def set_log(self, enable: "bool" = False):
         """
-        Change the color of the curve.
+        Set the log of the image.
 
         Args:
-            color(str): Color of the curve.
-            symbol_color(str, optional): Color of the symbol. Defaults to None.
+            enable(bool): Whether to perform log on the monitor data.
         """
 
     @rpc_call
-    def set_colormap_z(self, colormap: "str"):
+    def set_rotation(self, deg_90: "int" = 0):
         """
-        Set the colormap for the scatter plot z gradient.
+        Set the rotation of the image.
 
         Args:
-            colormap(str): Colormap for the scatter plot.
+            deg_90(int): The rotation angle of the monitor data before displaying.
         """
 
     @rpc_call
-    def set_symbol(self, symbol: "str"):
+    def set_transpose(self, enable: "bool" = False):
         """
-        Change the symbol of the curve.
+        Set the transpose of the image.
 
         Args:
-            symbol(str): Symbol of the curve.
+            enable(bool): Whether to transpose the image.
         """
 
     @rpc_call
-    def set_symbol_color(self, symbol_color: "str"):
+    def set_opacity(self, opacity: "float" = 1.0):
         """
-        Change the symbol color of the curve.
+        Set the opacity of the image.
 
         Args:
-            symbol_color(str): Color of the symbol.
+            opacity(float): The opacity of the image.
         """
 
     @rpc_call
-    def set_symbol_size(self, symbol_size: "int"):
+    def set_autorange(self, autorange: "bool" = False):
         """
-        Change the symbol size of the curve.
+        Set the autorange of the color bar.
 
         Args:
-            symbol_size(int): Size of the symbol.
+            autorange(bool): Whether to autorange the color bar.
         """
 
     @rpc_call
-    def set_pen_width(self, pen_width: "int"):
+    def set_color_map(self, cmap: "str" = "magma"):
         """
-        Change the pen width of the curve.
+        Set the color map of the image.
 
         Args:
-            pen_width(int): Width of the pen.
+            cmap(str): The color map of the image.
         """
 
     @rpc_call
-    def set_pen_style(self, pen_style: "Literal['solid', 'dash', 'dot', 'dashdot']"):
+    def set_auto_downsample(self, auto: "bool" = True):
         """
-        Change the pen style of the curve.
+        Set the auto downsample of the image.
 
         Args:
-            pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
+            auto(bool): Whether to downsample the image.
         """
 
     @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.
+    def set_monitor(self, monitor: "str"):
         """
+        Set the monitor of the image.
 
+        Args:
+            monitor(str): The name of the monitor.
+        """
 
-class BECImageShow(RPCBase):
-    @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def set_vrange(
+        self, vmin: "float" = None, vmax: "float" = None, vrange: "tuple[int, int]" = None
+    ):
         """
-        Get the RPC ID of the widget.
+        Set the range of the color bar.
+
+        Args:
+            vmin(float): Minimum value of the color bar.
+            vmax(float): Maximum value of the color bar.
+        """
+
+    @rpc_call
+    def get_data(self) -> "np.ndarray":
+        """
+        Get the data of the image.
+        Returns:
+            np.ndarray: The data of the image.
+        """
+
+
+class BECImageShow(RPCBase):
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
         """
 
     @property
@@ -1159,7 +1155,7 @@ class BECImageShow(RPCBase):
         """
 
 
-class BECConnector(RPCBase):
+class BECMotorMap(RPCBase):
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -1171,20 +1167,80 @@ class BECConnector(RPCBase):
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def change_motors(
+        self,
+        motor_x: "str",
+        motor_y: "str",
+        motor_x_entry: "str" = None,
+        motor_y_entry: "str" = None,
+        validate_bec: "bool" = True,
+    ) -> "None":
         """
-        Get all registered RPC objects.
+        Change the active motors for the plot.
+
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+
+    @rpc_call
+    def set_max_points(self, max_points: "int") -> "None":
         """
+        Set the maximum number of points to display.
 
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
 
-class BECImageItem(RPCBase):
-    @property
     @rpc_call
-    def rpc_id(self) -> "str":
+    def set_precision(self, precision: "int") -> "None":
         """
-        Get the RPC ID of the widget.
+        Set the decimal precision of the motor position.
+
+        Args:
+            precision(int): Decimal precision of the motor position.
         """
 
+    @rpc_call
+    def set_num_dim_points(self, num_dim_points: "int") -> "None":
+        """
+        Set the number of dim points for the motor map.
+
+        Args:
+            num_dim_points(int): Number of dim points.
+        """
+
+    @rpc_call
+    def set_background_value(self, background_value: "int") -> "None":
+        """
+        Set the background value of the motor map.
+
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+
+    @rpc_call
+    def set_scatter_size(self, scatter_size: "int") -> "None":
+        """
+        Set the scatter size of the motor map plot.
+
+        Args:
+            scatter_size(int): Size of the scatter points.
+        """
+
+    @rpc_call
+    def get_data(self) -> "dict":
+        """
+        Get the data of the motor map.
+        Returns:
+            dict: Data of the motor map.
+        """
+
+
+class BECPlotBase(RPCBase):
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -1196,128 +1252,132 @@ class BECImageItem(RPCBase):
         """
 
     @rpc_call
-    def set(self, **kwargs):
+    def set(self, **kwargs) -> "None":
         """
-        Set the properties of the image.
+        Set the properties of the plot widget.
 
         Args:
             **kwargs: Keyword arguments for the properties to be set.
 
         Possible properties:
-            - downsample
-            - color_map
-            - monitor
-            - opacity
-            - vrange
-            - fft
-            - log
-            - rot
-            - transpose
+            - 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_fft(self, enable: "bool" = False):
+    def set_title(self, title: "str"):
         """
-        Set the FFT of the image.
+        Set the title of the plot widget.
 
         Args:
-            enable(bool): Whether to perform FFT on the monitor data.
+            title(str): Title of the plot widget.
         """
 
     @rpc_call
-    def set_log(self, enable: "bool" = False):
+    def set_x_label(self, label: "str"):
         """
-        Set the log of the image.
+        Set the label of the x-axis.
 
         Args:
-            enable(bool): Whether to perform log on the monitor data.
+            label(str): Label of the x-axis.
         """
 
     @rpc_call
-    def set_rotation(self, deg_90: "int" = 0):
+    def set_y_label(self, label: "str"):
         """
-        Set the rotation of the image.
+        Set the label of the y-axis.
 
         Args:
-            deg_90(int): The rotation angle of the monitor data before displaying.
+            label(str): Label of the y-axis.
         """
 
     @rpc_call
-    def set_transpose(self, enable: "bool" = False):
+    def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
         """
-        Set the transpose of the image.
+        Set the scale of the x-axis.
 
         Args:
-            enable(bool): Whether to transpose the image.
+            scale(Literal["linear", "log"]): Scale of the x-axis.
         """
 
     @rpc_call
-    def set_opacity(self, opacity: "float" = 1.0):
+    def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
         """
-        Set the opacity of the image.
+        Set the scale of the y-axis.
 
         Args:
-            opacity(float): The opacity of the image.
+            scale(Literal["linear", "log"]): Scale of the y-axis.
         """
 
     @rpc_call
-    def set_autorange(self, autorange: "bool" = False):
+    def set_x_lim(self, *args) -> "None":
         """
-        Set the autorange of the color bar.
+        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:
-            autorange(bool): Whether to autorange the color bar.
+            *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_color_map(self, cmap: "str" = "magma"):
+    def set_y_lim(self, *args) -> "None":
         """
-        Set the color map of the image.
+        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:
-            cmap(str): The color map of the image.
+            *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_auto_downsample(self, auto: "bool" = True):
+    def set_grid(self, x: "bool" = False, y: "bool" = False):
         """
-        Set the auto downsample of the image.
+        Set the grid of the plot widget.
 
         Args:
-            auto(bool): Whether to downsample the image.
+            x(bool): Show grid on the x-axis.
+            y(bool): Show grid on the y-axis.
         """
 
     @rpc_call
-    def set_monitor(self, monitor: "str"):
+    def lock_aspect_ratio(self, lock):
         """
-        Set the monitor of the image.
+        Lock aspect ratio.
 
         Args:
-            monitor(str): The name of the monitor.
+            lock(bool): True to lock, False to unlock.
         """
 
     @rpc_call
-    def set_vrange(
-        self, vmin: "float" = None, vmax: "float" = None, vrange: "tuple[int, int]" = None
-    ):
+    def remove(self):
         """
-        Set the range of the color bar.
-
-        Args:
-            vmin(float): Minimum value of the color bar.
-            vmax(float): Maximum value of the color bar.
+        Remove the plot widget from the figure.
         """
 
+
+class BECWaveform(RPCBase):
+    @property
     @rpc_call
-    def get_data(self) -> "np.ndarray":
+    def rpc_id(self) -> "str":
         """
-        Get the data of the image.
-        Returns:
-            np.ndarray: The data of the image.
+        Get the RPC ID of the widget.
         """
 
-
-class BECMotorMap(RPCBase):
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -1329,329 +1389,332 @@ class BECMotorMap(RPCBase):
         """
 
     @rpc_call
-    def change_motors(
+    def plot(
         self,
-        motor_x: "str",
-        motor_y: "str",
-        motor_x_entry: "str" = None,
-        motor_y_entry: "str" = None,
-        validate_bec: "bool" = True,
-    ) -> "None":
+        x: "list | np.ndarray | None" = None,
+        y: "list | np.ndarray | None" = None,
+        x_name: "str | None" = None,
+        y_name: "str | None" = None,
+        z_name: "str | None" = None,
+        x_entry: "str | None" = None,
+        y_entry: "str | None" = None,
+        z_entry: "str | None" = None,
+        color: "str | None" = None,
+        color_map_z: "str | None" = "plasma",
+        label: "str | None" = None,
+        validate: "bool" = True,
+    ) -> "BECCurve":
         """
-        Change the active motors for the plot.
-
+        Plot a curve to the plot widget.
         Args:
-            motor_x(str): Motor name for the X axis.
-            motor_y(str): Motor name for the Y axis.
-            motor_x_entry(str): Motor entry for the X axis.
-            motor_y_entry(str): Motor entry for the Y axis.
-            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            x_name(str): The name of the device for the x-axis.
+            y_name(str): The name of the device for the y-axis.
+            z_name(str): The name of the device for the z-axis.
+            x_entry(str): The name of the entry for the x-axis.
+            y_entry(str): The name of the entry for the y-axis.
+            z_entry(str): The name of the entry for the z-axis.
+            color(str): The color of the curve.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str): The label of the curve.
+            validate(bool): If True, validate the device names and entries.
+
+        Returns:
+            BECCurve: The curve object.
         """
 
     @rpc_call
-    def set_max_points(self, max_points: "int") -> "None":
+    def remove_curve(self, *identifiers):
         """
-        Set the maximum number of points to display.
+        Remove a curve from the plot widget.
 
         Args:
-            max_points(int): Maximum number of points to display.
+            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
         """
 
     @rpc_call
-    def set_precision(self, precision: "int") -> "None":
+    def scan_history(self, scan_index: "int" = None, scan_id: "str" = None):
         """
-        Set the decimal precision of the motor position.
+        Update the scan curves with the data from the scan storage.
+        Provide only one of scan_id or scan_index.
 
         Args:
-            precision(int): Decimal precision of the motor position.
+            scan_id(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 set_num_dim_points(self, num_dim_points: "int") -> "None":
+    def curves(self) -> "list[BECCurve]":
         """
-        Set the number of dim points for the motor map.
-
-        Args:
-            num_dim_points(int): Number of dim points.
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
         """
 
     @rpc_call
-    def set_background_value(self, background_value: "int") -> "None":
+    def get_curve(self, identifier) -> "BECCurve":
         """
-        Set the background value of the motor map.
+        Get the curve by its index or ID.
 
         Args:
-            background_value(int): Background value of the motor map.
+            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 set_scatter_size(self, scatter_size: "int") -> "None":
+    def get_curve_config(self, curve_id: "str", dict_output: "bool" = True) -> "CurveConfig | dict":
         """
-        Set the scatter size of the motor map plot.
+        Get the configuration of a curve by its ID.
 
         Args:
-            scatter_size(int): Size of the scatter points.
-        """
+            curve_id(str): ID of the curve.
 
-    @rpc_call
-    def get_data(self) -> "dict":
-        """
-        Get the data of the motor map.
         Returns:
-            dict: Data of the motor map.
+            CurveConfig|dict: Configuration of the curve.
         """
 
-
-class BECDock(RPCBase):
-    @property
     @rpc_call
-    def config_dict(self) -> "dict":
+    def apply_config(self, config: "dict | SubplotConfig", replot_last_scan: "bool" = False):
         """
-        Get the configuration of the widget.
+        Apply the configuration to the 1D waveform widget.
 
-        Returns:
-            dict: The configuration of the widget.
+        Args:
+            config(dict|SubplotConfig): Configuration settings.
+            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
         """
 
-    @property
     @rpc_call
-    def rpc_id(self) -> "str":
-        """
-        Get the RPC ID of the widget.
+    def get_all_data(self, output: "Literal['dict', 'pandas']" = "dict") -> "dict | pd.DataFrame":
         """
+        Extract all curve data into a dictionary or a pandas DataFrame.
 
-    @property
-    @rpc_call
-    def widget_list(self) -> "list[BECConnector]":
-        """
-        Get the widgets in the dock.
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
 
         Returns:
-            widgets(list): The widgets in the dock.
+            dict | pd.DataFrame: Data of all curves in the specified format.
         """
 
     @rpc_call
-    def show_title_bar(self):
+    def set(self, **kwargs) -> "None":
         """
-        Hide the title bar of the dock.
+        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 hide_title_bar(self):
+    def set_title(self, title: "str"):
         """
-        Hide the title bar of the dock.
+        Set the title of the plot widget.
+
+        Args:
+            title(str): Title of the plot widget.
         """
 
     @rpc_call
-    def get_widgets_positions(self) -> "dict":
+    def set_x_label(self, label: "str"):
         """
-        Get the positions of the widgets in the dock.
+        Set the label of the x-axis.
 
-        Returns:
-            dict: The positions of the widgets in the dock as dict -> {(row, col, rowspan, colspan):widget}
+        Args:
+            label(str): Label of the x-axis.
         """
 
     @rpc_call
-    def set_title(self, title: "str"):
+    def set_y_label(self, label: "str"):
         """
-        Set the title of the dock.
+        Set the label of the y-axis.
 
         Args:
-            title(str): The title of the dock.
+            label(str): Label of the y-axis.
         """
 
     @rpc_call
-    def add_widget(
-        self,
-        widget: "BECConnector | str",
-        row=None,
-        col=0,
-        rowspan=1,
-        colspan=1,
-        shift: "Literal['down', 'up', 'left', 'right']" = "down",
-    ) -> "BECConnector":
+    def set_x_scale(self, scale: "Literal['linear', 'log']" = "linear"):
         """
-        Add a widget to the dock.
+        Set the scale of the x-axis.
 
         Args:
-            widget(QWidget): The widget to add.
-            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
-            col(int): The column to add the widget to.
-            rowspan(int): The number of rows the widget should span.
-            colspan(int): The number of columns the widget should span.
-            shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
+            scale(Literal["linear", "log"]): Scale of the x-axis.
         """
 
     @rpc_call
-    def list_eligible_widgets(self) -> "list":
+    def set_y_scale(self, scale: "Literal['linear', 'log']" = "linear"):
         """
-        List all widgets that can be added to the dock.
+        Set the scale of the y-axis.
 
-        Returns:
-            list: The list of eligible widgets.
+        Args:
+            scale(Literal["linear", "log"]): Scale of the y-axis.
         """
 
     @rpc_call
-    def move_widget(self, widget: "QWidget", new_row: "int", new_col: "int"):
+    def set_x_lim(self, *args) -> "None":
         """
-        Move a widget to a new position in the layout.
+        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:
-            widget(QWidget): The widget to move.
-            new_row(int): The new row to move the widget to.
-            new_col(int): The new column to move the widget to.
+            *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 remove_widget(self, widget_rpc_id: "str"):
+    def set_y_lim(self, *args) -> "None":
         """
-        Remove a widget from the dock.
+        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:
-            widget_rpc_id(str): The ID of the widget to remove.
+            *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 remove(self):
+    def set_grid(self, x: "bool" = False, y: "bool" = False):
         """
-        Remove the dock from the parent dock area.
+        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 attach(self):
+    def lock_aspect_ratio(self, lock):
         """
-        Attach the dock to the parent dock area.
+        Lock aspect ratio.
+
+        Args:
+            lock(bool): True to lock, False to unlock.
         """
 
     @rpc_call
-    def detach(self):
+    def remove(self):
         """
-        Detach the dock from the parent dock area.
+        Remove the plot widget from the figure.
         """
 
 
-class BECDockArea(RPCBase, BECGuiClientMixin):
-    @property
+class Ring(RPCBase):
     @rpc_call
-    def config_dict(self) -> "dict":
+    def get_all_rpc(self) -> "dict":
         """
-        Get the configuration of the widget.
-
-        Returns:
-            dict: The configuration of the widget.
+        Get all registered RPC objects.
         """
 
     @property
     @rpc_call
-    def panels(self) -> "dict[str, BECDock]":
+    def rpc_id(self) -> "str":
         """
-        Get the docks in the dock area.
-        Returns:
-            dock_dict(dict): The docks in the dock area.
+        Get the RPC ID of the widget.
         """
 
+    @property
     @rpc_call
-    def save_state(self) -> "dict":
+    def config_dict(self) -> "dict":
         """
-        Save the state of the dock area.
+        Get the configuration of the widget.
 
         Returns:
-            dict: The state of the dock area.
+            dict: The configuration of the widget.
         """
 
     @rpc_call
-    def remove_dock(self, name: "str"):
+    def set_value(self, value: "int | float"):
         """
-        Remove a dock by name and ensure it is properly closed and cleaned up.
+        Set the value for the ring widget
 
         Args:
-            name(str): The name of the dock to remove.
+            value(int | float): Value for the ring widget
         """
 
     @rpc_call
-    def restore_state(
-        self, state: "dict" = None, missing: "Literal['ignore', 'error']" = "ignore", extra="bottom"
-    ):
+    def set_color(self, color: "str | tuple"):
         """
-        Restore the state of the dock area. If no state is provided, the last state is restored.
+        Set the color for the ring widget
 
         Args:
-            state(dict): The state to restore.
-            missing(Literal['ignore','error']): What to do if a dock is missing.
-            extra(str): Extra docks that are in the dockarea but that are not mentioned in state will be added to the bottom of the dockarea, unless otherwise specified by the extra argument.
+            color(str | tuple): Color for the ring widget. Can be HEX code or tuple (R, G, B, A).
         """
 
     @rpc_call
-    def add_dock(
-        self,
-        name: "str" = None,
-        position: "Literal['bottom', 'top', 'left', 'right', 'above', 'below']" = None,
-        relative_to: "BECDock | None" = None,
-        closable: "bool" = False,
-        prefix: "str" = "dock",
-        widget: "str | QWidget | None" = None,
-        row: "int" = None,
-        col: "int" = 0,
-        rowspan: "int" = 1,
-        colspan: "int" = 1,
-    ) -> "BECDock":
+    def set_background(self, color: "str | tuple"):
         """
-        Add a dock to the dock area. Dock has QGridLayout as layout manager by default.
+        Set the background color for the ring widget
 
         Args:
-            name(str): The name of the dock to be displayed and for further references. Has to be unique.
-            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
-            relative_to(BECDock): The dock to which the new dock should be added relative to.
-            closable(bool): Whether the dock is closable.
-            prefix(str): The prefix for the dock name if no name is provided.
-            widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
-            row(int): The row of the added widget.
-            col(int): The column of the added widget.
-            rowspan(int): The rowspan of the added widget.
-            colspan(int): The colspan of the added widget.
-
-        Returns:
-            BECDock: The created dock.
+            color(str | tuple): Background color for the ring widget. Can be HEX code or tuple (R, G, B, A).
         """
 
     @rpc_call
-    def clear_all(self):
+    def set_line_width(self, width: "int"):
         """
-        Close all docks and remove all temp areas.
+        Set the line width for the ring widget
+
+        Args:
+            width(int): Line width for the ring widget
         """
 
     @rpc_call
-    def detach_dock(self, dock_name: "str") -> "BECDock":
+    def set_min_max_values(self, min_value: "int | float", max_value: "int | float"):
         """
-        Undock a dock from the dock area.
+        Set the min and max values for the ring widget.
 
         Args:
-            dock_name(str): The dock to undock.
-
-        Returns:
-            BECDock: The undocked dock.
+            min_value(int | float): Minimum value for the ring widget
+            max_value(int | float): Maximum value for the ring widget
         """
 
     @rpc_call
-    def attach_all(self):
+    def set_start_angle(self, start_angle: "int"):
         """
-        Return all floating docks to the dock area.
+        Set the start angle for the ring widget
+
+        Args:
+            start_angle(int): Start angle for the ring widget in degrees
         """
 
     @rpc_call
-    def get_all_rpc(self) -> "dict":
+    def set_update(self, mode: "Literal['manual', 'scan', 'device']", device: "str" = None):
         """
-        Get all registered RPC objects.
+        Set the update mode for the ring widget.
+        Modes:
+        - "manual": Manual update mode, the value is set by the user.
+        - "scan": Update mode for the scan progress. The value is updated by the current scan progress.
+        - "device": Update mode for the device readback. The value is updated by the device readback. Take into account that user has to set the device name and limits.
+
+        Args:
+            mode(str): Update mode for the ring widget. Can be "manual", "scan" or "device"
+            device(str): Device name for the device readback mode, only used when mode is "device"
         """
 
-    @property
     @rpc_call
-    def temp_areas(self) -> "list":
+    def reset_connection(self):
         """
-        Get the temporary areas in the dock area.
-
-        Returns:
-            list: The temporary areas in the dock area.
+        Reset the connections for the ring widget. Disconnect the current slot and endpoint.
         """
 
 
@@ -1834,144 +1897,6 @@ class SpiralProgressBar(RPCBase):
         """
 
 
-class Ring(RPCBase):
-    @rpc_call
-    def get_all_rpc(self) -> "dict":
-        """
-        Get all registered RPC objects.
-        """
-
-    @property
-    @rpc_call
-    def rpc_id(self) -> "str":
-        """
-        Get the RPC ID of the widget.
-        """
-
-    @property
-    @rpc_call
-    def config_dict(self) -> "dict":
-        """
-        Get the configuration of the widget.
-
-        Returns:
-            dict: The configuration of the widget.
-        """
-
-    @rpc_call
-    def set_value(self, value: "int | float"):
-        """
-        Set the value for the ring widget
-
-        Args:
-            value(int | float): Value for the ring widget
-        """
-
-    @rpc_call
-    def set_color(self, color: "str | tuple"):
-        """
-        Set the color for the ring widget
-
-        Args:
-            color(str | tuple): Color for the ring widget. Can be HEX code or tuple (R, G, B, A).
-        """
-
-    @rpc_call
-    def set_background(self, color: "str | tuple"):
-        """
-        Set the background color for the ring widget
-
-        Args:
-            color(str | tuple): Background color for the ring widget. Can be HEX code or tuple (R, G, B, A).
-        """
-
-    @rpc_call
-    def set_line_width(self, width: "int"):
-        """
-        Set the line width for the ring widget
-
-        Args:
-            width(int): Line width for the ring widget
-        """
-
-    @rpc_call
-    def set_min_max_values(self, min_value: "int | float", max_value: "int | float"):
-        """
-        Set the min and max values for the ring widget.
-
-        Args:
-            min_value(int | float): Minimum value for the ring widget
-            max_value(int | float): Maximum value for the ring widget
-        """
-
-    @rpc_call
-    def set_start_angle(self, start_angle: "int"):
-        """
-        Set the start angle for the ring widget
-
-        Args:
-            start_angle(int): Start angle for the ring widget in degrees
-        """
-
-    @rpc_call
-    def set_update(self, mode: "Literal['manual', 'scan', 'device']", device: "str" = None):
-        """
-        Set the update mode for the ring widget.
-        Modes:
-        - "manual": Manual update mode, the value is set by the user.
-        - "scan": Update mode for the scan progress. The value is updated by the current scan progress.
-        - "device": Update mode for the device readback. The value is updated by the device readback. Take into account that user has to set the device name and limits.
-
-        Args:
-            mode(str): Update mode for the ring widget. Can be "manual", "scan" or "device"
-            device(str): Device name for the device readback mode, only used when mode is "device"
-        """
-
-    @rpc_call
-    def reset_connection(self):
-        """
-        Reset the connections for the ring widget. Disconnect the current slot and endpoint.
-        """
-
-
-class WebsiteWidget(RPCBase):
-    @rpc_call
-    def set_url(self, url: str) -> None:
-        """
-        Set the url of the website widget
-
-        Args:
-            url (str): The url to set
-        """
-
-    @rpc_call
-    def get_url(self) -> str:
-        """
-        Get the current url of the website widget
-
-        Returns:
-            str: The current url
-        """
-
-    @rpc_call
-    def reload(self):
-        """
-        Reload the website
-        """
-
-    @rpc_call
-    def back(self):
-        """
-        Go back in the history
-        """
-
-    @rpc_call
-    def forward(self):
-        """
-        Go forward in the history
-        """
-
-
 class WebsiteWidget(RPCBase):
     @rpc_call
     def set_url(self, url: str) -> None: