bec-widgets 1.20.0__tar.gz → 1.21.0__tar.gz

{bec_widgets-1.20.0 → bec_widgets-1.21.0}/CHANGELOG.md

@@ -1,6 +1,14 @@
 # CHANGELOG
 
 
+## v1.21.0 (2025-02-17)
+
+### Features
+
+- Generated form for scan metadata
+  ([`1708bd4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1708bd405f86b1353828b01fbf5f98383a19ec2a))
+
+
 ## v1.20.0 (2025-02-06)
 
 ### Features

{bec_widgets-1.20.0 → bec_widgets-1.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_widgets
-Version: 1.20.0
+Version: 1.21.0
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets

bec_widgets-1.21.0/bec_widgets/widgets/editors/scan_metadata/__init__.py

@@ -0,0 +1,7 @@
+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-1.21.0/bec_widgets/widgets/editors/scan_metadata/_metadata_widgets.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from decimal import Decimal
+from typing import TYPE_CHECKING, Callable, get_args
+
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from pydantic import BaseModel, Field
+from qtpy.QtCore import Signal  # type: ignore
+from qtpy.QtWidgets import (
+    QApplication,
+    QButtonGroup,
+    QCheckBox,
+    QDoubleSpinBox,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QLayout,
+    QLineEdit,
+    QRadioButton,
+    QSpinBox,
+    QToolButton,
+    QWidget,
+)
+
+from bec_widgets.widgets.editors.scan_metadata._util import (
+    clearable_required,
+    field_default,
+    field_limits,
+    field_maxlen,
+    field_minlen,
+    field_precision,
+)
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
+logger = bec_logger.logger
+
+
+class ClearableBoolEntry(QWidget):
+    stateChanged = Signal()
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._layout = QHBoxLayout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self._layout)
+        self._layout.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
+        self._entry = QButtonGroup()
+        self._true = QRadioButton("true", parent=self)
+        self._false = QRadioButton("false", parent=self)
+        for button in [self._true, self._false]:
+            self._layout.addWidget(button)
+            self._entry.addButton(button)
+            button.toggled.connect(self.stateChanged)
+
+    def clear(self):
+        self._entry.setExclusive(False)
+        self._true.setChecked(False)
+        self._false.setChecked(False)
+        self._entry.setExclusive(True)
+
+    def isChecked(self) -> bool | None:
+        if not self._true.isChecked() and not self._false.isChecked():
+            return None
+        return self._true.isChecked()
+
+    def setChecked(self, value: bool | None):
+        if value is None:
+            self.clear()
+        elif value:
+            self._true.setChecked(True)
+            self._false.setChecked(False)
+        else:
+            self._true.setChecked(False)
+            self._false.setChecked(True)
+
+    def setToolTip(self, tooltip: str):
+        self._true.setToolTip(tooltip)
+        self._false.setToolTip(tooltip)
+
+
+class MetadataWidget(QWidget):
+
+    valueChanged = Signal()
+
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._info = info
+        self._layout = QHBoxLayout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.setSizeConstraint(QLayout.SizeConstraint.SetMaximumSize)
+        self._default = field_default(self._info)
+        self._desc = self._info.description
+        self.setLayout(self._layout)
+        self._add_main_widget()
+        if clearable_required(info):
+            self._add_clear_button()
+
+    @abstractmethod
+    def getValue(self): ...
+
+    @abstractmethod
+    def setValue(self, value): ...
+
+    @abstractmethod
+    def _add_main_widget(self) -> None:
+        """Add the main data entry widget to self._main_widget and appply any
+        constraints from the field info"""
+
+    def _describe(self, pad=" "):
+        return pad + (self._desc if self._desc else "")
+
+    def _add_clear_button(self):
+        self._clear_button = QToolButton()
+        self._clear_button.setIcon(
+            material_icon(icon_name="close", size=(10, 10), convert_to_pixmap=False)
+        )
+        self._layout.addWidget(self._clear_button)
+        # the widget added in _add_main_widget must implement .clear() if value is not required
+        self._clear_button.setToolTip("Clear value or reset to default.")
+        self._clear_button.clicked.connect(self._main_widget.clear)  # type: ignore
+
+    def _value_changed(self, *_, **__):
+        self.valueChanged.emit()
+
+
+class StrMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.textChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QLineEdit()
+        self._layout.addWidget(self._main_widget)
+        min_length, max_length = field_minlen(self._info), field_maxlen(self._info)
+        if max_length:
+            self._main_widget.setMaxLength(max_length)
+        self._main_widget.setToolTip(
+            f"(length min: {min_length} max: {max_length}){self._describe()}"
+        )
+        if self._default:
+            self._main_widget.setText(self._default)
+            self._add_clear_button()
+
+    def getValue(self):
+        if self._main_widget.text() == "":
+            return self._default
+        return self._main_widget.text()
+
+    def setValue(self, value: str):
+        if value is None:
+            self._main_widget.setText("")
+        self._main_widget.setText(value)
+
+
+class IntMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.textChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QSpinBox()
+        self._layout.addWidget(self._main_widget)
+        min_, max_ = field_limits(self._info, int)
+        self._main_widget.setMinimum(min_)
+        self._main_widget.setMaximum(max_)
+        self._main_widget.setToolTip(f"(range {min_} to {max_}){self._describe()}")
+        if self._default is not None:
+            self._main_widget.setValue(self._default)
+            self._add_clear_button()
+        else:
+            self._main_widget.clear()
+
+    def getValue(self):
+        if self._main_widget.text() == "":
+            return self._default
+        return self._main_widget.value()
+
+    def setValue(self, value: int):
+        if value is None:
+            self._main_widget.clear()
+        self._main_widget.setValue(value)
+
+
+class FloatDecimalMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.textChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QDoubleSpinBox()
+        self._layout.addWidget(self._main_widget)
+        min_, max_ = field_limits(self._info, int)
+        self._main_widget.setMinimum(min_)
+        self._main_widget.setMaximum(max_)
+        precision = field_precision(self._info)
+        if precision:
+            self._main_widget.setDecimals(precision)
+        minstr = f"{float(min_):.3f}" if abs(min_) <= 1000 else f"{float(min_):.3e}"
+        maxstr = f"{float(max_):.3f}" if abs(max_) <= 1000 else f"{float(max_):.3e}"
+        self._main_widget.setToolTip(f"(range {minstr} to {maxstr}){self._describe()}")
+        if self._default is not None:
+            self._main_widget.setValue(self._default)
+            self._add_clear_button()
+        else:
+            self._main_widget.clear()
+
+    def getValue(self):
+        if self._main_widget.text() == "":
+            return self._default
+        return self._main_widget.value()
+
+    def setValue(self, value: float):
+        if value is None:
+            self._main_widget.clear()
+        self._main_widget.setValue(value)
+
+
+class BoolMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.stateChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        if clearable_required(self._info):
+            self._main_widget = ClearableBoolEntry()
+        else:
+            self._main_widget = QCheckBox()
+        self._layout.addWidget(self._main_widget)
+        self._main_widget.setToolTip(self._describe(""))
+        self._main_widget.setChecked(self._default)  # type: ignore # if there is no default then it will be ClearableBoolEntry and can be set with None
+
+    def getValue(self):
+        return self._main_widget.isChecked()
+
+    def setValue(self, value):
+        self._main_widget.setChecked(value)
+
+
+def widget_from_type(annotation: type | None) -> Callable[[FieldInfo], MetadataWidget]:
+    if annotation in [str, str | None]:
+        return StrMetadataField
+    if annotation in [int, int | None]:
+        return IntMetadataField
+    if annotation in [float, float | None, Decimal, Decimal | None]:
+        return FloatDecimalMetadataField
+    if annotation in [bool, bool | None]:
+        return BoolMetadataField
+    else:
+        logger.warning(f"Type {annotation} is not (yet) supported in metadata form creation.")
+        return StrMetadataField
+
+
+if __name__ == "__main__":  # pragma: no cover
+
+    class TestModel(BaseModel):
+        value1: str | None = Field(None)
+        value2: bool | None = Field(None)
+        value3: bool = Field(True)
+        value4: int = Field(123)
+        value5: int | None = Field()
+
+    app = QApplication([])
+    w = QWidget()
+    layout = QGridLayout()
+    w.setLayout(layout)
+    for i, (field_name, info) in enumerate(TestModel.model_fields.items()):
+        layout.addWidget(QLabel(field_name), i, 0)
+        layout.addWidget(widget_from_type(info.annotation)(info), i, 1)
+
+    w.show()
+    app.exec()

bec_widgets-1.21.0/bec_widgets/widgets/editors/scan_metadata/_util.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import sys
+from decimal import Decimal
+from math import inf, nextafter
+from typing import TYPE_CHECKING, TypeVar, get_args
+
+from annotated_types import Ge, Gt, Le, Lt
+from bec_lib.logger import bec_logger
+from pydantic_core import PydanticUndefined
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
+logger = bec_logger.logger
+
+
+_MININT = -2147483648
+_MAXINT = 2147483647
+_MINFLOAT = -sys.float_info.max
+_MAXFLOAT = sys.float_info.max
+
+T = TypeVar("T", int, float, Decimal)
+
+
+def field_limits(info: FieldInfo, type_: type[T]) -> tuple[T, T]:
+    _min = _MININT if type_ is int else _MINFLOAT
+    _max = _MAXINT if type_ is int else _MAXFLOAT
+    for md in info.metadata:
+        if isinstance(md, Ge):
+            _min = type_(md.ge)  # type: ignore
+        if isinstance(md, Gt):
+            _min = type_(md.gt) + 1 if type_ is int else nextafter(type_(md.gt), inf)  # type: ignore
+        if isinstance(md, Lt):
+            _max = type_(md.lt) - 1 if type_ is int else nextafter(type_(md.lt), -inf)  # type: ignore
+        if isinstance(md, Le):
+            _max = type_(md.le)  # type: ignore
+    return _min, _max  # type: ignore
+
+
+def _get_anno(info: FieldInfo, annotation: str, default):
+    for md in info.metadata:
+        if hasattr(md, annotation):
+            return getattr(md, annotation)
+    return default
+
+
+def field_precision(info: FieldInfo):
+    return _get_anno(info, "decimal_places", 307)
+
+
+def field_maxlen(info: FieldInfo):
+    return _get_anno(info, "max_length", None)
+
+
+def field_minlen(info: FieldInfo):
+    return _get_anno(info, "min_length", None)
+
+
+def field_default(info: FieldInfo):
+    if info.default is PydanticUndefined:
+        return
+    return info.default
+
+
+def clearable_required(info: FieldInfo):
+    return type(None) in get_args(info.annotation) or info.is_required()

bec_widgets-1.21.0/bec_widgets/widgets/editors/scan_metadata/additional_metadata_table.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from typing import Any
+
+from qtpy.QtCore import QAbstractTableModel, QModelIndex, Qt, Signal  # type: ignore
+from qtpy.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QTableView,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.qt_utils.error_popups import SafeSlot
+
+
+class AdditionalMetadataTableModel(QAbstractTableModel):
+    def __init__(self, data):
+        super().__init__()
+        self._data: list[list[str]] = data
+        self._disallowed_keys: list[str] = []
+
+    def headerData(
+        self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole()
+    ) -> Any:
+        if orientation == Qt.Orientation.Horizontal and role == Qt.ItemDataRole.DisplayRole:
+            return "Key" if section == 0 else "Value"
+        return super().headerData(section, orientation, role)
+
+    def rowCount(self, index: QModelIndex = QModelIndex()):
+        return 0 if index.isValid() else len(self._data)
+
+    def columnCount(self, index: QModelIndex = QModelIndex()):
+        return 0 if index.isValid() else 2
+
+    def data(self, index, role=Qt.ItemDataRole):
+        if index.isValid():
+            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
+                return str(self._data[index.row()][index.column()])
+
+    def setData(self, index, value, role):
+        if role == Qt.ItemDataRole.EditRole:
+            if value in self._disallowed_keys or value in self._other_keys(index.row()):
+                return False
+            self._data[index.row()][index.column()] = str(value)
+            return True
+        return False
+
+    def update_disallowed_keys(self, keys: list[str]):
+        self._disallowed_keys = keys
+        for i, item in enumerate(self._data):
+            if item[0] in self._disallowed_keys:
+                self._data[i][0] = ""
+                self.dataChanged.emit(self.index(i, 0), self.index(i, 0))
+
+    def _other_keys(self, row: int):
+        return [r[0] for r in self._data[:row] + self._data[row + 1 :]]
+
+    def flags(self, _):
+        return Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsEditable
+
+    def insertRows(self, row, number, index):
+        """We only support adding one at a time for now"""
+        if row != self.rowCount() or number != 1:
+            return False
+        self.beginInsertRows(QModelIndex(), 0, 0)
+        self._data.append(["", ""])
+        self.endInsertRows()
+        return True
+
+    def removeRows(self, row, number, index):
+        """This can only be consecutive, so instead of trying to be clever, only support removing one at a time"""
+        if number != 1:
+            return False
+        self.beginRemoveRows(QModelIndex(), row, row)
+        del self._data[row]
+        self.endRemoveRows()
+        return True
+
+    @SafeSlot()
+    def add_row(self):
+        self.insertRow(self.rowCount())
+
+    @SafeSlot(list)
+    def delete_rows(self, rows: list[int]):
+        # delete from the end so indices stay correct
+        for row in sorted(rows, reverse=True):
+            self.removeRows(row, 1, QModelIndex())
+
+    def dump_dict(self):
+        if self._data == [[]]:
+            return {}
+        return dict(self._data)
+
+
+class AdditionalMetadataTable(QWidget):
+
+    delete_rows = Signal(list)
+
+    def __init__(self, initial_data: list[list[str]]):
+        super().__init__()
+
+        self._layout = QHBoxLayout()
+        self.setLayout(self._layout)
+        self._table_model = AdditionalMetadataTableModel(initial_data)
+        self._table_view = QTableView()
+        self._table_view.setModel(self._table_model)
+        self._table_view.horizontalHeader().setStretchLastSection(True)
+        self._layout.addWidget(self._table_view)
+
+        self._buttons = QVBoxLayout()
+        self._layout.addLayout(self._buttons)
+        self._add_button = QPushButton("+")
+        self._add_button.setToolTip("add a new row")
+        self._remove_button = QPushButton("-")
+        self._remove_button.setToolTip("delete rows containing any selected cells")
+        self._buttons.addWidget(self._add_button)
+        self._buttons.addWidget(self._remove_button)
+        self._add_button.clicked.connect(self._table_model.add_row)
+        self._remove_button.clicked.connect(self.delete_selected_rows)
+        self.delete_rows.connect(self._table_model.delete_rows)
+
+    def delete_selected_rows(self):
+        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):
+        return self._table_model.dump_dict()
+
+    def update_disallowed_keys(self, keys: list[str]):
+        self._table_model.update_disallowed_keys(keys)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication([])
+    set_theme("dark")
+
+    window = AdditionalMetadataTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
+    window.show()
+    app.exec()