bec-widgets 1.25.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

bec_widgets/widgets/editors/{scan_metadata/additional_metadata_table.py → dict_backed_table.py}

@@ -13,15 +13,23 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.utils.error_popups import SafeSlot
 
 
-class AdditionalMetadataTableModel(QAbstractTableModel):
+class DictBackedTableModel(QAbstractTableModel):
     def __init__(self, data):
+        """A model to go with DictBackedTable, which represents key-value pairs
+        to be displayed in a TreeWidget.
+
+        Args:
+            data (list[list[str]]): list of key-value pairs to initialise with"""
         super().__init__()
         self._data: list[list[str]] = data
         self._disallowed_keys: list[str] = []
 
+    # pylint: disable=missing-function-docstring
+    # see QAbstractTableModel documentation for these methods
+
     def headerData(
         self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole()
     ) -> Any:
@@ -49,6 +57,10 @@ class AdditionalMetadataTableModel(QAbstractTableModel):
         return False
 
     def update_disallowed_keys(self, keys: list[str]):
+        """Set the list of keys which may not be used.
+
+        Args:
+            keys (list[str]): list of keys which are forbidden."""
         self._disallowed_keys = keys
         for i, item in enumerate(self._data):
             if item[0] in self._disallowed_keys:
@@ -95,16 +107,21 @@ class AdditionalMetadataTableModel(QAbstractTableModel):
         return dict(self._data)
 
 
-class AdditionalMetadataTable(QWidget):
-
+class DictBackedTable(QWidget):
     delete_rows = Signal(list)
 
     def __init__(self, initial_data: list[list[str]]):
+        """Widget which uses a DictBackedTableModel to display an editable table
+        which can be extracted as a dict.
+
+        Args:
+            initial_data (list[list[str]]): list of key-value pairs to initialise with
+        """
         super().__init__()
 
         self._layout = QHBoxLayout()
         self.setLayout(self._layout)
-        self._table_model = AdditionalMetadataTableModel(initial_data)
+        self._table_model = DictBackedTableModel(initial_data)
         self._table_view = QTreeView()
         self._table_view.setModel(self._table_model)
         self._table_view.setSizePolicy(
@@ -126,15 +143,21 @@ class AdditionalMetadataTable(QWidget):
         self.delete_rows.connect(self._table_model.delete_rows)
 
     def delete_selected_rows(self):
+        """Delete rows which are part of the selection model"""
         cells: list[QModelIndex] = self._table_view.selectionModel().selectedIndexes()
         row_indices = list({r.row() for r in cells})
         if row_indices:
             self.delete_rows.emit(row_indices)
 
     def dump_dict(self):
+        """Get the current content of the table as a dict"""
         return self._table_model.dump_dict()
 
     def update_disallowed_keys(self, keys: list[str]):
+        """Set the list of keys which may not be used.
+
+        Args:
+            keys (list[str]): list of keys which are forbidden."""
         self._table_model.update_disallowed_keys(keys)
 
 
@@ -144,6 +167,6 @@ if __name__ == "__main__":  # pragma: no cover
     app = QApplication([])
     set_theme("dark")
 
-    window = AdditionalMetadataTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
+    window = DictBackedTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
     window.show()
     app.exec()

bec_widgets/widgets/editors/scan_metadata/__init__.py

@@ -1,7 +0,0 @@
-from bec_widgets.widgets.editors.scan_metadata.additional_metadata_table import (
-    AdditionalMetadataTable,
-    AdditionalMetadataTableModel,
-)
-from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
-
-__all__ = ["ScanMetadata", "AdditionalMetadataTable", "AdditionalMetadataTableModel"]

bec_widgets/widgets/editors/scan_metadata/_util.py

@@ -9,7 +9,7 @@ from annotated_types import Ge, Gt, Le, Lt
 from bec_lib.logger import bec_logger
 from pydantic_core import PydanticUndefined
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from pydantic.fields import FieldInfo
 
 logger = bec_logger.logger

bec_widgets/widgets/{plots/motor_map/register_bec_motor_map_widget.py → editors/scan_metadata/register_scan_metadata.py}

@@ -6,11 +6,9 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.plots.motor_map.bec_motor_map_widget_plugin import (
-        BECMotorMapWidgetPlugin,
-    )
+    from bec_widgets.widgets.editors.scan_metadata.scan_metadata_plugin import ScanMetadataPlugin
 
-    QPyDesignerCustomWidgetCollection.addCustomWidget(BECMotorMapWidgetPlugin())
+    QPyDesignerCustomWidgetCollection.addCustomWidget(ScanMetadataPlugin())
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

@@ -1,48 +1,21 @@
 from __future__ import annotations
 
 from decimal import Decimal
-from types import NoneType
-from typing import TYPE_CHECKING
 
 from bec_lib.logger import bec_logger
 from bec_lib.metadata_schema import get_metadata_schema_for_scan
-from bec_qthemes import material_icon
-from pydantic import Field, ValidationError
-from qtpy.QtCore import Signal  # type: ignore
-from qtpy.QtWidgets import (
-    QApplication,
-    QComboBox,
-    QGridLayout,
-    QHBoxLayout,
-    QLabel,
-    QLayout,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
-from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
-from bec_widgets.qt_utils.expandable_frame import ExpandableGroupFrame
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.widgets.editors.scan_metadata._metadata_widgets import widget_from_type
-from bec_widgets.widgets.editors.scan_metadata.additional_metadata_table import (
-    AdditionalMetadataTable,
-)
-
-if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
-
-logger = bec_logger.logger
+from pydantic import Field
+from qtpy.QtWidgets import QApplication, QComboBox, QHBoxLayout, QVBoxLayout, QWidget
 
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
+from bec_widgets.utils.forms_from_types.forms import PydanticModelForm
+from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
 
-class ScanMetadata(BECWidget, QWidget):
-    """Dynamically generates a form for inclusion of metadata for a scan. Uses the
-    metadata schema registry supplied in the plugin repo to find pydantic models
-    associated with the scan type. Sets limits for numerical values if specified."""
+logger = bec_logger.logger
 
-    metadata_updated = Signal(dict)
-    metadata_cleared = Signal(NoneType)
 
+class ScanMetadata(PydanticModelForm):
     def __init__(
         self,
         parent=None,
@@ -51,119 +24,36 @@ class ScanMetadata(BECWidget, QWidget):
         initial_extras: list[list[str]] | None = None,
         **kwargs,
     ):
-        super().__init__(client=client, **kwargs)
-        QWidget.__init__(self, parent=parent)
-
-        self.set_schema(scan_name)
-
-        self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self.setLayout(self._layout)
+        """Dynamically generates a form for inclusion of metadata for a scan. Uses the
+        metadata schema registry supplied in the plugin repo to find pydantic models
+        associated with the scan type. Sets limits for numerical values if specified.
 
-        self._required_md_box = ExpandableGroupFrame("Scan schema metadata")
-        self._layout.addWidget(self._required_md_box)
-        self._required_md_box_layout = QHBoxLayout()
-        self._required_md_box.set_layout(self._required_md_box_layout)
-
-        self._md_grid = QWidget()
-        self._required_md_box_layout.addWidget(self._md_grid)
-        self._grid_container = QVBoxLayout()
-        self._md_grid.setLayout(self._grid_container)
-        self._new_grid_layout()
-        self._grid_container.addLayout(self._md_grid_layout)
+        Args:
+            scan_name (str): The scan for which to generate a metadata form
+            Initial_extras (list[list[str]]): Initial data with which to populate the additional
+                                              metadata table - inner lists should be key-value pairs
+        """
 
+        # self.populate() gets called in super().__init__
+        # so make sure self._additional_metadata exists
         self._additional_md_box = ExpandableGroupFrame("Additional metadata", expanded=False)
-        self._layout.addWidget(self._additional_md_box)
         self._additional_md_box_layout = QHBoxLayout()
         self._additional_md_box.set_layout(self._additional_md_box_layout)
 
-        self._additional_metadata = AdditionalMetadataTable(initial_extras or [])
-        self._additional_md_box_layout.addWidget(self._additional_metadata)
+        self._additional_metadata = DictBackedTable(initial_extras or [])
+        self._scan_name = scan_name or ""
+        self._md_schema = get_metadata_schema_for_scan(self._scan_name)
 
-        self._validity = CompactPopupWidget()
-        self._validity.compact_view = True  # type: ignore
-        self._validity.label = "Metadata validity"  # type: ignore
-        self._validity.compact_show_popup.setIcon(
-            material_icon(icon_name="info", size=(10, 10), convert_to_pixmap=False)
-        )
-        self._validity_message = QLabel("Not yet validated")
-        self._validity.addWidget(self._validity_message)
-        self._layout.addWidget(self._validity)
+        super().__init__(parent=parent, metadata_model=self._md_schema, client=client, **kwargs)
 
-        self.populate()
+        self._layout.addWidget(self._additional_md_box)
+        self._additional_md_box_layout.addWidget(self._additional_metadata)
 
     @SafeSlot(str)
     def update_with_new_scan(self, scan_name: str):
-        self.set_schema(scan_name)
-        self.populate()
+        self.set_schema_from_scan(scan_name)
         self.validate_form()
 
-    def validate_form(self, *_) -> bool:
-        """validate the currently entered metadata against the pydantic schema.
-        If successful, returns on metadata_emitted and returns true.
-        Otherwise, emits on metadata_cleared and returns false."""
-        try:
-            metadata_dict = self.get_full_model_dict()
-            self._md_schema.model_validate(metadata_dict)
-            self._validity.set_global_state("success")
-            self._validity_message.setText("No errors!")
-            self.metadata_updated.emit(metadata_dict)
-        except ValidationError as e:
-            self._validity.set_global_state("emergency")
-            self._validity_message.setText(str(e))
-            self.metadata_cleared.emit(None)
-
-    def get_full_model_dict(self):
-        """Get the entered metadata as a dict"""
-        return self._additional_metadata.dump_dict() | self._dict_from_grid()
-
-    def set_schema(self, scan_name: str | None = None):
-        self._scan_name = scan_name or ""
-        self._md_schema = get_metadata_schema_for_scan(self._scan_name)
-
-    def populate(self):
-        self._clear_grid()
-        self._populate()
-
-    def _populate(self):
-        self._additional_metadata.update_disallowed_keys(list(self._md_schema.model_fields.keys()))
-        for i, (field_name, info) in enumerate(self._md_schema.model_fields.items()):
-            self._add_griditem(field_name, info, i)
-
-    def _add_griditem(self, field_name: str, info: FieldInfo, row: int):
-        grid = self._md_grid_layout
-        label = QLabel(info.title or field_name)
-        label.setProperty("_model_field_name", field_name)
-        label.setToolTip(info.description or field_name)
-        grid.addWidget(label, row, 0)
-        widget = widget_from_type(info.annotation)(info)
-        widget.valueChanged.connect(self.validate_form)
-        grid.addWidget(widget, row, 1)
-
-    def _dict_from_grid(self) -> dict[str, str | int | float | Decimal | bool]:
-        grid = self._md_grid_layout
-        return {
-            grid.itemAtPosition(i, 0).widget().property("_model_field_name"): grid.itemAtPosition(i, 1).widget().getValue()  # type: ignore # we only add 'MetadataWidget's here
-            for i in range(grid.rowCount())
-        }
-
-    def _clear_grid(self):
-        while self._md_grid_layout.count():
-            item = self._md_grid_layout.takeAt(0)
-            widget = item.widget()
-            if widget is not None:
-                widget.deleteLater()
-        self._md_grid_layout.deleteLater()
-        self._new_grid_layout()
-        self._grid_container.addLayout(self._md_grid_layout)
-        self._md_grid.adjustSize()
-        self.adjustSize()
-
-    def _new_grid_layout(self):
-        self._md_grid_layout = QGridLayout()
-        self._md_grid_layout.setContentsMargins(0, 0, 0, 0)
-        self._md_grid_layout.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
-
     @SafeProperty(bool)
     def hide_optional_metadata(self):  # type: ignore
         """Property to hide the optional metadata table."""
@@ -178,8 +68,25 @@ class ScanMetadata(BECWidget, QWidget):
         """
         self._additional_md_box.setVisible(not hide)
 
+    def get_form_data(self):
+        """Get the entered metadata as a dict"""
+        return self._additional_metadata.dump_dict() | self._dict_from_grid()
+
+    def populate(self):
+        self._additional_metadata.update_disallowed_keys(list(self._md_schema.model_fields.keys()))
+        super().populate()
+
+    def set_schema_from_scan(self, scan_name: str | None):
+        self._scan_name = scan_name or ""
+        self.set_schema(get_metadata_schema_for_scan(self._scan_name))
+        self.populate()
+
 
 if __name__ == "__main__":  # pragma: no cover
+    # pylint: disable=redefined-outer-name
+    # pylint: disable=protected-access
+    # pylint: disable=disallowed-name
+
     from unittest.mock import patch
 
     from bec_lib.metadata_schema import BasicScanMetadata
@@ -210,7 +117,6 @@ if __name__ == "__main__":  # pragma: no cover
         "bec_lib.metadata_schema._get_metadata_schema_registry",
         lambda: {"scan1": ExampleSchema1, "scan2": ExampleSchema2, "scan3": ExampleSchema3},
     ):
-
         app = QApplication([])
         w = QWidget()
         selection = QComboBox()

bec_widgets/widgets/editors/scan_metadata/scan_metadata.pyproject

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

bec_widgets/widgets/{plots/multi_waveform/bec_multi_waveform_widget_plugin.py → editors/scan_metadata/scan_metadata_plugin.py}

@@ -4,36 +4,36 @@
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.plots.multi_waveform.multi_waveform_widget import BECMultiWaveformWidget
+from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='BECMultiWaveformWidget' name='bec_multi_waveform_widget'>
+    <widget class='ScanMetadata' name='scan_metadata'>
     </widget>
 </ui>
 """
 
 
-class BECMultiWaveformWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+class ScanMetadataPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = BECMultiWaveformWidget(parent)
+        t = ScanMetadata(parent)
         return t
 
     def domXml(self):
         return DOM_XML
 
     def group(self):
-        return "BEC Plots"
+        return ""
 
     def icon(self):
-        return designer_material_icon(BECMultiWaveformWidget.ICON_NAME)
+        return designer_material_icon(ScanMetadata.ICON_NAME)
 
     def includeFile(self):
-        return "bec_multi_waveform_widget"
+        return "scan_metadata"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -45,10 +45,10 @@ class BECMultiWaveformWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: n
         return self._form_editor is not None
 
     def name(self):
-        return "BECMultiWaveformWidget"
+        return "ScanMetadata"
 
     def toolTip(self):
-        return "BECMultiWaveformWidget"
+        return "Dynamically generates a form for inclusion of metadata for a scan."
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/editors/text_box/text_box.py

@@ -7,9 +7,9 @@ from bec_lib.logger import bec_logger
 from pydantic import Field
 from qtpy.QtWidgets import QTextEdit, QVBoxLayout, QWidget
 
-from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.bec_connector import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 
 logger = bec_logger.logger
 
@@ -49,8 +49,7 @@ class TextBox(BECWidget, QWidget):
             if isinstance(config, dict):
                 config = TextBoxConfig(**config)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         self.layout = QVBoxLayout(self)
         self.text_box_text_edit = QTextEdit(parent=self)
         self.layout.addWidget(self.text_box_text_edit)

bec_widgets/widgets/editors/website/website.py

@@ -26,8 +26,7 @@ class WebsiteWidget(BECWidget, QWidget):
     def __init__(
         self, parent=None, url: str = None, config=None, client=None, gui_id=None, **kwargs
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         layout = QVBoxLayout()
         layout.setContentsMargins(0, 0, 0, 0)
         self.website = QWebEngineView()
@@ -118,6 +117,7 @@ class WebsiteWidget(BECWidget, QWidget):
         Cleanup the widget
         """
         self.website.page().deleteLater()
+        super().cleanup()
 
 
 if __name__ == "__main__":

bec_widgets/widgets/games/minesweeper.py

@@ -144,10 +144,10 @@ class Minesweeper(BECWidget, QWidget):
     PLUGIN = True
     ICON_NAME = "videogame_asset"
     USER_ACCESS = []
+    RPC = True
 
     def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, *args, **kwargs)
 
         self._ui_initialised = False
         self._timer_start_num_seconds = 0
@@ -403,6 +403,7 @@ class Minesweeper(BECWidget, QWidget):
 
     def cleanup(self):
         self._timer.stop()
+        super().cleanup()
 
 
 if __name__ == "__main__":