bec-widgets 0.99.8__py3-none-any.whl → 0.99.9__py3-none-any.whl

docs/developer/widget_development/bec_dispatcher.md

@@ -1,143 +0,0 @@
-(developer.widget_development.bec_dispatcher)=
-
-# BECDispatcher
-
-## Overview
-
-The [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher)
-is a powerful tool that
-simplifies the process of connecting Qt slots to message updates from the BEC server. It enables real-time communication
-between your widget and the BEC server by listening to specific message channels and triggering callbacks when new data
-is received.
-
-This tool is especially useful for creating widgets that need to respond to dynamic data, such as device readbacks or
-scan updates. By
-using [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher),
-you
-can create callback functions that react to incoming messages and update your widget's state or perform other tasks
-based on the data received.
-
-## How It Works
-
-When you create a widget that needs to respond to updates from the BEC server, you can use
-the [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher)
-to
-connect specific Qt slots (callback functions) to message endpoints. These endpoints are defined within the BEC system
-and represent specific channels of information (
-e.g., [`device readback`](https://beamline-experiment-control.readthedocs.io/en/latest/api_reference/_autosummary/bec_lib.endpoints.MessageEndpoints.html#bec_lib.endpoints.MessageEndpoints.device_readback),
-[`scan_segment`](https://beamline-experiment-control.readthedocs.io/en/latest/api_reference/_autosummary/bec_lib.endpoints.MessageEndpoints.html#bec_lib.endpoints.MessageEndpoints.scan_segment),
-etc.).
-
-### Step-by-Step Guide
-
-1. **Create a Callback Function**: Define a function within your widget that will handle the data received from the BEC
-   server. This function should usually accept two parameters: `msg_content` (the message content) and `metadata` (
-   additional
-   information about the message).
-
-    ```python
-    # Example for a callback function that updates a widget display based on motor readback data
-   from qtpy.QtCore import Slot
-   
-    @Slot(dict, dict)
-    def on_device_readback(self, msg_content, metadata):
-        # Process the incoming data
-        new_value = msg_content["signals"]['motor_x']["value"]
-        # Update the widget's display or perform another action
-        self.update_display(new_value)
-    ```
-
-2. **Connect the Slot to an Endpoint**: Use
-   the [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher)
-   to connect your callback function to a specific
-   endpoint. The endpoint represents the type of data or message you're interested in.
-
-    ```python
-   from bec_lib.endpoints import MessageEndpoints
-   
-    self.bec_dispatcher.connect_slot(self.on_device_readback, MessageEndpoints.device_readback("motor_x"))
-    ```
-
-3. **Handle Incoming Data**: Your callback function will be triggered automatically whenever a new message is received
-   on the connected endpoint. Use the data in `msg_content` to update your widget or perform other actions.
-
-4. **Clean Up Connections**: If your widget is being destroyed or you no longer need to listen for updates, make sure to
-   disconnect your slots from
-   the [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher)
-   to avoid memory or thread leaks.
-
-    ```python
-    self.bec_dispatcher.disconnect_slot(self.on_device_readback, MessageEndpoints.device_readback("motor_x"))
-    ```
-
-### Example: Motor Map Widget
-
-The [`BECMotorMap`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.widgets.figure.plots.motor_map.motor_map.BECMotorMap.html#bec-widgets-widgets-figure-plots-motor-map-motor-map-becmotormap)
-widget is a great example of
-how [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher)
-can be used to handle real-time data updates. This
-widget listens for updates on specific motor positions and dynamically updates the motor map display.
-
-Here's a breakdown of
-how [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher)
-is used in
-the [`BECMotorMap`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.widgets.figure.plots.motor_map.motor_map.BECMotorMap.html#bec-widgets-widgets-figure-plots-motor-map-motor-map-becmotormap)
-widget:
-
-1. **Connecting to Motor Readbacks**:
-   The widget connects to
-   the [`device readback`](https://beamline-experiment-control.readthedocs.io/en/latest/api_reference/_autosummary/bec_lib.endpoints.MessageEndpoints.html#bec_lib.endpoints.MessageEndpoints.device_readback)
-   endpoints using
-   the [`connect_slot`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher.connect_slot)
-   method
-   of [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher).
-   This allows
-   the widget to receive real-time updates about the motor positions.
-
-```{literalinclude} ../../../bec_widgets/widgets/figure/plots/motor_map/motor_map.py
-:language: python
-:pyobject: BECMotorMap._connect_motor_to_slots
-:dedent: 4
-```
-
-2. **Handling Readback Data**:
-   The `on_device_readback` slot is called whenever new data is received from the motor readback. This slot processes
-   the data and updates the motor map plot accordingly.
-
-```{literalinclude} ../../../bec_widgets/widgets/figure/plots/motor_map/motor_map.py
-:language: python
-:pyobject: BECMotorMap.on_device_readback
-:dedent: 4
-```
-
-3. **Updating the Plot**:
-   The motor map plot is updated in response to the new data, providing a real-time visualization of the motor's
-   position.
-
-```{literalinclude} ../../../bec_widgets/widgets/figure/plots/motor_map/motor_map.py
-:language: python
-:pyobject: BECMotorMap._update_plot
-:dedent: 4
-```
-
-4. **Disconnecting When No Longer Needed**:
-   The widget ensures that connections are properly cleaned up when no longer needed.
-
-```{literalinclude} ../../../bec_widgets/widgets/figure/plots/motor_map/motor_map.py
-:language: python
-:pyobject: BECMotorMap._update_plot
-:dedent: 4
-```
-
-## Conclusion
-
-The [`BECDispatcher`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher.html#bec_widgets.utils.bec_dispatcher.BECDispatcher)
-is a key tool for developing interactive and responsive widgets within the BEC framework. By
-leveraging this tool, you can create widgets that automatically respond to real-time data updates from the BEC server,
-enhancing the interactivity and functionality of your user interface.
-
-In next tutorials we will cover how to create a custom widget using the BECDispatcher and BECWidget base class.
-
-```{note}
-For more details on specific messages and endpoints, please refer to the [Message Endpoints Documentation](https://beamline-experiment-control.readthedocs.io/en/latest/api_reference/_autosummary/bec_lib.endpoints.MessageEndpoints.html#bec-lib-endpoints-messageendpoints).
-```

docs/developer/widget_development/widget_base_class.md

@@ -1,171 +0,0 @@
-(developer.widget_development.widget_base_class)=
-
-# BECWidget Base Class
-
-When developing new widgets, it is crucial to ensure seamless integration with the BEC system. This is achieved by using
-the [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-base class, which provides essential functionalities and shortcuts to interact with various BEC services. In this
-tutorial, we will explore the importance of this base class, the role of
-the [`BECConnector`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector.html#bec_widgets.utils.bec_connector.BECConnector)
-mixin, and how these components work together to facilitate the development of powerful and responsive widgets.
-
-## Understanding the `BECWidget` Base Class
-
-The [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-base class is designed to serve as the foundation for all BEC-connected widgets. It ensures that your widget is properly
-integrated with the BEC system by providing:
-
-1. **Connection to BEC Services
-   **: [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-   includes
-   the [`BECConnector`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector.html#bec_widgets.utils.bec_connector.BECConnector)
-   mixin, which handles all the necessary connections to BEC services such as the BEC server, device manager, scan
-   control, and more.
-
-2. **Qt Integration**:
-   The [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-   base class also ensures that your widget is correctly integrated with Qt by requiring that it inherits from
-   both [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-   and [`QWidget`](https://doc.qt.io/qtforpython-6/PySide6/QtWidgets/QWidget.html). This combination allows your widget
-   to leverage the full power of Qt for creating rich user interfaces while staying connected to the BEC ecosystem.
-
-3. **Configuration Management**: The base class provides a `ConnectionConfig` model (based on Pydantic) that helps
-   manage and validate the configuration of your widget. This configuration can be easily serialized to and from Python
-   dictionaries, JSON, or YAML formats, allowing for persistent storage and retrieval of widget states.
-
-4. **RPC Registration**: Widgets derived
-   from [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-   are automatically registered with
-   the [`RPCRegister`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.cli.rpc_register.RPCRegister.html#bec_widgets.cli.rpc_register.RPCRegister),
-   enabling them to handle remote procedure calls (RPCs) efficiently. This allows the widget to be controlled remotely
-   from the `BECIPythonClient` via CLI, providing powerful control and automation capabilities. For example, you can
-   remotely adjust widget settings, start/stop operations, or query the widget’s status directly from the command line.
-
-Here’s a basic example of a widget inheriting
-from [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget):
-
-```python
-from bec_widgets.utils.bec_widget import BECWidget
-from qtpy.QtWidgets import QWidget, QVBoxLayout
-
-
-class MyWidget(BECWidget, QWidget):
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        QWidget.__init__(self, parent=parent)
-        self.get_bec_shortcuts()  # Initialize BEC shortcuts
-        self.init_ui()
-
-    def init_ui(self):
-        layout = QVBoxLayout(self)
-        # Add more UI components here
-        self.setLayout(layout)
-```
-
-### The Role of `BECConnector`
-
-At the heart
-of [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-is
-the [`BECConnector`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector.html#bec_widgets.utils.bec_connector.BECConnector)
-mixin, which plays a crucial role in managing the connection between your widget and the BEC system.
-The [`BECConnector`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector.html#bec_widgets.utils.bec_connector.BECConnector)
-provides several key functionalities:
-
-1. **Client Initialization**: It initializes a `BECClient` instance if one isn't provided, ensuring your widget is
-   connected to the BEC server. This client is central to all interactions with the BEC system.
-
-2. **Task Management**:
-   The [`submit_task`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector.html#bec_widgets.utils.bec_connector.BECConnector.submit_task)
-   method allows for running tasks in separate threads, preventing long-running operations from blocking the main UI
-   thread.
-
-3. **Configuration Handling
-   **: [`BECConnector`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector.html#bec_widgets.utils.bec_connector.BECConnector)
-   uses the `ConnectionConfig` model to manage the widget’s configuration, ensuring all parameters are validated and
-   properly set up.
-
-4. **RPC Registration**: Widgets are registered with
-   the [`RPCRegister`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.cli.rpc_register.RPCRegister.html#bec-widgets-cli-rpc-register-rpcregister),
-   allowing them to handle remote procedure calls effectively.
-
-5. **Error Handling**: It includes utilities for handling errors gracefully within the Qt environment, ensuring that
-   issues are reported to the user without crashing the application.
-
-### Utilizing `get_bec_shortcuts`
-
-One of the most powerful features of
-the [`BECConnector`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector.html#bec_widgets.utils.bec_connector.BECConnector)
-is the `get_bec_shortcuts` method. This method provides your widget with direct access to essential components of the
-BEC system through convenient shortcuts:
-
-1. **Device Manager (`self.dev`)**:
-    - Access all devices registered with the BEC system. You can interact with devices, retrieve their status, and send
-      commands directly through this shortcut.
-   ```python
-   # Moves 'motor1' to position 10
-   self.dev["motor1"].move(10)  
-   ```
-
-2. **Scan Control (`self.scans`)**:
-    - Control scans, initiate new ones, monitor progress, and manage their execution.
-   ```python
-   # Starts Line Scan from -10 to 10 in samx and -5 to 5 in samy
-   self.scans.line_scan(self.dev.samx,-10,10,self.dev.samy,-5,5, steps=100, exp_time=0.001,relative=False)
-   ```
-
-3. **Queue Management (`self.queue`)**:
-    - Manage the BEC scan queue, such as adding scans, checking status, or removing scans.
-   ```python
-   # Request abortion of the current scan queue
-   self.queue.request_scan_abortion() 
-   ```
-
-4. **Scan Storage (`self.scan_storage`)**:
-    - Access stored scan data for retrieval and analysis.
-   ```python
-   # Retrieve scan item for a specific scan ID
-   self.scan_item = self.queue.scan_storage.find_scan_by_ID(self.scan_id)  
-   ```
-
-5. **Full BECClient Access (`self.client`)**:
-    - Direct access to the BECClient instance, allowing for additional functionalities not covered by the shortcuts.
-   ```python
-   # Shutdown the BECClient
-   self.client.shutdown()  
-   ```
-
-### Example: `PositionerBox` Widget
-
-Let’s look at an example of a widget that leverages
-the [`BECWidget`](https://bec.readthedocs.io/projects/bec-widgets/en/latest/api_reference/_autosummary/bec_widgets.utils.bec_widget.BECWidget.html#bec_widgets.utils.bec_widget.BECWidget)
-base class and `get_bec_shortcuts`:
-
-````{dropdown} View code: PositionerBox Widget
-:icon: code-square
-:animate: fade-in-slide-down
-```{literalinclude} ../../../bec_widgets/widgets/positioner_box/positioner_box.py
-:language: python
-:pyobject: PositionerBox
-```
-````
-
-In this widget:
-
-- **Device Interaction**: The widget uses `self.dev` to interact with a positioner device, reading its state and
-  updating the UI accordingly.
-
-- **Scan and Queue Control**: Although not shown in this example, the widget could easily use `self.scans`
-  and `self.queue` to manage scans related to the positioner or queue up new operations.
-
-### Conclusion
-
-The `BECWidget` base class and the `BECConnector` mixin are foundational components for creating widgets that seamlessly
-integrate with the BEC system. By inheriting from `BECWidget`, you gain access to powerful connection management, task
-handling, and configuration capabilities, as well as shortcuts that make interacting with BEC services straightforward
-and efficient.
-
-By leveraging these tools, you can focus on building the core functionality of your widget, confident that the
-complexities of BEC integration are handled robustly and efficiently. In the next tutorial we will demonstrate
-step-by-step how to create a custom widget using the `BECWidget` base class and explore advanced features for creating
-responsive and interactive user interfaces.

docs/developer/widget_development/widget_development.md

@@ -1,14 +0,0 @@
-(developer.widget_development)=
-
-# Widget Development
-This section provides an introduction to the building blocks of BEC Widgets: widgets. Widgets are the basic components of the graphical user interface (GUI) and are used to create larger applications. We will cover key topics such as how to develop new widgets or how to customise existing widgets. For details on the already available widgets and their usage, please refer to user section about [widgets](#user.widgets)
-
-```{toctree}
----
-maxdepth: 2
-hidden: false
----
-
-bec_dispatcher
-widget_base_class
-```

docs/index.md

@@ -1,74 +0,0 @@
-:html_theme.sidebar_secondary.remove:
-
-# BEC Widgets documentation
-
-A flexible and extensible framework for building graphical user interfaces in Python, optimized for use in the BEC environment.
-
-<br><br>
-
-````{grid} 2
-:gutter: 5
-
-```{grid-item-card}
-:link: introduction
-:link-type: ref
-:img-top: /assets/index_getting_started.svg
-:text-align: center
-:class-item: index-card
-
-## Introduction
-
-General information about BEC Widgets.
-```
-
-```{grid-item-card}
-:link: user
-:link-type: ref
-:img-top:  /assets/index_user_guide.svg
-:text-align: center
-:class-item: index-card
-
-## User guide
-
-Information for users of BEC Widgets.
-```
-
-```{grid-item-card} 
-:link: developer
-:link-type: ref
-:img-top: /assets/index_contribute.svg
-:text-align: center
-:class-item: index-card
-
-## Developer guide
-
-Information for developers of BEC Widgets. 
-```
-
-```{grid-item-card} 
-:link: api_reference
-:link-type: ref
-:img-top: /assets/index_api.svg
-:text-align: center
-:class-item: index-card
-
-## API reference
-
-Comprehensive reference of all BEC Widget classes, functions, and methods.
-```
-
-````
-
-
-```{toctree}
----
-numbered: true
-maxdepth: 2
-hidden: true
----
-
-introduction/introduction
-user/user
-developer/developer
-api_reference/api_reference
-```

docs/introduction/introduction.md

@@ -1,18 +0,0 @@
-(introduction)=
-# Introduction
-
-## Overview
-
-BEC Widgets is a GUI framework developed with beamline scientists in mind, aiming to provide a modern and modular environment for interacting with experiments. This package offers a suite of widgets specifically designed to enhance the workflow of beamline experiments, including features for running scans and data visualization.
-
-Targeting the unique needs of beamline scientists, BEC Widgets stands out with its modular approach to widget design and high customizability. This flexibility allows for tailored solutions that meet the specific requirements of each beamline.
-
-**Key Features**:
-
-- **Integration:** Seamlessly integrates with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec), ensuring a cohesive and efficient experiment control experience.
-- **Support for Pyside6 and PyQt6:** Provides compatibility with both Pyside6 and PyQt6, offering versatility in your development environment.
-- **Widget Modularity:** Features modular widgets that can be easily combined to create customized applications, perfectly aligning with the diverse needs of beamline experiments.
-
-## Getting Started
-
-For detailed usage instructions and examples showcasing the practical applications of BEC Widgets, please refer to the [User](#user) section. Developers interested in contributing or customizing BEC Widgets can find more information in the [Developer](#developer) section.

docs/make.bat

@@ -1,35 +0,0 @@
-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=.
-set BUILDDIR=_build
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.https://www.sphinx-doc.org/
-	exit /b 1
-)
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
-
-:end
-popd

docs/requirements.txt

@@ -1,12 +0,0 @@
-sphinx
-sphinx_copybutton
-recommonmark
-sphinx-toolbox
-pydata-sphinx-theme
-sphinx-copybutton
-sphinx-inline-tabs
-myst-parser
-sphinx-design
-PySide6
-bec-widgets
-tomli

docs/user/api_reference/api_reference.md

@@ -1,11 +0,0 @@
-(user.api_reference)=
-# User API Reference
-
-```{eval-rst}
-.. autosummary::
-   :toctree: _autosummary
-   :template: custom-module-template.rst
-
-    bec_widgets.cli.client
-
-```

docs/user/applications/applications.md

@@ -1,10 +0,0 @@
-(user.applications)=
-# Applications
-
-**Coming soon**
-
-```{toctree}
----
-maxdepth: 1
-hidden: true
----

docs/user/customisation.md

@@ -1,123 +0,0 @@
-(user.customisation)=
-# Customisation
-
-## Leveraging BEC Widgets in custom GUI applications
-
-BEC Widgets can be used to compose a complete Qt graphical application, along with
-other QWidgets. The only requirement is to connect to BEC servers in order to get
-data, or to interact with BEC components. This role is devoted to the BECDispatcher,
-a singleton object which has to be instantiated **after the QApplication is created**.
-
-A typical BEC Widgets custom application "main" entry point should follow the template
-below: 
-
-```
-import argparse
-import sys
-
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-from qtpy.QtWidgets import QApplication
-
-# optional command line arguments processing
-parser = argparse.ArgumentParser(description="...")
-parser.add_argument( ...)
-...
-args = parser.parse_args()
-
-# creation of the Qt application
-app = QApplication([])
-
-# creation of BEC Dispatcher
-# /!\ important: after the QApplication has been instantiated
-bec_dispatcher = BECDispatcher()
-client = bec_dispatcher.client
-client.start()
-
-# (optional) processing of command line args,
-# creation of a main window depending on the command line arguments (or not)
-if args.xxx == "...":
-    window = ...
- 
-# display of the main window and start of Qt event loop
-window.show()
-sys.exit(app.exec())
-```
-
-The main "window" object presents the layout of widgets to the user and allows
-users to interact. BEC Widgets must be placed in the window:
-
-```
-from qtpy.QWidgets import QMainWindow
-from bec_widgets.widgets.figure import BECFigure
-
-window = QMainWindow()
-bec_figure = BECFigure(gui_id="my_gui_app_id")
-window.setCentralWidget(bec_figure)
-
-# prepare to plot samx motor vs bpm4i value
-bec_figure.plot(x_name="samx", y_name="bpm4i")
-```
-
-In the example just above, the resulting application will show a plot of samx
-positions on the horizontal axis, and beam intensity on the vertical axis
-(when the next scan will be started).
-
-It is important to ensure proper cleanup of the resources is done when application
-quits:
-
-```
-def final_cleanup():
-    bec_figure.clear_all()
-    bec_figure.client.shutdown()
-
-window.aboutToQuit.connect(final_cleanup)
-```
-
-Final example:
-
-```
-import sys
-from qtpy.QtWidgets import QMainWindow, QApplication
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-# creation of the Qt application
-app = QApplication([])
-
-# creation of BEC Dispatcher
-bec_dispatcher = BECDispatcher()
-client = bec_dispatcher.client
-client.start()
-
-# creation of main window
-window = QMainWindow()
-
-# inserting BEC Widgets
-bec_figure = BECFigure(parent=window, gui_id="my_gui_app_id")
-window.setCentralWidget(bec_figure)
-
-bec_figure.plot(x_name="samx", y_name="bpm4i")
-
-# ensuring proper cleanup
-def final_cleanup():
-    bec_figure.clear_all()
-    bec_figure.client.shutdown()
-
-app.aboutToQuit.connect(final_cleanup)
-
-# execution
-window.show()
-sys.exit(app.exec())
-```
-
-## Writing applications using Qt Designer
-
-BEC Widgets are designed to be used with QtDesigner to quickly design GUI.
-
-## Example of promoting widgets in Qt Designer
-
-_Work in progress_
-
-## Implementation of plugins into Qt Designer
-
-_Work in progress_