feat(curve, waveform): add dap_parameters for lmfit customization in DAP requests

.github/scripts/pr_issue_sync/pr_issue_sync.py

@@ -3,7 +3,7 @@ import os
 from typing import Literal
 
 import requests
-from github import Auth, Github
+from github import Github
 from pydantic import BaseModel
 
 
@@ -24,7 +24,7 @@ class ProjectItemHandler:
 
     def __init__(self, gh_config: GHConfig):
         self.gh_config = gh_config
-        self.gh = Github(auth=Auth.Token(gh_config.token))
+        self.gh = Github(gh_config.token)
         self.repo = self.gh.get_repo(f"{gh_config.organization}/{gh_config.repository}")
         self.project_node_id = self.get_project_node_id()
 

CHANGELOG.md

@@ -1,35 +1,6 @@
 # CHANGELOG
 
 
-## v2.45.14 (2026-01-23)
-
-### Bug Fixes
-
-- **bec_status**: Adjust bec status widget to info and version signature
-  ([`709ffd6`](https://github.com/bec-project/bec_widgets/commit/709ffd6927dceb903cbd0797fc162e56aef378c1))
-
-### Continuous Integration
-
-- Use auth.token instead of login_or_token
-  ([`0349c87`](https://github.com/bec-project/bec_widgets/commit/0349c872612ab0506e5662b813e78200a76d7590))
-
-### Testing
-
-- **device config**: Validate against pydantic
-  ([`de8fe3b`](https://github.com/bec-project/bec_widgets/commit/de8fe3b5f503ace17b0064d2ce9f54662b0fb77e))
-
-- **scan control**: Avoid strict length comparisons
-  ([`d577fac`](https://github.com/bec-project/bec_widgets/commit/d577fac02fed11b2b1c44704c04fd111c2fed1d3))
-
-
-## v2.45.13 (2025-12-17)
-
-### Bug Fixes
-
-- **scan queue**: Adjustments for changes to the pydantic model of the scan queue
-  ([`01c6e09`](https://github.com/bec-project/bec_widgets/commit/01c6e092b9cd46ae056c43e8c6576f7a570cce80))
-
-
 ## v2.45.12 (2025-12-16)
 
 ### Bug Fixes

bec_widgets/cli/client.py

@@ -5418,6 +5418,7 @@ class Waveform(RPCBase):
         color: "str | None" = None,
         label: "str | None" = None,
         dap: "str | None" = None,
+        dap_parameters: "dict | lmfit.Parameters | None | object" = None,
         scan_id: "str | None" = None,
         scan_number: "int | None" = None,
         **kwargs,
@@ -5442,6 +5443,8 @@ class Waveform(RPCBase):
             dap(str): The dap model to use for the curve. When provided, a DAP curve is
                 attached automatically for device, history, or custom data sources. Use
                 the same string as the LMFit model name.
+            dap_parameters(dict | lmfit.Parameters | None): Optional lmfit parameter overrides sent to the DAP server.
+                Values can be numeric (interpreted as fixed parameters) or dicts like`{"value": 1.0, "vary": False}`.
             scan_id(str):  Optional scan ID. When provided, the curve is treated as a **history** curve and
                 the y‑data (and optional x‑data) are fetched from that historical scan. Such curves are
                 never cleared by live‑scan resets.
@@ -5458,6 +5461,7 @@ class Waveform(RPCBase):
         dap_name: "str",
         color: "str | None" = None,
         dap_oversample: "int" = 1,
+        dap_parameters: "dict | lmfit.Parameters | None" = None,
         **kwargs,
     ) -> "Curve":
         """
@@ -5470,6 +5474,7 @@ class Waveform(RPCBase):
             dap_name(str): The name of the DAP model to use.
             color(str): The color of the curve.
             dap_oversample(int): The oversampling factor for the DAP curve.
+            dap_parameters(dict | lmfit.Parameters | None): Optional lmfit parameter overrides sent to the DAP server.
             **kwargs
 
         Returns:

bec_widgets/utils/colors.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+from functools import lru_cache
 import re
 from typing import TYPE_CHECKING, Literal
 
 import bec_qthemes
 import numpy as np
 import pyqtgraph as pg
+from bec_lib import bec_logger
 from bec_qthemes._os_appearance.listener import OSThemeSwitchListener
 from pydantic_core import PydanticCustomError
 from qtpy.QtGui import QColor
@@ -15,6 +17,9 @@ if TYPE_CHECKING:  # pragma: no cover
     from bec_qthemes._main import AccentColors
 
 
+logger = bec_logger.logger
+
+
 def get_theme_name():
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
         return "dark"
@@ -138,6 +143,83 @@ def apply_theme(theme: Literal["dark", "light"]):
 
 
 class Colors:
+    @staticmethod
+    def list_available_colormaps() -> list[str]:
+        """
+        List colormap names available via the pyqtgraph colormap registry.
+
+        Note: This does not include `GradientEditorItem` presets (used by HistogramLUT menus).
+        """
+
+        def _list(source: str | None = None) -> list[str]:
+            try:
+                return pg.colormap.listMaps() if source is None else pg.colormap.listMaps(source)
+            except Exception:  # pragma: no cover - backend may be missing
+                return []
+
+        return [*_list(None), *_list("matplotlib"), *_list("colorcet")]
+
+    @staticmethod
+    def list_available_gradient_presets() -> list[str]:
+        """
+        List `GradientEditorItem` preset names (HistogramLUT right-click menu entries).
+        """
+        from pyqtgraph.graphicsItems.GradientEditorItem import Gradients
+
+        return list(Gradients.keys())
+
+    @staticmethod
+    def canonical_colormap_name(color_map: str) -> str:
+        """
+        Return an available colormap/preset name if a case-insensitive match exists.
+        """
+        requested = (color_map or "").strip()
+        if not requested:
+            return requested
+
+        registry = Colors.list_available_colormaps()
+        presets = Colors.list_available_gradient_presets()
+        available = set(registry) | set(presets)
+
+        if requested in available:
+            return requested
+
+        # Case-insensitive match.
+        lower_to_canonical = {name.lower(): name for name in available}
+        return lower_to_canonical.get(requested.lower(), requested)
+
+    @staticmethod
+    def get_colormap(color_map: str) -> pg.ColorMap:
+        """
+        Resolve a string into a `pg.ColorMap` using either:
+        - the `pg.colormap` registry (optionally including matplotlib/colorcet backends), or
+        - `GradientEditorItem` presets (HistogramLUT right-click menu).
+        """
+        name = Colors.canonical_colormap_name(color_map)
+        if not name:
+            raise ValueError("Empty colormap name")
+
+        return Colors._get_colormap_cached(name)
+
+    @staticmethod
+    @lru_cache(maxsize=256)
+    def _get_colormap_cached(name: str) -> pg.ColorMap:
+        # 1) Registry/backends
+        try:
+            return pg.colormap.get(name)
+        except Exception:
+            pass
+        for source in ("matplotlib", "colorcet"):
+            try:
+                return pg.colormap.get(name, source=source)
+            except Exception:
+                continue
+
+        # 2) Presets -> ColorMap
+        ge = pg.GradientEditorItem()
+        ge.loadPreset(name)
+
+        return ge.colorMap()
 
     @staticmethod
     def golden_ratio(num: int) -> list:
@@ -219,7 +301,7 @@ class Colors:
         if theme_offset < 0 or theme_offset > 1:
             raise ValueError("theme_offset must be between 0 and 1")
 
-        cmap = pg.colormap.get(colormap)
+        cmap = Colors.get_colormap(colormap)
         min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
 
         # Generate positions that are evenly spaced within the acceptable range
@@ -267,7 +349,7 @@ class Colors:
             ValueError: If theme_offset is not between 0 and 1.
         """
 
-        cmap = pg.colormap.get(colormap)
+        cmap = Colors.get_colormap(colormap)
         phi = (1 + np.sqrt(5)) / 2  # Golden ratio
         golden_angle_conjugate = 1 - (1 / phi)  # Approximately 0.38196601125
 
@@ -533,18 +615,21 @@ class Colors:
         Raises:
             PydanticCustomError: If colormap is invalid.
         """
-        available_pg_maps = pg.colormap.listMaps()
-        available_mpl_maps = pg.colormap.listMaps("matplotlib")
-        available_mpl_colorcet = pg.colormap.listMaps("colorcet")
-
-        available_colormaps = available_pg_maps + available_mpl_maps + available_mpl_colorcet
-        if color_map not in available_colormaps:
+        normalized = Colors.canonical_colormap_name(color_map)
+        try:
+            Colors.get_colormap(normalized)
+        except Exception as ext:
+            logger.warning(f"Colormap validation error: {ext}")
             if return_error:
+                available_colormaps = sorted(
+                    set(Colors.list_available_colormaps())
+                    | set(Colors.list_available_gradient_presets())
+                )
                 raise PydanticCustomError(
                     "unsupported colormap",
-                    f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
+                    f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose from the following: {available_colormaps}.",
                     {"wrong_value": color_map},
                 )
             else:
                 return False
-        return color_map
+        return normalized

bec_widgets/widgets/plots/image/image_base.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, ConfigDict, Field, ValidationError
 from qtpy.QtCore import QPointF, Signal, SignalInstance
 from qtpy.QtWidgets import QDialog, QVBoxLayout
 
+from bec_widgets.utils import Colors
 from bec_widgets.utils.container_utils import WidgetContainerUtils
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.side_panel import SidePanel
@@ -131,8 +132,7 @@ class ImageLayerManager:
         image.setZValue(z_position)
         image.removed.connect(self._remove_destroyed_layer)
 
-        # FIXME: For now, we hard-code the default color map here. In the future, this should be configurable.
-        image.color_map = "plasma"
+        image.color_map = self.parent.config.color_map
 
         self.layers[name] = ImageLayer(name=name, image=image, sync=sync)
         self.plot_item.addItem(image)
@@ -249,6 +249,8 @@ class ImageBase(PlotBase):
     Base class for the Image widget.
     """
 
+    MAX_TICKS_COLORBAR = 10
+
     sync_colorbar_with_autorange = Signal()
     image_updated = Signal()
     layer_added = Signal(str)
@@ -460,18 +462,20 @@ class ImageBase(PlotBase):
                 self.setProperty("autorange", False)
 
             if style == "simple":
-                self._color_bar = pg.ColorBarItem(colorMap=self.config.color_map)
+                cmap = Colors.get_colormap(self.config.color_map)
+                self._color_bar = pg.ColorBarItem(colorMap=cmap)
                 self._color_bar.setImageItem(self.layer_manager["main"].image)
                 self._color_bar.sigLevelsChangeFinished.connect(disable_autorange)
+                self.config.color_bar = "simple"
 
             elif style == "full":
                 self._color_bar = pg.HistogramLUTItem()
                 self._color_bar.setImageItem(self.layer_manager["main"].image)
-                self._color_bar.gradient.loadPreset(self.config.color_map)
+                self.config.color_bar = "full"
+                self._apply_colormap_to_colorbar(self.config.color_map)
                 self._color_bar.sigLevelsChanged.connect(disable_autorange)
 
             self.plot_widget.addItem(self._color_bar, row=0, col=1)
-            self.config.color_bar = style
         else:
             if self._color_bar:
                 self.plot_widget.removeItem(self._color_bar)
@@ -484,6 +488,37 @@ class ImageBase(PlotBase):
         if vrange:  # should be at the end to disable the autorange if defined
             self.v_range = vrange
 
+    def _apply_colormap_to_colorbar(self, color_map: str) -> None:
+        if not self._color_bar:
+            return
+
+        cmap = Colors.get_colormap(color_map)
+
+        if self.config.color_bar == "simple":
+            self._color_bar.setColorMap(cmap)
+            return
+
+        if self.config.color_bar != "full":
+            return
+
+        gradient = getattr(self._color_bar, "gradient", None)
+        if gradient is None:
+            return
+
+        positions = np.linspace(0.0, 1.0, self.MAX_TICKS_COLORBAR)
+        colors = cmap.map(positions, mode="byte")
+
+        colors = np.asarray(colors)
+        if colors.ndim != 2:
+            return
+        if colors.shape[1] == 3:  # add alpha
+            alpha = np.full((colors.shape[0], 1), 255, dtype=colors.dtype)
+            colors = np.concatenate([colors, alpha], axis=1)
+
+        ticks = [(float(p), tuple(int(x) for x in c)) for p, c in zip(positions, colors)]
+        state = {"mode": "rgb", "ticks": ticks}
+        gradient.restoreState(state)
+
     ################################################################################
     # Static rois with roi manager
 
@@ -754,10 +789,7 @@ class ImageBase(PlotBase):
                 layer.image.color_map = value
 
             if self._color_bar:
-                if self.config.color_bar == "simple":
-                    self._color_bar.setColorMap(value)
-                elif self.config.color_bar == "full":
-                    self._color_bar.gradient.loadPreset(value)
+                self._apply_colormap_to_colorbar(self.config.color_map)
         except ValidationError:
             return
 

bec_widgets/widgets/plots/image/image_item.py

@@ -119,7 +119,8 @@ class ImageItem(BECConnector, pg.ImageItem):
         """Set a new color map."""
         try:
             self.config.color_map = value
-            self.setColorMap(value)
+            cmap = Colors.get_colormap(self.config.color_map)
+            self.setColorMap(cmap)
         except ValidationError:
             logger.error(f"Invalid colormap '{value}' provided.")
 

bec_widgets/widgets/plots/waveform/curve.py

@@ -24,6 +24,7 @@ class DeviceSignal(BaseModel):
     entry: str
     dap: str | None = None
     dap_oversample: int = 1
+    dap_parameters: dict | None = None
 
     model_config: dict = {"validate_assignment": True}
 

bec_widgets/widgets/plots/waveform/waveform.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import json
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
 
-import lmfit
 import numpy as np
 import pyqtgraph as pg
 from bec_lib import bec_logger, messages
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.lmfit_serializer import serialize_lmfit_params, serialize_param_object
 from bec_lib.scan_data_container import ScanDataContainer
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Qt, QTimer, Signal
@@ -41,6 +41,15 @@ from bec_widgets.widgets.services.scan_history_browser.scan_history_browser impo
 )
 
 logger = bec_logger.logger
+_DAP_PARAM = object()
+
+if TYPE_CHECKING:  # pragma: no cover
+    import lmfit  # type: ignore
+else:
+    try:
+        import lmfit  # type: ignore
+    except Exception:  # pragma: no cover
+        lmfit = None
 
 
 # noinspection PyDataclass
@@ -697,6 +706,7 @@ class Waveform(PlotBase):
         color: str | None = None,
         label: str | None = None,
         dap: str | None = None,
+        dap_parameters: dict | lmfit.Parameters | None | object = None,
         scan_id: str | None = None,
         scan_number: int | None = None,
         **kwargs,
@@ -721,6 +731,8 @@ class Waveform(PlotBase):
             dap(str): The dap model to use for the curve. When provided, a DAP curve is
                 attached automatically for device, history, or custom data sources. Use
                 the same string as the LMFit model name.
+            dap_parameters(dict | lmfit.Parameters | None): Optional lmfit parameter overrides sent to the DAP server.
+                Values can be numeric (interpreted as fixed parameters) or dicts like`{"value": 1.0, "vary": False}`.
             scan_id(str):  Optional scan ID. When provided, the curve is treated as a **history** curve and
                 the y‑data (and optional x‑data) are fetched from that historical scan. Such curves are
                 never cleared by live‑scan resets.
@@ -733,6 +745,8 @@ class Waveform(PlotBase):
         source = "custom"
         x_data = None
         y_data = None
+        if dap_parameters is _DAP_PARAM:
+            dap_parameters = kwargs.pop("dap_parameters", None) or kwargs.pop("parameters", None)
 
         # 1. Custom curve logic
         if x is not None and y is not None:
@@ -810,7 +824,9 @@ class Waveform(PlotBase):
         curve = self._add_curve(config=config, x_data=x_data, y_data=y_data)
 
         if dap is not None and curve.config.source in ("device", "history", "custom"):
-            self.add_dap_curve(device_label=curve.name(), dap_name=dap, **kwargs)
+            self.add_dap_curve(
+                device_label=curve.name(), dap_name=dap, dap_parameters=dap_parameters, **kwargs
+            )
 
         return curve
 
@@ -823,6 +839,7 @@ class Waveform(PlotBase):
         dap_name: str,
         color: str | None = None,
         dap_oversample: int = 1,
+        dap_parameters: dict | lmfit.Parameters | None = None,
         **kwargs,
     ) -> Curve:
         """
@@ -835,6 +852,7 @@ class Waveform(PlotBase):
             dap_name(str): The name of the DAP model to use.
             color(str): The color of the curve.
             dap_oversample(int): The oversampling factor for the DAP curve.
+            dap_parameters(dict | lmfit.Parameters | None): Optional lmfit parameter overrides sent to the DAP server.
             **kwargs
 
         Returns:
@@ -882,7 +900,11 @@ class Waveform(PlotBase):
 
         # Attach device signal with DAP
         config.signal = DeviceSignal(
-            name=dev_name, entry=dev_entry, dap=dap_name, dap_oversample=dap_oversample
+            name=dev_name,
+            entry=dev_entry,
+            dap=dap_name,
+            dap_oversample=dap_oversample,
+            dap_parameters=self._normalize_dap_parameters(dap_parameters),
         )
 
         # 4) Create the DAP curve config using `_add_curve(...)`
@@ -1762,12 +1784,21 @@ class Waveform(PlotBase):
                 x_min = None
                 x_max = None
 
+            dap_parameters = getattr(dap_curve.config.signal, "dap_parameters", None)
+            dap_kwargs = {
+                "data_x": x_data,
+                "data_y": y_data,
+                "oversample": dap_curve.dap_oversample,
+            }
+            if dap_parameters:
+                dap_kwargs["parameters"] = dap_parameters
+
             msg = messages.DAPRequestMessage(
                 dap_cls="LmfitService1D",
                 dap_type="on_demand",
                 config={
                     "args": [],
-                    "kwargs": {"data_x": x_data, "data_y": y_data},
+                    "kwargs": dap_kwargs,
                     "class_args": model._plugin_info["class_args"],
                     "class_kwargs": model._plugin_info["class_kwargs"],
                     "curve_label": dap_curve.name(),
@@ -1776,6 +1807,49 @@ class Waveform(PlotBase):
             )
             self.client.connector.set_and_publish(MessageEndpoints.dap_request(), msg)
 
+    @staticmethod
+    def _normalize_dap_parameters(parameters: dict | lmfit.Parameters | None) -> dict | None:
+        """
+        Normalize user-provided lmfit parameters into a JSON-serializable dict suitable for the DAP server.
+
+        Supports:
+        - `lmfit.Parameters`
+        - `dict[name -> number]` (treated as fixed parameter with `vary=False`)
+        - `dict[name -> dict]` (lmfit.Parameter fields; defaults to `vary=False` if unspecified)
+        - `dict[name -> lmfit.Parameter]`
+        """
+        if parameters is None:
+            return None
+        if lmfit is not None and isinstance(parameters, lmfit.Parameters):
+            return serialize_lmfit_params(parameters)
+        if not isinstance(parameters, dict):
+            if lmfit is None:
+                raise TypeError(
+                    "dap_parameters must be a dict when lmfit is not installed on the client."
+                )
+            raise TypeError("dap_parameters must be a dict or lmfit.Parameters (or omitted).")
+
+        normalized: dict[str, dict] = {}
+        for name, spec in parameters.items():
+            if spec is None:
+                continue
+            if isinstance(spec, (int, float, np.number)):
+                normalized[name] = {"name": name, "value": float(spec), "vary": False}
+                continue
+            if lmfit is not None and isinstance(spec, lmfit.Parameter):
+                normalized[name] = serialize_param_object(spec)
+                continue
+            if isinstance(spec, dict):
+                normalized[name] = {"name": name, **spec}
+                if "vary" not in normalized[name]:
+                    normalized[name]["vary"] = False
+                continue
+            raise TypeError(
+                f"Invalid dap_parameters entry for '{name}': expected number, dict, or lmfit.Parameter."
+            )
+
+        return normalized or None
+
     @SafeSlot(dict, dict)
     def update_dap_curves(self, msg, metadata):
         """
@@ -1793,14 +1867,6 @@ class Waveform(PlotBase):
         if not curve:
             return
 
-        # Get data from the parent (device) curve
-        parent_curve = self._find_curve_by_label(curve.config.parent_label)
-        if parent_curve is None:
-            return
-        x_parent, _ = parent_curve.get_data()
-        if x_parent is None or len(x_parent) == 0:
-            return
-
         # Retrieve and store the fit parameters and summary from the DAP server response
         try:
             curve.dap_params = msg["data"][1]["fit_parameters"]
@@ -1809,19 +1875,13 @@ class Waveform(PlotBase):
             logger.warning(f"Failed to retrieve DAP data for curve '{curve.name()}'")
             return
 
-        # Render model according to the DAP model name and parameters
-        model_name = curve.config.signal.dap
-        model_function = getattr(lmfit.models, model_name)()
-
-        x_min, x_max = x_parent.min(), x_parent.max()
-        oversample = curve.dap_oversample
-        new_x = np.linspace(x_min, x_max, int(len(x_parent) * oversample))
-
-        # Evaluate the model with the provided parameters to generate the y values
-        new_y = model_function.eval(**curve.dap_params, x=new_x)
-
-        # Update the curve with the new data
-        curve.setData(new_x, new_y)
+        # Plot the fitted curve using the server-provided output to avoid requiring lmfit on the client.
+        try:
+            fit_data = msg["data"][0]
+            curve.setData(np.asarray(fit_data["x"]), np.asarray(fit_data["y"]))
+        except Exception:
+            logger.exception(f"Failed to plot DAP result for curve '{curve.name()}'")
+            return
 
         metadata.update({"curve_id": curve_id})
         self.dap_params_update.emit(curve.dap_params, metadata)
@@ -2377,8 +2437,48 @@ class DemoApp(QMainWindow):  # pragma: no cover
         sigma = 0.8
         y = amplitude * np.exp(-((x - center) ** 2) / (2 * sigma**2)) + noise
 
+        # 1) No explicit parameters: server will use lmfit defaults/guesses.
         self.custom_waveform.plot(x=x, y=y, label="custom-gaussian", dap="GaussianModel")
 
+        # 2) Easy dict: numbers mean "fix this parameter to value" (vary=False).
+        self.custom_waveform.plot(
+            x=x,
+            y=y,
+            label="custom-gaussian-fixed-easy",
+            dap="GaussianModel",
+            dap_parameters={"amplitude": 1.0},
+            dap_oversample=5,
+        )
+
+        # 3) lmfit-style dict: any subset of lmfit.Parameter fields.
+        #    Here `center` is not fixed (vary=True) but its initial value is set.
+        self.custom_waveform.plot(
+            x=x,
+            y=y,
+            label="custom-gaussian-override-dict",
+            dap="GaussianModel",
+            dap_parameters={
+                "center": {"value": 1.2, "vary": True},
+                "sigma": {"value": sigma, "vary": False, "min": 0.0},
+            },
+        )
+
+        # 4) Passing a real `lmfit.Parameters` object (optional: requires lmfit on the client).
+        if lmfit is not None:
+            params_gauss = lmfit.models.GaussianModel().make_params()
+            params_gauss["amplitude"].set(value=amplitude, vary=False)
+            params_gauss["center"].set(value=center, vary=False)
+            params_gauss["sigma"].set(value=sigma, vary=False, min=0.0)
+            self.custom_waveform.plot(
+                x=x,
+                y=y,
+                label="custom-gaussian-fixed-params",
+                dap="GaussianModel",
+                dap_parameters=params_gauss,
+            )
+        else:
+            logger.info("Skipping lmfit.Parameters demo (lmfit not installed on client).")
+
 
 if __name__ == "__main__":  # pragma: no cover
     import sys

bec_widgets/widgets/progress/scan_progressbar/scan_progressbar.py

@@ -6,7 +6,6 @@ import time
 from typing import Literal
 
 import numpy as np
-from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from qtpy.QtCore import QObject, QTimer, Signal
@@ -265,28 +264,22 @@ class ScanProgressBar(BECWidget, QWidget):
         """
         if not "queue" in msg_content:
             return
-        if "primary" not in msg_content["queue"]:
-            return
-        if (primary_queue := msg_content.get("queue").get("primary")) is None:
-            return
-        if not isinstance(primary_queue, messages.ScanQueueStatus):
-            return
-        primary_queue_info = primary_queue.info
+        primary_queue_info = msg_content["queue"].get("primary", {}).get("info", [])
         if len(primary_queue_info) == 0:
             return
         scan_info = primary_queue_info[0]
         if scan_info is None:
             return
-        if scan_info.status.lower() == "running" and self.task is None:
+        if scan_info.get("status").lower() == "running" and self.task is None:
             self.task = ProgressTask(parent=self)
             self.progress_started.emit()
 
-        active_request_block = scan_info.active_request_block
+        active_request_block = scan_info.get("active_request_block", {})
         if active_request_block is None:
             return
 
-        self.scan_number = active_request_block.scan_number
-        report_instructions = active_request_block.report_instructions
+        self.scan_number = active_request_block.get("scan_number")
+        report_instructions = active_request_block.get("report_instructions", [])
         if not report_instructions:
             return
 

bec_widgets/widgets/services/bec_queue/bec_queue.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
 from bec_qthemes import material_icon
 from qtpy.QtCore import Property, Qt, Signal, Slot
@@ -146,16 +145,7 @@ class BECQueue(BECWidget, CompactPopupWidget):
             _metadata (dict): The metadata.
         """
         # only show the primary queue for now
-        queues = content.get("queue", {})
-        if not queues:
-            self.reset_content()
-            return
-        primary_queue: messages.ScanQueueStatus | None = queues.get("primary")
-        if not primary_queue:
-            self.reset_content()
-            return
-        queue_info = primary_queue.info
-
+        queue_info = content.get("queue", {}).get("primary", {}).get("info", [])
         self.table.setRowCount(len(queue_info))
         self.table.clearContents()
 
@@ -164,19 +154,19 @@ class BECQueue(BECWidget, CompactPopupWidget):
             return
 
         for index, item in enumerate(queue_info):
-            blocks = item.request_blocks
+            blocks = item.get("request_blocks", [])
             scan_types = []
             scan_numbers = []
             scan_ids = []
-            status = item.status
+            status = item.get("status", "")
             for request_block in blocks:
-                scan_type = request_block.msg.scan_type
+                scan_type = request_block.get("content", {}).get("scan_type", "")
                 if scan_type:
                     scan_types.append(scan_type)
-                scan_number = request_block.scan_number
+                scan_number = request_block.get("scan_number", "")
                 if scan_number:
                     scan_numbers.append(str(scan_number))
-                scan_id = request_block.scan_id
+                scan_id = request_block.get("scan_id", "")
                 if scan_id:
                     scan_ids.append(scan_id)
             if scan_types:
@@ -188,7 +178,7 @@ class BECQueue(BECWidget, CompactPopupWidget):
             self.set_row(index, scan_numbers, scan_types, status, scan_ids)
         busy = (
             False
-            if all(item.status in ("STOPPED", "COMPLETED", "IDLE") for item in queue_info)
+            if all(item.get("status") in ("STOPPED", "COMPLETED", "IDLE") for item in queue_info)
             else True
         )
         self.set_global_state("warning" if busy else "default")

bec_widgets/widgets/services/bec_status_box/bec_status_box.py

@@ -9,7 +9,6 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import BaseModel
 from qtpy.QtCore import QObject, QTimer, Signal, Slot
 from qtpy.QtWidgets import QHBoxLayout, QTreeWidget, QTreeWidgetItem
 
@@ -19,10 +18,9 @@ from bec_widgets.widgets.services.bec_status_box.status_item import StatusItem
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_lib.client import BECClient
-    from bec_lib.messages import BECStatus, ServiceMetricMessage, StatusMessage
-else:
-    # TODO : Put normal imports back when Pydantic gets faster
-    BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
+
+# TODO : Put normal imports back when Pydantic gets faster
+BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
 
 
 @dataclass
@@ -202,11 +200,7 @@ class BECStatusBox(BECWidget, CompactPopupWidget):
         self.status_container[service_name].update({"info": service_info_item})
 
     @Slot(dict, dict)
-    def update_service_status(
-        self,
-        services_info: dict[str, StatusMessage],
-        services_metric: dict[str, ServiceMetricMessage],
-    ) -> None:
+    def update_service_status(self, services_info: dict, services_metric: dict) -> None:
         """Callback function services_metric from BECServiceStatusMixin.
         It updates the status of all services.
 
@@ -215,9 +209,6 @@ class BECStatusBox(BECWidget, CompactPopupWidget):
             services_metric (dict): A dictionary containing the service metrics for all running BEC services.
         """
         checked = [self.box_name]
-        # FIXME: We simply replace the pydantic message with dict for now until we refactor the widget
-        for val in services_info.values():
-            val.info = val.info.model_dump() if isinstance(val.info, BaseModel) else val.info
         services_info = self.update_core_services(services_info, services_metric)
         checked.extend(self.CORE_SERVICES)
 

bec_widgets/widgets/services/bec_status_box/status_item.py

@@ -141,11 +141,7 @@ class StatusItem(QWidget):
         metrics_text = (
             f"<b>SERVICE:</b> {self.config.service_name}<br><b>STATUS:</b> {self.config.status}<br>"
         )
-        if "version" in self.config.info:
-            metrics_text += f"<b>BEC_LIB VERSION:</b> {self.config.info['version']}<br>"
-        if "versions" in self.config.info:
-            for component, version in self.config.info["versions"].items():
-                metrics_text += f"<b>{component.upper()} VERSION:</b> {version}<br>"
+        metrics_text += f"<b>BEC_LIB VERSION:</b> {self.config.info['version']}<br>"
         if self.config.metrics:
             for key, value in self.config.metrics.items():
                 if key == "create_time":

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "2.45.14"
+version = "2.45.12"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [

tests/end-2-end/test_plotting_framework_e2e.py

@@ -75,6 +75,7 @@ def test_rpc_plotting_shortcuts_init_configs(qtbot, connected_client_gui_obj):
     assert c1._config_dict["signal"] == {
         "dap": None,
         "name": "bpm4i",
+        "dap_parameters": None,
         "entry": "bpm4i",
         "dap_oversample": 1,
     }

tests/end-2-end/test_scan_control_e2e.py

@@ -1,5 +1,7 @@
 import time
 
+import pytest
+
 from bec_widgets.utils.widget_io import WidgetIO
 
 
@@ -22,10 +24,8 @@ def test_scan_control_populate_scans_e2e(scan_control):
         scan_control.comboBox_scan_selection.itemText(i)
         for i in range(scan_control.comboBox_scan_selection.count())
     ]
-    # Verify that we have at least the expected scans.
-    # There may be more scans if additional scans are added to the test plugin.
-    assert scan_control.comboBox_scan_selection.count() >= len(expected_scans)
-    assert all(scan in items for scan in expected_scans)
+    assert scan_control.comboBox_scan_selection.count() == len(expected_scans)
+    assert sorted(items) == sorted(expected_scans)
 
 
 def test_run_line_scan_with_parameters_e2e(scan_control, bec_client_lib, qtbot):

tests/unit_tests/test_bec_status_box.py

@@ -2,7 +2,7 @@
 from unittest import mock
 
 import pytest
-from bec_lib.messages import BECStatus, ServiceInfo, ServiceMetricMessage, StatusMessage
+from bec_lib.messages import BECStatus, ServiceMetricMessage, StatusMessage
 
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import (
     BECServiceInfoContainer,
@@ -75,17 +75,13 @@ def test_update_service_status(status_box):
     """Also checks check redundant tree items"""
     name = "test_service"
     status = BECStatus.IDLE
-    info = StatusMessage(name=name, status=status, info=ServiceInfo(user="test", hostname="host"))
+    info = {"test": "test"}
     metrics = {"metric": "test_metric"}
     status_box.add_tree_item(name, status, info, {})
     not_connected_name = "invalid_service"
     status_box.add_tree_item(not_connected_name, status, info, metrics)
 
-    services_status = {
-        name: StatusMessage(
-            name=name, status=status, info=ServiceInfo(user="test", hostname="host")
-        )
-    }
+    services_status = {name: StatusMessage(name=name, status=status, info=info)}
     services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
 
     with mock.patch.object(status_box, "update_core_services", return_value=services_status):
@@ -99,7 +95,7 @@ def test_update_core_services(status_box):
     status_box.CORE_SERVICES = ["test_service"]
     name = "test_service"
     status = BECStatus.RUNNING
-    info = ServiceInfo(user="test", hostname="host")
+    info = {"test": "test"}
     metrics = {"metric": "test_metric"}
     services_status = {name: StatusMessage(name=name, status=status, info=info)}
     services_metrics = {name: ServiceMetricMessage(name=name, metrics=metrics)}
@@ -119,7 +115,7 @@ def test_update_core_services(status_box):
 def test_double_click_item(status_box):
     name = "test_service"
     status = BECStatus.IDLE
-    info = ServiceInfo(user="test", hostname="host")
+    info = {"test": "test"}
     metrics = {"MyData": "This should be shown nicely"}
     status_box.add_tree_item(name, status, info, metrics)
     container = status_box.status_container[name]

tests/unit_tests/test_color_utils.py

@@ -82,6 +82,18 @@ def test_rgba_to_hex():
     assert Colors.rgba_to_hex(255, 87, 51) == "#FF5733FF"
 
 
+def test_validate_color_map_accepts_gradient_presets_and_greys_alias():
+    presets = {p.lower() for p in Colors.list_available_gradient_presets()}
+    candidate = next(
+        (p for p in ("grey", "gray", "bipolar", "spectrum", "flame") if p in presets), None
+    )
+    if candidate is None:
+        pytest.skip("No known GradientEditorItem presets available in this environment.")
+
+    assert Colors.validate_color_map(candidate) != ""
+    assert Colors.get_colormap(candidate) is not None
+
+
 @pytest.mark.parametrize("num", [10, 100, 400])
 def test_evenly_spaced_colors(num):
     colors_qcolor = Colors.evenly_spaced_colors(colormap="magma", num=num, format="QColor")

tests/unit_tests/test_device_config_form_dialog.py

@@ -129,13 +129,19 @@ def test_update_cycle(update_dialog, qtbot):
         ({"readOnly": True, "description": "test"}, {"readOnly": True, "description": "test"}),
         (
             {"deviceConfig": {"param1": "'val1'"}},
-            DeviceConfigModel(
-                enabled=True,
-                deviceClass="TestDevice",
-                deviceConfig={"param1": "val1"},
-                readoutPriority="monitored",
-                name="test_device",
-            ).model_dump(),
+            {
+                "enabled": True,
+                "deviceClass": "TestDevice",
+                "deviceConfig": {"param1": "val1"},
+                "readoutPriority": "monitored",
+                "description": "",
+                "readOnly": False,
+                "softwareTrigger": False,
+                "onFailure": "retry",
+                "deviceTags": set(),
+                "userParameter": {},
+                "name": "test_device",
+            },
         ),
         ({"deviceConfig": {}}, {}),
     ],

tests/unit_tests/test_scan_progress_bar.py

@@ -25,30 +25,6 @@ def scan_progressbar(qtbot, mocked_client):
     yield widget
 
 
-@pytest.fixture
-def scan_message():
-    return messages.ScanQueueMessage(
-        metadata={
-            "file_suffix": None,
-            "file_directory": None,
-            "user_metadata": {"sample_name": ""},
-            "RID": "94949c6e-d5f2-4f01-837e-a5d36257dd5d",
-        },
-        scan_type="line_scan",
-        parameter={
-            "args": {"samx": [-10.0, 10.0]},
-            "kwargs": {
-                "steps": 20,
-                "relative": False,
-                "exp_time": 0.1,
-                "burst_at_each_point": 1,
-                "system_config": {"file_suffix": None, "file_directory": None},
-            },
-        },
-        queue="primary",
-    )
-
-
 def test_progress_task_basic():
     """percentage, remaining, and formatted time helpers behave as expected."""
     task = ProgressTask(parent=None, value=50, max_value=100, done=False)
@@ -191,9 +167,7 @@ def test_progressbar_queue_update(scan_progressbar):
     """
     Test that an empty queue update does not change the progress source.
     """
-    msg = messages.ScanQueueStatusMessage(
-        queue={"primary": messages.ScanQueueStatus(info=[], status="RUNNING")}
-    )
+    msg = messages.ScanQueueStatusMessage(queue={"primary": {"info": [], "status": "RUNNING"}})
     with mock.patch.object(scan_progressbar, "set_progress_source") as mock_set_source:
         scan_progressbar.on_queue_update(
             msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
@@ -201,37 +175,50 @@ def test_progressbar_queue_update(scan_progressbar):
         mock_set_source.assert_not_called()
 
 
-def test_progressbar_queue_update_with_scan(scan_progressbar, scan_message):
+def test_progressbar_queue_update_with_scan(scan_progressbar):
     """
     Test that a queue update with a scan changes the progress source to SCAN_PROGRESS.
     """
-    request_block = messages.RequestBlock(
-        msg=scan_message,
-        RID="some-rid",
-        scan_motors=["samx"],
-        readout_priority={"monitored": ["samx"]},
-        is_scan=True,
-        scan_number=1,
-        scan_id="e3f50794-852c-4bb1-965e-41c585ab0aa9",
-        report_instructions=[{"scan_progress": 20}],
-    )
     msg = messages.ScanQueueStatusMessage(
         metadata={},
         queue={
-            "primary": messages.ScanQueueStatus(
-                info=[
-                    messages.QueueInfoEntry(
-                        queue_id="40831e2c-fbd1-4432-8072-ad168a7ad964",
-                        scan_id=["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
-                        status="RUNNING",
-                        active_request_block=request_block,
-                        is_scan=[True],
-                        request_blocks=[request_block],
-                        scan_number=[1],
-                    )
+            "primary": {
+                "info": [
+                    {
+                        "queue_id": "40831e2c-fbd1-4432-8072-ad168a7ad964",
+                        "scan_id": ["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
+                        "status": "RUNNING",
+                        "active_request_block": {
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": ""},
+                                    "RID": "94949c6e-d5f2-4f01-837e-a5d36257dd5d",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-10.0, 10.0]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "relative": False,
+                                        "exp_time": 0.1,
+                                        "burst_at_each_point": 1,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "scan_number": 1,
+                            "report_instructions": [{"scan_progress": 20}],
+                        },
+                    }
                 ],
-                status="RUNNING",
-            )
+                "status": "RUNNING",
+            }
         },
     )
 
@@ -242,37 +229,50 @@ def test_progressbar_queue_update_with_scan(scan_progressbar, scan_message):
         mock_set_source.assert_called_once_with(ProgressSource.SCAN_PROGRESS)
 
 
-def test_progressbar_queue_update_with_device(scan_progressbar, scan_message):
+def test_progressbar_queue_update_with_device(scan_progressbar):
     """
     Test that a queue update with a device changes the progress source to DEVICE_PROGRESS.
     """
-    request_block = messages.RequestBlock(
-        msg=scan_message,
-        RID="some-rid",
-        scan_motors=["samx"],
-        readout_priority={"monitored": ["samx"]},
-        is_scan=True,
-        scan_number=1,
-        scan_id="e3f50794-852c-4bb1-965e-41c585ab0aa9",
-        report_instructions=[{"device_progress": ["samx"]}],
-    )
     msg = messages.ScanQueueStatusMessage(
         metadata={},
         queue={
-            "primary": messages.ScanQueueStatus(
-                info=[
-                    messages.QueueInfoEntry(
-                        queue_id="40831e2c-fbd1-4432-8072-ad168a7ad964",
-                        scan_id=["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
-                        status="RUNNING",
-                        active_request_block=request_block,
-                        is_scan=[True],
-                        request_blocks=[request_block],
-                        scan_number=[1],
-                    )
+            "primary": {
+                "info": [
+                    {
+                        "queue_id": "40831e2c-fbd1-4432-8072-ad168a7ad964",
+                        "scan_id": ["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
+                        "status": "RUNNING",
+                        "active_request_block": {
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": ""},
+                                    "RID": "94949c6e-d5f2-4f01-837e-a5d36257dd5d",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-10.0, 10.0]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "relative": False,
+                                        "exp_time": 0.1,
+                                        "burst_at_each_point": 1,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "scan_number": 1,
+                            "report_instructions": [{"device_progress": ["samx"]}],
+                        },
+                    }
                 ],
-                status="RUNNING",
-            )
+                "status": "RUNNING",
+            }
         },
     )
 
@@ -283,36 +283,49 @@ def test_progressbar_queue_update_with_device(scan_progressbar, scan_message):
         mock_set_source.assert_called_once_with(ProgressSource.DEVICE_PROGRESS, device="samx")
 
 
-def test_progressbar_queue_update_with_no_scan_or_device(scan_progressbar, scan_message):
+def test_progressbar_queue_update_with_no_scan_or_device(scan_progressbar):
     """
     Test that a queue update with neither scan nor device does not change the progress source.
     """
-    request_block = messages.RequestBlock(
-        msg=scan_message,
-        RID="some-rid",
-        scan_motors=["samx"],
-        readout_priority={"monitored": ["samx"]},
-        is_scan=True,
-        scan_number=1,
-        scan_id="e3f50794-852c-4bb1-965e-41c585ab0aa9",
-    )
     msg = messages.ScanQueueStatusMessage(
         metadata={},
         queue={
-            "primary": messages.ScanQueueStatus(
-                info=[
-                    messages.QueueInfoEntry(
-                        queue_id="40831e2c-fbd1-4432-8072-ad168a7ad964",
-                        scan_id=["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
-                        status="RUNNING",
-                        active_request_block=request_block,
-                        is_scan=[True],
-                        request_blocks=[request_block],
-                        scan_number=[1],
-                    )
+            "primary": {
+                "info": [
+                    {
+                        "queue_id": "40831e2c-fbd1-4432-8072-ad168a7ad964",
+                        "scan_id": ["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
+                        "status": "RUNNING",
+                        "active_request_block": {
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": ""},
+                                    "RID": "94949c6e-d5f2-4f01-837e-a5d36257dd5d",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-10.0, 10.0]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "relative": False,
+                                        "exp_time": 0.1,
+                                        "burst_at_each_point": 1,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "scan_number": 1,
+                        },
+                    }
                 ],
-                status="RUNNING",
-            )
+                "status": "RUNNING",
+            }
         },
     )
 

tests/unit_tests/test_waveform.py

@@ -516,6 +516,57 @@ def test_plot_custom_curve_with_inline_dap(qtbot, mocked_client_with_dap):
     assert dap_curve.config.signal.dap == "GaussianModel"
 
 
+def test_normalize_dap_parameters_number_dict():
+    normalized = Waveform._normalize_dap_parameters({"amplitude": 1.0, "center": 2})
+    assert normalized == {
+        "amplitude": {"name": "amplitude", "value": 1.0, "vary": False},
+        "center": {"name": "center", "value": 2.0, "vary": False},
+    }
+
+
+def test_normalize_dap_parameters_dict_spec_defaults_vary_false():
+    normalized = Waveform._normalize_dap_parameters({"sigma": {"value": 0.8, "min": 0.0}})
+    assert normalized["sigma"]["name"] == "sigma"
+    assert normalized["sigma"]["value"] == 0.8
+    assert normalized["sigma"]["min"] == 0.0
+    assert normalized["sigma"]["vary"] is False
+
+
+def test_normalize_dap_parameters_invalid_type_raises():
+    with pytest.raises(TypeError):
+        Waveform._normalize_dap_parameters(["amplitude", 1.0])  # type: ignore[arg-type]
+
+
+def test_request_dap_includes_normalized_parameters(qtbot, mocked_client_with_dap, monkeypatch):
+    wf = create_widget(qtbot, Waveform, client=mocked_client_with_dap)
+    curve = wf.plot(
+        x=[0, 1, 2],
+        y=[1, 2, 3],
+        label="custom-inline-params",
+        dap="GaussianModel",
+        dap_parameters={"amplitude": 1.0},
+    )
+    dap_curve = wf.get_curve(f"{curve.name()}-GaussianModel")
+    assert dap_curve is not None
+    dap_curve.dap_oversample = 3
+
+    captured = {}
+
+    def capture(topic, msg, *args, **kwargs):  # noqa: ARG001
+        captured["topic"] = topic
+        captured["msg"] = msg
+
+    monkeypatch.setattr(wf.client.connector, "set_and_publish", capture)
+    wf.request_dap()
+
+    msg = captured["msg"]
+    dap_kwargs = msg.content["config"]["kwargs"]
+    assert dap_kwargs["oversample"] == 3
+    assert dap_kwargs["parameters"] == {
+        "amplitude": {"name": "amplitude", "value": 1.0, "vary": False}
+    }
+
+
 def test_fetch_scan_data_and_access(qtbot, mocked_client, monkeypatch):
     """
     Test the _fetch_scan_data_and_access method returns live_data/val if in a live scan,