bec-widgets 0.87.1__py3-none-any.whl → 0.88.1__py3-none-any.whl

bec_widgets/widgets/figure/plots/axis_settings.py

@@ -1,14 +1,14 @@
 import os
 
 from qtpy.QtCore import Slot
-from qtpy.QtWidgets import QVBoxLayout, QWidget
+from qtpy.QtWidgets import QVBoxLayout
 
+from bec_widgets.qt_utils.settings_dialog import SettingWidget
 from bec_widgets.utils import UILoader
-from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.widget_io import WidgetIO
 
 
-class AxisSettings(QWidget):
+class AxisSettings(SettingWidget):
     def __init__(self, parent=None, *args, **kwargs):
         super().__init__(parent=parent, *args, **kwargs)
 
@@ -25,6 +25,10 @@ class AxisSettings(QWidget):
 
     @Slot(dict)
     def display_current_settings(self, axis_config: dict):
+
+        if axis_config == {}:
+            return
+
         # Top Box
         WidgetIO.set_value(self.ui.plot_title, axis_config["title"])
 
@@ -37,6 +41,10 @@ class AxisSettings(QWidget):
             WidgetIO.check_and_adjust_limits(self.ui.x_max, axis_config["x_lim"][1])
             WidgetIO.set_value(self.ui.x_min, axis_config["x_lim"][0])
             WidgetIO.set_value(self.ui.x_max, axis_config["x_lim"][1])
+        if axis_config["x_lim"] is None:
+            x_range = self.target_widget.fig.widget_list[0].plot_item.viewRange()[0]
+            WidgetIO.set_value(self.ui.x_min, x_range[0])
+            WidgetIO.set_value(self.ui.x_max, x_range[1])
 
         # Y Axis Box
         WidgetIO.set_value(self.ui.y_label, axis_config["y_label"])
@@ -47,15 +55,34 @@ class AxisSettings(QWidget):
             WidgetIO.check_and_adjust_limits(self.ui.y_max, axis_config["y_lim"][1])
             WidgetIO.set_value(self.ui.y_min, axis_config["y_lim"][0])
             WidgetIO.set_value(self.ui.y_max, axis_config["y_lim"][1])
+        if axis_config["y_lim"] is None:
+            y_range = self.target_widget.fig.widget_list[0].plot_item.viewRange()[1]
+            WidgetIO.set_value(self.ui.y_min, y_range[0])
+            WidgetIO.set_value(self.ui.y_max, y_range[1])
 
+    @Slot()
+    def accept_changes(self):
+        title = WidgetIO.get_value(self.ui.plot_title)
 
-if __name__ == "__main__":
-    import sys
+        # X Axis
+        x_label = WidgetIO.get_value(self.ui.x_label)
+        x_scale = self.ui.x_scale.currentText()
+        x_grid = WidgetIO.get_value(self.ui.x_grid)
+        x_lim = (WidgetIO.get_value(self.ui.x_min), WidgetIO.get_value(self.ui.x_max))
 
-    from qtpy.QtWidgets import QApplication
+        # Y Axis
+        y_label = WidgetIO.get_value(self.ui.y_label)
+        y_scale = self.ui.y_scale.currentText()
+        y_grid = WidgetIO.get_value(self.ui.y_grid)
+        y_lim = (WidgetIO.get_value(self.ui.y_min), WidgetIO.get_value(self.ui.y_max))
 
-    app = QApplication(sys.argv)
-    apply_theme("dark")
-    window = AxisSettings()
-    window.show()
-    sys.exit(app.exec_())
+        self.target_widget.set(
+            title=title,
+            x_label=x_label,
+            x_scale=x_scale,
+            x_lim=x_lim,
+            y_label=y_label,
+            y_scale=y_scale,
+            y_lim=y_lim,
+        )
+        self.target_widget.set_grid(x_grid, y_grid)

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

@@ -55,6 +55,7 @@ class BECImageShow(BECPlotBase):
         "set_y_lim",
         "set_grid",
         "lock_aspect_ratio",
+        "export",
         "remove",
         "images",
     ]

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

@@ -58,6 +58,7 @@ class BECMotorMap(BECPlotBase):
         "set_background_value",
         "set_scatter_size",
         "get_data",
+        "export",
         "remove",
         "reset_history",
     ]

bec_widgets/widgets/figure/plots/plot_base.py

@@ -2,11 +2,8 @@ from __future__ import annotations
 
 from typing import Literal, Optional
 
-import numpy as np
 import pyqtgraph as pg
 from pydantic import BaseModel, Field
-from qtpy import QT_VERSION
-from qtpy.QtGui import QFont, QFontDatabase, QFontInfo
 from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import BECConnector, ConnectionConfig
@@ -57,6 +54,7 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
         "set_y_lim",
         "set_grid",
         "lock_aspect_ratio",
+        "export",
         "remove",
         "set_legend_label_size",
     ]
@@ -293,6 +291,25 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
         """
         self.plot_item.setAspectLocked(lock)
 
+    def set_auto_range(self, enabled: bool, axis: str = "xy"):
+        """
+        Set the auto range of the plot widget.
+
+        Args:
+            enabled(bool): If True, enable the auto range.
+            axis(str, optional): The axis to enable the auto range.
+                - "xy": Enable auto range for both x and y axis.
+                - "x": Enable auto range for x axis.
+                - "y": Enable auto range for y axis.
+        """
+        self.plot_item.enableAutoRange(axis, enabled)
+
+    def export(self):
+        """Show the Export Dialog of the plot widget."""
+        scene = self.plot_item.scene()
+        scene.contextMenuItem = self.plot_item
+        scene.showExportDialog()
+
     def remove(self):
         """Remove the plot widget from the figure."""
         if self.figure is not None:

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

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import datetime
-import time
 from collections import defaultdict
 from typing import Any, Literal, Optional
 
@@ -10,7 +8,8 @@ import pyqtgraph as pg
 from bec_lib import messages
 from bec_lib.device import ReadoutPriority
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field, ValidationError
+from pydantic import Field, ValidationError, field_validator
+from pyqtgraph.exporters import MatplotlibExporter
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
@@ -26,13 +25,16 @@ from bec_widgets.widgets.figure.plots.waveform.waveform_curve import (
 
 
 class Waveform1DConfig(SubplotConfig):
-    color_palette: Literal["plasma", "viridis", "inferno", "magma"] = Field(
-        "plasma", description="The color palette of the figure widget."
+    color_palette: Optional[str] = Field(
+        "plasma", description="The color palette of the figure widget.", validate_default=True
     )
     curves: dict[str, CurveConfig] = Field(
         {}, description="The list of curves to be added to the 1D waveform widget."
     )
 
+    model_config: dict = {"validate_assignment": True}
+    _validate_color_map_z = field_validator("color_palette")(Colors.validate_color_map)
+
 
 class BECWaveform(BECPlotBase):
     READOUT_PRIORITY_HANDLER = {
@@ -63,7 +65,9 @@ class BECWaveform(BECPlotBase):
         "set_x_lim",
         "set_y_lim",
         "set_grid",
+        "set_colormap",
         "lock_aspect_ratio",
+        "export",
         "remove",
         "clear_all",
         "set_legend_label_size",
@@ -71,6 +75,7 @@ class BECWaveform(BECPlotBase):
     scan_signal_update = pyqtSignal()
     async_signal_update = pyqtSignal()
     dap_params_update = pyqtSignal(dict)
+    dap_summary_update = pyqtSignal(dict)
     autorange_signal = pyqtSignal()
 
     def __init__(
@@ -385,7 +390,6 @@ class BECWaveform(BECPlotBase):
 
             self.async_signal_update.emit()
             self.scan_signal_update.emit()
-        # self.autorange_timer.start(200)
 
     @pyqtSlot()
     def auto_range(self):
@@ -651,6 +655,19 @@ class BECWaveform(BECPlotBase):
             params[curve_id] = curve.dap_params
         return params
 
+    @pyqtSlot()
+    def get_dap_summary(self) -> dict:
+        """
+        Get the DAP summary of all DAP curves.
+
+        Returns:
+            dict: DAP summary of all DAP curves.
+        """
+        summary = {}
+        for curve_id, curve in self._curves_data["DAP"].items():
+            summary[curve_id] = curve.dap_summary
+        return summary
+
     def _add_curve_object(
         self,
         name: str,
@@ -954,6 +971,22 @@ class BECWaveform(BECPlotBase):
         current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
         self.plot_item.setLabel("bottom", f"{current_label}{self._x_axis_mode['label_suffix']}")
 
+    def set_colormap(self, colormap: str | None = None):
+        """
+        Set the colormap of the plot widget.
+
+        Args:
+            colormap(str, optional): Scale the colors of curves to colormap. If None, use the default color palette.
+        """
+        if colormap is not None:
+            self.config.color_palette = colormap
+
+        colors = Colors.golden_angle_color(
+            colormap=self.config.color_palette, num=len(self.plot_item.curves) + 1, format="HEX"
+        )
+        for curve, color in zip(self.curves, colors):
+            curve.set_color(color)
+
     def setup_dap(self, old_scan_id: str | None, new_scan_id: str | None):
         """
         Setup DAP for the new scan.
@@ -1051,7 +1084,9 @@ class BECWaveform(BECPlotBase):
                     y = msg["data"][0]["y"]
                     curve.setData(x, y)
                     curve.dap_params = msg["data"][1]["fit_parameters"]
+                    curve.dap_summary = msg["data"][1]["fit_summary"]
                     self.dap_params_update.emit(curve.dap_params)
+                    self.dap_summary_update.emit(curve.dap_summary)
                 break
 
     @pyqtSlot(dict, dict)
@@ -1180,7 +1215,6 @@ class BECWaveform(BECPlotBase):
             timestamps = self.scan_item.data[y_name][y_entry].timestamps
 
             x_data = timestamps
-            print(x_data)
             return x_data
         if self._x_axis_mode["name"] == "index":
             x_data = None
@@ -1214,49 +1248,6 @@ class BECWaveform(BECPlotBase):
                 x_data = []
         return x_data
 
-    # def _get_x_data(self, curve: BECCurve, y_name: str, y_entry: str) -> list | np.ndarray | None:
-    #     """
-    #     Get the x data for the curve with the decision logic based on the curve configuration:
-    #         - If x is called 'timestamp', use the timestamp data from the scan item.
-    #         - If x is called 'index', use the rolling index.
-    #         - If x is a custom signal, use the data from the scan item.
-    #         - If x is not specified, use the first device from the scan report.
-    #
-    #     Args:
-    #         curve(BECCurve): The curve object.
-    #
-    #     Returns:
-    #         list|np.ndarray|None: X data for the curve.
-    #     """
-    #     x_data = None
-    #     if curve.config.signals.x is not None:
-    #         if curve.config.signals.x.name == "timestamp":
-    #             timestamps = self.scan_item.data[y_name][y_entry].timestamps
-    #             x_data = self.convert_timestamps(timestamps)
-    #         elif curve.config.signals.x.name == "index":
-    #             x_data = None
-    #         else:
-    #             x_name = curve.config.signals.x.name
-    #             x_entry = curve.config.signals.x.entry
-    #             try:
-    #                 x_data = self.scan_item.data[x_name][x_entry].val
-    #             except TypeError:
-    #                 x_data = []
-    #     else:
-    #         if len(self._curves_data["async"]) > 0:
-    #             x_data = None
-    #         else:
-    #             x_name = self.scan_item.status_message.info["scan_report_devices"][0]
-    #             x_entry = self.entry_validator.validate_signal(x_name, None)
-    #             x_data = self.scan_item.data[x_name][x_entry].val
-    #             self._x_axis_mode["label_suffix"] = f" [auto: {x_name}-{x_entry}]"
-    #             current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
-    #             self.plot_item.setLabel(
-    #                 "bottom", f"{current_label}{self._x_axis_mode['label_suffix']}"
-    #             )
-    #
-    #     return x_data
-
     def _make_z_gradient(self, data_z: list | np.ndarray, colormap: str) -> list | None:
         """
         Make a gradient color for the z values.
@@ -1349,6 +1340,13 @@ class BECWaveform(BECPlotBase):
             return combined_data
         return data
 
+    def export_to_matplotlib(self):
+        """
+        Export current waveform to matplotlib gui. Available only if matplotlib is installed in the enviroment.
+
+        """
+        MatplotlibExporter(self.plot_item).export()
+
     def clear_all(self):
         curves_data = self._curves_data
         sources = list(curves_data.keys())

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

@@ -101,6 +101,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         self.parent_item = parent_item
         self.apply_config()
         self.dap_params = None
+        self.dap_summary = None
         if kwargs:
             self.set(**kwargs)
 
@@ -132,6 +133,14 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     def dap_params(self, value):
         self._dap_params = value
 
+    @property
+    def dap_summary(self):
+        return self._dap_report
+
+    @dap_summary.setter
+    def dap_summary(self, value):
+        self._dap_report = value
+
     def set_data(self, x, y):
         if self.config.source == "custom":
             self.setData(x, y)

bec_widgets/widgets/motor_map/bec_motor_map_widget_plugin.py

@@ -3,6 +3,7 @@ import os
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 from qtpy.QtGui import QIcon
 
+import bec_widgets
 from bec_widgets.widgets.motor_map.motor_map_widget import BECMotorMapWidget
 
 DOM_XML = """
@@ -12,6 +13,8 @@ DOM_XML = """
 </ui>
 """
 
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
 
 class BECMotorMapWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -26,11 +29,10 @@ class BECMotorMapWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cov
         return DOM_XML
 
     def group(self):
-        return "BEC Visualization Widgets"
+        return "BEC Plots"
 
     def icon(self):
-        current_path = os.path.dirname(__file__)
-        icon_path = os.path.join(current_path, "assets", "motor_map.png")
+        icon_path = os.path.join(MODULE_PATH, "assets", "designer_icons", "motor_map.png")
         return QIcon(icon_path)
 
     def includeFile(self):

bec_widgets/widgets/motor_map/motor_map_widget.py

@@ -5,17 +5,12 @@ import sys
 from qtpy.QtWidgets import QVBoxLayout, QWidget
 
 from bec_widgets.qt_utils.settings_dialog import SettingsDialog
-from bec_widgets.qt_utils.toolbar import ModularToolBar
+from bec_widgets.qt_utils.toolbar import DeviceSelectionAction, IconAction, ModularToolBar
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.figure.plots.motor_map.motor_map import MotorMapConfig
 from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_settings import MotorMapSettings
-from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_toolbar import (
-    ConnectAction,
-    DeviceSelectionAction,
-    ResetHistoryAction,
-    SettingsAction,
-)
 
 
 class BECMotorMapWidget(BECWidget, QWidget):
@@ -28,6 +23,7 @@ class BECMotorMapWidget(BECWidget, QWidget):
         "set_scatter_size",
         "get_data",
         "reset_history",
+        "export",
     ]
 
     def __init__(
@@ -52,11 +48,15 @@ class BECMotorMapWidget(BECWidget, QWidget):
         self.fig = BECFigure()
         self.toolbar = ModularToolBar(
             actions={
-                "motor_x": DeviceSelectionAction("Motor X:"),
-                "motor_y": DeviceSelectionAction("Motor Y:"),
-                "connect": ConnectAction(),
-                "history": ResetHistoryAction(),
-                "config": SettingsAction(),
+                "motor_x": DeviceSelectionAction(
+                    "Motor X:", DeviceComboBox(device_filter="Positioner")
+                ),
+                "motor_y": DeviceSelectionAction(
+                    "Motor Y:", DeviceComboBox(device_filter="Positioner")
+                ),
+                "connect": IconAction(icon_path="connection.svg", tooltip="Connect Motors"),
+                "history": IconAction(icon_path="history.svg", tooltip="Reset Trace History"),
+                "config": IconAction(icon_path="settings.svg", tooltip="Open Configuration Dialog"),
             },
             target_widget=self,
         )
@@ -202,6 +202,12 @@ class BECMotorMapWidget(BECWidget, QWidget):
         """
         self.map.set_scatter_size(scatter_size)
 
+    def export(self):
+        """
+        Show the export dialog for the motor map.
+        """
+        self.map.export()
+
     def cleanup(self):
         self.fig.cleanup()
         self.toolbar.widgets["motor_x"].device_combobox.cleanup()

bec_widgets/widgets/waveform/bec_waveform_widget.pyproject

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

bec_widgets/widgets/waveform/bec_waveform_widget_plugin.py

@@ -0,0 +1,59 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+import bec_widgets
+from bec_widgets.widgets.waveform.waveform_widget import BECWaveformWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECWaveformWidget' name='bec_waveform_widget'>
+    </widget>
+</ui>
+"""
+
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
+
+class BECWaveformWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECWaveformWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Plots"
+
+    def icon(self):
+        icon_path = os.path.join(MODULE_PATH, "assets", "designer_icons", "BECWaveformWidget.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "bec_waveform_widget"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECWaveformWidget"
+
+    def toolTip(self):
+        return "BECWaveformWidget"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/waveform/register_bec_waveform_widget.py

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