bec-widgets 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

CHANGELOG.md

@@ -1,6 +1,36 @@
 # CHANGELOG
 
 
+## v1.2.0 (2024-10-25)
+
+### Features
+
+* feat(colors): evenly spaced color generation + new golden ratio calculation ([`40c9fea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/40c9fea35f869ef52e05948dd1989bcd99f602e0))
+
+### Refactoring
+
+* refactor: add bec_lib version to statusbox ([`5d4b86e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d4b86e1c6e1800051afce4f991153e370767fa6))
+
+
+## v1.1.0 (2024-10-25)
+
+### Features
+
+* feat: add filter i/o utility class ([`0350833`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0350833f36e0a7cadce4173f9b1d1fbfdf985375))
+
+### Refactoring
+
+* refactor: do not flush selection upon receiving config update; allow widgetIO to receive kwargs to be able to use get_value to receive string instead of int for QComboBox ([`91959e8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/91959e82de8586934af3ebb5aaa0923930effc51))
+
+* refactor: allow to set selection in DeviceInput; automatic update of selection on device config update; cleanup ([`5eb15b7`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5eb15b785f12e30eb8ccbc56d4ad9e759a4cf5eb))
+
+* refactor: cleanup, added device_signal for signal inputs ([`6fb2055`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6fb20552ff57978f4aeb79fd7f062f8d6b5581e7))
+
+### Testing
+
+* test(scan_control): tests added for grid_scan to ensure scan_args signal validity ([`acb7902`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/acb79020d4be546efc001ff47b6f5cdba2ee9375))
+
+
 ## v1.0.2 (2024-10-22)
 
 ### Bug Fixes
@@ -139,38 +169,3 @@ complete UI ([`49268e3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/49268e38
 * fix: use new 'scan_axis' signal, to set_x and select x axis on waveform
 
 Fixes #361, do not try to change x axis when not permitted ([`efa2763`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/efa276358b0f5a45cce9fa84fa5f9aafaf4284f7))
-
-### Features
-
-* feat: new 'scan_axis' signal
-
-Signal is emitted before "scan_started", to inform about scan positioner
-and (start, stop) positions. In case of multiple bundles, the signal
-is emitted multiple times. ([`f084e25`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f084e2514bc9459cccaa951b79044bc25884e738))
-
-
-## v0.113.0 (2024-10-02)
-
-### Bug Fixes
-
-* fix: add is_log checks and functionality to plot_indicator_items ([`0f9953e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0f9953e8fdcf3f9b5a09f994c69edb6b34756df9))
-
-### Features
-
-* feat: add first draft for alignment_1d GUI ([`63c24f9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/63c24f97a355edaa928b6e222909252b276bcada))
-
-* feat: add move to position button to lmfit dialog ([`281cb27`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/281cb27d8b5433e27a7ba0ca0a19e4b45b9c544f))
-
-### Refactoring
-
-* refactor: various minor improvements for the alignment gui ([`f554f3c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f554f3c1672c4fe32968a5991dc98802556a6f3b))
-
-* refactor: allow hiding of arg/kwarg boxes ([`efe90eb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/efe90eb163e2123a5b4d0bb59f66025a569336ad))
-
-### Testing
-
-* test: add tests for scan_status_callback ([`dc0c825`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/dc0c825fd594c093a24543ff803d6c6564010e92))
-
-### Unknown
-
-* feat : Add bec_signal_proxy to handle signals with option to unblock them manually. ([`1dcfeb6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1dcfeb6cfce3c69f0c5401731d4d3f9a1981b22e))

PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bec_widgets
-Version: 1.0.2
+Version: 1.2.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/cli/client.py

@@ -38,6 +38,8 @@ class Widgets(str, enum.Enum):
     ResumeButton = "ResumeButton"
     RingProgressBar = "RingProgressBar"
     ScanControl = "ScanControl"
+    SignalComboBox = "SignalComboBox"
+    SignalLineEdit = "SignalLineEdit"
     StopButton = "StopButton"
     TextBox = "TextBox"
     VSCodeEditor = "VSCodeEditor"
@@ -2591,6 +2593,24 @@ class DeviceLineEdit(RPCBase):
         """
 
 
+class DeviceSignalInputBase(RPCBase):
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+
 class LMFitDialog(RPCBase):
     @property
     @rpc_call
@@ -3003,6 +3023,42 @@ class ScanControl(RPCBase):
         """
 
 
+class SignalComboBox(RPCBase):
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+
+class SignalLineEdit(RPCBase):
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+
 class StopButton(RPCBase):
     @property
     @rpc_call

bec_widgets/tests/utils.py

@@ -0,0 +1,226 @@
+from unittest.mock import MagicMock
+
+from bec_lib.device import Device as BECDevice
+from bec_lib.device import Positioner as BECPositioner
+from bec_lib.device import ReadoutPriority
+from bec_lib.devicemanager import DeviceContainer
+
+
+class FakeDevice(BECDevice):
+    """Fake minimal positioner class for testing."""
+
+    def __init__(self, name, enabled=True, readout_priority=ReadoutPriority.MONITORED):
+        super().__init__(name=name)
+        self._enabled = enabled
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._readout_priority = readout_priority
+        self._config = {
+            "readoutPriority": "baseline",
+            "deviceClass": "ophyd.Device",
+            "deviceConfig": {},
+            "deviceTags": ["user device"],
+            "enabled": enabled,
+            "readOnly": False,
+            "name": self.name,
+        }
+
+    @property
+    def readout_priority(self):
+        return self._readout_priority
+
+    @readout_priority.setter
+    def readout_priority(self, value):
+        self._readout_priority = value
+
+    @property
+    def limits(self) -> tuple[float, float]:
+        return self._limits
+
+    @limits.setter
+    def limits(self, value: tuple[float, float]):
+        self._limits = value
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.signals[self.name]["value"] = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+
+class FakePositioner(BECPositioner):
+
+    def __init__(
+        self,
+        name,
+        enabled=True,
+        limits=None,
+        read_value=1.0,
+        readout_priority=ReadoutPriority.MONITORED,
+    ):
+        super().__init__(name=name)
+        # self.limits = limits if limits is not None else [0.0, 0.0]
+        self.read_value = read_value
+        self.setpoint_value = read_value
+        self.motor_is_moving_value = 0
+        self._enabled = enabled
+        self._limits = limits
+        self._readout_priority = readout_priority
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._config = {
+            "readoutPriority": "baseline",
+            "deviceClass": "ophyd_devices.SimPositioner",
+            "deviceConfig": {"delay": 1, "tolerance": 0.01, "update_frequency": 400},
+            "deviceTags": ["user motors"],
+            "enabled": enabled,
+            "readOnly": False,
+            "name": self.name,
+        }
+        self._info = {
+            "signals": {
+                "readback": {"kind_str": "5"},  # hinted
+                "setpoint": {"kind_str": "1"},  # normal
+                "velocity": {"kind_str": "2"},  # config
+            }
+        }
+        self.signals = {
+            self.name: {"value": self.read_value},
+            f"{self.name}_setpoint": {"value": self.setpoint_value},
+            f"{self.name}_motor_is_moving": {"value": self.motor_is_moving_value},
+        }
+
+    @property
+    def readout_priority(self):
+        return self._readout_priority
+
+    @readout_priority.setter
+    def readout_priority(self, value):
+        self._readout_priority = value
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool):
+        self._enabled = value
+
+    @property
+    def limits(self) -> tuple[float, float]:
+        return self._limits
+
+    @limits.setter
+    def limits(self, value: tuple[float, float]):
+        self._limits = value
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.read_value = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+    @property
+    def precision(self):
+        return 3
+
+    def set_read_value(self, value):
+        self.read_value = value
+
+    def read(self):
+        return self.signals
+
+    def set_limits(self, limits):
+        self.limits = limits
+
+    def move(self, value, relative=False):
+        """Simulates moving the device to a new position."""
+        if relative:
+            self.read_value += value
+        else:
+            self.read_value = value
+        # Respect the limits
+        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
+
+    @property
+    def readback(self):
+        return MagicMock(get=MagicMock(return_value=self.read_value))
+
+
+class Positioner(FakePositioner):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name="test", limits=None, read_value=1.0):
+        super().__init__(name, limits, read_value)
+
+
+class Device(FakeDevice):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name, enabled=True):
+        super().__init__(name, enabled)
+
+
+class DMMock:
+    def __init__(self):
+        self.devices = DeviceContainer()
+        self.enabled_devices = [device for device in self.devices if device.enabled]
+
+    def add_devives(self, devices: list):
+        for device in devices:
+            self.devices[device.name] = device
+
+
+DEVICES = [
+    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
+    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
+    FakePositioner("samz", limits=[-8, 8], read_value=4.0),
+    FakePositioner("aptrx", limits=None, read_value=4.0),
+    FakePositioner("aptry", limits=None, read_value=5.0),
+    FakeDevice("gauss_bpm"),
+    FakeDevice("gauss_adc1"),
+    FakeDevice("gauss_adc2"),
+    FakeDevice("gauss_adc3"),
+    FakeDevice("bpm4i"),
+    FakeDevice("bpm3a"),
+    FakeDevice("bpm3i"),
+    FakeDevice("eiger", readout_priority=ReadoutPriority.ASYNC),
+    FakeDevice("waveform1d"),
+    FakeDevice("async_device", readout_priority=ReadoutPriority.ASYNC),
+    Positioner("test", limits=[-10, 10], read_value=2.0),
+    Device("test_device"),
+]

bec_widgets/utils/colors.py

@@ -107,9 +107,98 @@ class Colors:
             angles.append(angle)
         return angles
 
+    @staticmethod
+    def set_theme_offset(theme: Literal["light", "dark"] | None = None, offset=0.2) -> tuple:
+        """
+        Set the theme offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
+
+        Args:
+            theme(str): The theme to be applied.
+            offset(float): Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
+
+        Returns:
+            tuple: Tuple of min_pos and max_pos.
+
+        Raises:
+            ValueError: If theme_offset is not between 0 and 1.
+        """
+
+        if offset < 0 or offset > 1:
+            raise ValueError("theme_offset must be between 0 and 1")
+
+        if theme is None:
+            app = QApplication.instance()
+            if hasattr(app, "theme"):
+                theme = app.theme.theme
+
+        if theme == "light":
+            min_pos = 0.0
+            max_pos = 1 - offset
+        else:
+            min_pos = 0.0 + offset
+            max_pos = 1.0
+
+        return min_pos, max_pos
+
+    @staticmethod
+    def evenly_spaced_colors(
+        colormap: str,
+        num: int,
+        format: Literal["QColor", "HEX", "RGB"] = "QColor",
+        theme_offset=0.2,
+        theme: Literal["light", "dark"] | None = None,
+    ) -> list:
+        """
+        Extract `num` colors from the specified colormap, evenly spaced along its range,
+        and return them in the specified format.
+
+        Args:
+            colormap (str): Name of the colormap.
+            num (int): Number of requested colors.
+            format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
+            theme_offset (float): Has to be between 0-1. Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
+            theme (Literal['light', 'dark'] | None): The theme to be applied. Overrides the QApplication theme if specified.
+
+        Returns:
+            list: List of colors in the specified format.
+
+        Raises:
+            ValueError: If theme_offset is not between 0 and 1.
+        """
+        if theme_offset < 0 or theme_offset > 1:
+            raise ValueError("theme_offset must be between 0 and 1")
+
+        cmap = pg.colormap.get(colormap)
+        min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
+
+        # Generate positions that are evenly spaced within the acceptable range
+        if num == 1:
+            positions = np.array([(min_pos + max_pos) / 2])
+        else:
+            positions = np.linspace(min_pos, max_pos, num)
+
+        # Sample colors from the colormap at the calculated positions
+        colors = cmap.map(positions, mode="float")
+        color_list = []
+
+        for color in colors:
+            if format.upper() == "HEX":
+                color_list.append(QColor.fromRgbF(*color).name())
+            elif format.upper() == "RGB":
+                color_list.append(tuple((np.array(color) * 255).astype(int)))
+            elif format.upper() == "QCOLOR":
+                color_list.append(QColor.fromRgbF(*color))
+            else:
+                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
+        return color_list
+
     @staticmethod
     def golden_angle_color(
-        colormap: str, num: int, format: Literal["QColor", "HEX", "RGB"] = "QColor"
+        colormap: str,
+        num: int,
+        format: Literal["QColor", "HEX", "RGB"] = "QColor",
+        theme_offset=0.2,
+        theme: Literal["dark", "light"] | None = None,
     ) -> list:
         """
         Extract num colors from the specified colormap following golden angle distribution and return them in the specified format.
@@ -118,45 +207,39 @@ class Colors:
             colormap (str): Name of the colormap.
             num (int): Number of requested colors.
             format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
+            theme_offset (float): Has to be between 0-1. Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
 
         Returns:
             list: List of colors in the specified format.
 
         Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
+            ValueError: If theme_offset is not between 0 and 1.
         """
+
         cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.getColors(mode="float")
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = Colors.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = []
-        ii = 0
-        while len(colors) < num:
-            color_index = int(color_selection[ii])
-            color = cmap_colors[color_index]
-            app = QApplication.instance()
-            if hasattr(app, "theme") and app.theme.theme == "light":
-                background = 255
-            else:
-                background = 0
-            if np.abs(np.mean(color[:3] * 255) - background) < 50:
-                ii += 1
-                continue
+        phi = (1 + np.sqrt(5)) / 2  # Golden ratio
+        golden_angle_conjugate = 1 - (1 / phi)  # Approximately 0.38196601125
+
+        min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
+
+        # Generate positions within the acceptable range
+        positions = np.mod(np.arange(num) * golden_angle_conjugate, 1)
+        positions = min_pos + positions * (max_pos - min_pos)
+
+        # Sample colors from the colormap at the calculated positions
+        colors = cmap.map(positions, mode="float")
+        color_list = []
 
+        for color in colors:
             if format.upper() == "HEX":
-                colors.append(QColor.fromRgbF(*color).name())
+                color_list.append(QColor.fromRgbF(*color).name())
             elif format.upper() == "RGB":
-                colors.append(tuple((np.array(color) * 255).astype(int)))
+                color_list.append(tuple((np.array(color) * 255).astype(int)))
             elif format.upper() == "QCOLOR":
-                colors.append(QColor.fromRgbF(*color))
+                color_list.append(QColor.fromRgbF(*color))
             else:
                 raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
-            ii += 1
-        return colors
+        return color_list
 
     @staticmethod
     def hex_to_rgba(hex_color: str, alpha=255) -> tuple: