2.43.0

Automatically generated by python-semantic-release

CHANGELOG.md

@@ -1,6 +1,22 @@
 # CHANGELOG
 
 
+## v2.43.0 (2025-10-30)
+
+### Features
+
+- Add pdf viewer widget
+  ([`13a9175`](https://github.com/bec-project/bec_widgets/commit/13a9175ba5f5e1e2404d7302404d9511872aafc7))
+
+
+## v2.42.1 (2025-10-28)
+
+### Bug Fixes
+
+- **rpc_server**: Raise window, even if minimized
+  ([`6bc1c3c`](https://github.com/bec-project/bec_widgets/commit/6bc1c3c5f1b3e57ab8e8aeabcc1c0a52a56bbf0a))
+
+
 ## v2.42.0 (2025-10-21)
 
 ### Features

bec_widgets/cli/client.py

@@ -45,6 +45,7 @@ _Widgets = {
     "MonacoWidget": "MonacoWidget",
     "MotorMap": "MotorMap",
     "MultiWaveform": "MultiWaveform",
+    "PdfViewerWidget": "PdfViewerWidget",
     "PositionIndicator": "PositionIndicator",
     "PositionerBox": "PositionerBox",
     "PositionerBox2D": "PositionerBox2D",
@@ -3421,6 +3422,137 @@ class MultiWaveform(RPCBase):
         """
 
 
+class PdfViewerWidget(RPCBase):
+    """A widget to display PDF documents with toolbar controls."""
+
+    @rpc_call
+    def load_pdf(self, file_path: str):
+        """
+        Load a PDF file into the viewer.
+
+        Args:
+            file_path (str): Path to the PDF file to load.
+        """
+
+    @rpc_call
+    def zoom_in(self):
+        """
+        Zoom in the PDF view.
+        """
+
+    @rpc_call
+    def zoom_out(self):
+        """
+        Zoom out the PDF view.
+        """
+
+    @rpc_call
+    def fit_to_width(self):
+        """
+        Fit PDF to width.
+        """
+
+    @rpc_call
+    def fit_to_page(self):
+        """
+        Fit PDF to page.
+        """
+
+    @rpc_call
+    def reset_zoom(self):
+        """
+        Reset zoom to 100% (1.0 factor).
+        """
+
+    @rpc_call
+    def previous_page(self):
+        """
+        Go to previous page.
+        """
+
+    @rpc_call
+    def next_page(self):
+        """
+        Go to next page.
+        """
+
+    @rpc_call
+    def toggle_continuous_scroll(self, checked: bool):
+        """
+        Toggle between single page and continuous scroll mode.
+
+        Args:
+            checked (bool): True to enable continuous scroll, False for single page mode.
+        """
+
+    @property
+    @rpc_call
+    def page_spacing(self):
+        """
+        Get the spacing between pages in continuous scroll mode.
+        """
+
+    @page_spacing.setter
+    @rpc_call
+    def page_spacing(self):
+        """
+        Get the spacing between pages in continuous scroll mode.
+        """
+
+    @property
+    @rpc_call
+    def side_margins(self):
+        """
+        Get the horizontal margins (side spacing) around the PDF content.
+        """
+
+    @side_margins.setter
+    @rpc_call
+    def side_margins(self):
+        """
+        Get the horizontal margins (side spacing) around the PDF content.
+        """
+
+    @rpc_call
+    def go_to_first_page(self):
+        """
+        Go to the first page.
+        """
+
+    @rpc_call
+    def go_to_last_page(self):
+        """
+        Go to the last page.
+        """
+
+    @rpc_call
+    def jump_to_page(self, page_number: int):
+        """
+        Jump to a specific page number (1-based index).
+        """
+
+    @property
+    @rpc_call
+    def current_page(self):
+        """
+        Get the current page number (1-based index).
+        """
+
+    @property
+    @rpc_call
+    def current_file_path(self):
+        """
+        Get the current PDF file path.
+        """
+
+    @current_file_path.setter
+    @rpc_call
+    def current_file_path(self):
+        """
+        Get the current PDF file path.
+        """
+
+
 class PositionIndicator(RPCBase):
     """Display a position within a defined range, e.g. motor limits."""
 

bec_widgets/tests/fake_devices.py

@@ -1,285 +0,0 @@
-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": "hinted",
-                    "component_name": "readback",
-                    "obj_name": self.name,
-                },  # hinted
-                "setpoint": {
-                    "kind_str": "normal",
-                    "component_name": "setpoint",
-                    "obj_name": f"{self.name}_setpoint",
-                },  # normal
-                "velocity": {
-                    "kind_str": "config",
-                    "component_name": "velocity",
-                    "obj_name": f"{self.name}_velocity",
-                },  # 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, cached=False):
-        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, enabled=True):
-        super().__init__(name, limits=limits, read_value=read_value, enabled=enabled)
-
-
-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_devices(self, devices: list):
-        """
-        Add devices to the DeviceContainer.
-
-        Args:
-            devices (list): List of device instances to add.
-        """
-        for device in devices:
-            self.devices[device.name] = device
-
-    def get_bec_signals(self, signal_class_name: str):
-        """
-        Emulate DeviceManager.get_bec_signals for unit-tests.
-
-        For “AsyncSignal” we list every device whose readout_priority is
-        ReadoutPriority.ASYNC and build a minimal tuple
-        (device_name, signal_name, signal_info_dict) that matches the real
-        API shape used by Waveform._check_async_signal_found.
-        """
-        signals: list[tuple[str, str, dict]] = []
-        if signal_class_name != "AsyncSignal":
-            return signals
-
-        for device in self.devices.values():
-            if getattr(device, "readout_priority", None) == ReadoutPriority.ASYNC:
-                device_name = device.name
-                signal_name = device.name  # primary signal in our mocks
-                signal_info = {
-                    "component_name": signal_name,
-                    "obj_name": signal_name,
-                    "kind_str": "hinted",
-                    "signal_class": signal_class_name,
-                    "metadata": {
-                        "connected": True,
-                        "precision": None,
-                        "read_access": True,
-                        "timestamp": 0.0,
-                        "write_access": True,
-                    },
-                }
-                signals.append((device_name, signal_name, signal_info))
-        return signals
-
-
-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"),
-]
-
-
-def check_remote_data_size(widget, plot_name, num_elements):
-    """
-    Check if the remote data has the correct number of elements.
-    Used in the qtbot.waitUntil function.
-    """
-    return len(widget.get_all_data()[plot_name]["x"]) == num_elements

bec_widgets/tests/utils.py

@@ -1,76 +1,285 @@
-from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
-from qtpy.QtCore import QTimer
-from qtpy.QtWidgets import QApplication
+from unittest.mock import MagicMock
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
-from bec_widgets.utils import error_popups
+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 TestableQTimer(QTimer):
-    _instances: list[tuple[QTimer, str]] = []
-    _current_test_name: str = ""
+class FakeDevice(BECDevice):
+    """Fake minimal positioner class for testing."""
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        TestableQTimer._instances.append((self, TestableQTimer._current_test_name))
+    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,
+        }
 
-    @classmethod
-    def check_all_stopped(cls, qtbot):
-        def _is_done_or_deleted(t: QTimer):
-            try:
-                return not t.isActive()
-            except RuntimeError as e:
-                return "already deleted" in e.args[0]
+    @property
+    def readout_priority(self):
+        return self._readout_priority
 
-        try:
-            qtbot.waitUntil(lambda: all(_is_done_or_deleted(timer) for timer, _ in cls._instances))
-        except QtBotTimeoutError as exc:
-            active_timers = list(filter(lambda t: t[0].isActive(), cls._instances))
-            (t.stop() for t, _ in cls._instances)
-            raise TimeoutError(f"Failed to stop all timers: {active_timers}") from exc
-        cls._instances = []
+    @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
 
 
-def qapplication_fixture(qtbot, request, testable_qtimer_class):
-    yield
+class FakePositioner(BECPositioner):
 
-    if request.node.stash._storage.get("failed"):
-        print("Test failed, skipping cleanup checks")
-        return
+    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": "hinted",
+                    "component_name": "readback",
+                    "obj_name": self.name,
+                },  # hinted
+                "setpoint": {
+                    "kind_str": "normal",
+                    "component_name": "setpoint",
+                    "obj_name": f"{self.name}_setpoint",
+                },  # normal
+                "velocity": {
+                    "kind_str": "config",
+                    "component_name": "velocity",
+                    "obj_name": f"{self.name}_velocity",
+                },  # 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},
+        }
 
-    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
-    bec_dispatcher.stop_cli_server()
+    @property
+    def readout_priority(self):
+        return self._readout_priority
 
-    testable_qtimer_class.check_all_stopped(qtbot)
-    qapp = QApplication.instance()
-    qapp.processEvents()
-    if hasattr(qapp, "os_listener") and qapp.os_listener:
-        qapp.removeEventFilter(qapp.os_listener)
-    try:
-        qtbot.waitUntil(lambda: qapp.topLevelWidgets() == [])
-    except QtBotTimeoutError as exc:
-        raise TimeoutError(f"Failed to close all widgets: {qapp.topLevelWidgets()}") from exc
+    @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, cached=False):
+        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))
 
 
-def rpc_register_fixture():
-    try:
-        yield RPCRegister()
-    finally:
-        RPCRegister.reset_singleton()
+class Positioner(FakePositioner):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name="test", limits=None, read_value=1.0, enabled=True):
+        super().__init__(name, limits=limits, read_value=read_value, enabled=enabled)
 
 
-def bec_dispatcher_fixture(threads_check):
-    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
-    try:
-        yield bec_dispatcher
-    finally:
-        bec_dispatcher.disconnect_all()
-        bec_dispatcher.client.shutdown()
-        bec_dispatcher.stop_cli_server()
-        bec_dispatcher_module.BECDispatcher.reset_singleton()
+class Device(FakeDevice):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name, enabled=True):
+        super().__init__(name, enabled)
 
 
-def clean_singleton_fixture():
-    error_popups._popup_utility_instance = None
-    yield
+class DMMock:
+    def __init__(self):
+        self.devices = DeviceContainer()
+        self.enabled_devices = [device for device in self.devices if device.enabled]
+
+    def add_devices(self, devices: list):
+        """
+        Add devices to the DeviceContainer.
+
+        Args:
+            devices (list): List of device instances to add.
+        """
+        for device in devices:
+            self.devices[device.name] = device
+
+    def get_bec_signals(self, signal_class_name: str):
+        """
+        Emulate DeviceManager.get_bec_signals for unit-tests.
+
+        For “AsyncSignal” we list every device whose readout_priority is
+        ReadoutPriority.ASYNC and build a minimal tuple
+        (device_name, signal_name, signal_info_dict) that matches the real
+        API shape used by Waveform._check_async_signal_found.
+        """
+        signals: list[tuple[str, str, dict]] = []
+        if signal_class_name != "AsyncSignal":
+            return signals
+
+        for device in self.devices.values():
+            if getattr(device, "readout_priority", None) == ReadoutPriority.ASYNC:
+                device_name = device.name
+                signal_name = device.name  # primary signal in our mocks
+                signal_info = {
+                    "component_name": signal_name,
+                    "obj_name": signal_name,
+                    "kind_str": "hinted",
+                    "signal_class": signal_class_name,
+                    "metadata": {
+                        "connected": True,
+                        "precision": None,
+                        "read_access": True,
+                        "timestamp": 0.0,
+                        "write_access": True,
+                    },
+                }
+                signals.append((device_name, signal_name, signal_info))
+        return signals
+
+
+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"),
+]
+
+
+def check_remote_data_size(widget, plot_name, num_elements):
+    """
+    Check if the remote data has the correct number of elements.
+    Used in the qtbot.waitUntil function.
+    """
+    return len(widget.get_all_data()[plot_name]["x"]) == num_elements

bec_widgets/utils/rpc_server.py

@@ -11,7 +11,7 @@ from bec_lib.client import BECClient
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import
-from qtpy.QtCore import QTimer
+from qtpy.QtCore import Qt, QTimer
 from qtpy.QtWidgets import QApplication
 from redis.exceptions import RedisError
 
@@ -129,16 +129,44 @@ class RPCServer:
         # Run with rpc registry broadcast, but only once
         with RPCRegister.delayed_broadcast():
             logger.debug(f"Running RPC instruction: {method} with args: {args}, kwargs: {kwargs}")
-            method_obj = getattr(obj, method)
-            # check if the method accepts args and kwargs
-            if not callable(method_obj):
-                if not args:
-                    res = method_obj
-                else:
-                    setattr(obj, method, args[0])
-                    res = None
+            if method == "raise" and hasattr(
+                obj, "setWindowState"
+            ):  # special case for raising windows, should work even if minimized
+                # this is a special case for raising windows for gnome on rethat 9 systems where changing focus is supressed by default
+                # The procedure is as follows:
+                # 1. Get the current window state to check if the window is minimized and remove minimized flag
+                # 2. Then in order to force gnome to raise the window, we set the window to stay on top temporarily
+                #    and call raise_() and activateWindow()
+                #    This forces gnome to raise the window even if focus stealing is prevented
+                # 3. Flag for stay on top is removed again to restore the original window state
+                # 4. Finally, we call show() to ensure the window is visible
+
+                state = getattr(obj, "windowState", lambda: Qt.WindowNoState)()
+                target_state = state | Qt.WindowActive
+                if state & Qt.WindowMinimized:
+                    target_state &= ~Qt.WindowMinimized
+                obj.setWindowState(target_state)
+                if hasattr(obj, "showNormal") and state & Qt.WindowMinimized:
+                    obj.showNormal()
+                if hasattr(obj, "raise_"):
+                    obj.setWindowFlags(obj.windowFlags() | Qt.WindowStaysOnTopHint)
+                    obj.raise_()
+                if hasattr(obj, "activateWindow"):
+                    obj.activateWindow()
+                obj.setWindowFlags(obj.windowFlags() & ~Qt.WindowStaysOnTopHint)
+                obj.show()
+                res = None
             else:
-                res = method_obj(*args, **kwargs)
+                method_obj = getattr(obj, method)
+                # check if the method accepts args and kwargs
+                if not callable(method_obj):
+                    if not args:
+                        res = method_obj
+                    else:
+                        setattr(obj, method, args[0])
+                        res = None
+                else:
+                    res = method_obj(*args, **kwargs)
 
             if isinstance(res, list):
                 res = [self.serialize_object(obj) for obj in res]

bec_widgets/widgets/utility/pdf_viewer/pdf_viewer.py

@@ -0,0 +1,574 @@
+import os
+from typing import Optional
+
+from qtpy.QtCore import QMargins, Qt, Signal
+from qtpy.QtGui import QIntValidator
+from qtpy.QtPdf import QPdfDocument
+from qtpy.QtPdfWidgets import QPdfView
+from qtpy.QtWidgets import QFileDialog, QHBoxLayout, QLabel, QLineEdit, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.utils.toolbars.actions import MaterialIconAction, WidgetAction
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+
+
+class PdfViewerWidget(BECWidget, QWidget):
+    """A widget to display PDF documents with toolbar controls."""
+
+    # Emitted when a PDF document is successfully loaded, providing the file path.
+    document_ready = Signal(str)
+
+    PLUGIN = True
+    RPC = True
+    ICON_NAME = "picture_as_pdf"
+    USER_ACCESS = [
+        "load_pdf",
+        "zoom_in",
+        "zoom_out",
+        "fit_to_width",
+        "fit_to_page",
+        "reset_zoom",
+        "previous_page",
+        "next_page",
+        "toggle_continuous_scroll",
+        "page_spacing",
+        "page_spacing.setter",
+        "side_margins",
+        "side_margins.setter",
+        "go_to_first_page",
+        "go_to_last_page",
+        "jump_to_page",
+        "current_page",
+        "current_file_path",
+        "current_file_path.setter",
+    ]
+
+    def __init__(
+        self, parent: Optional[QWidget] = None, config=None, client=None, gui_id=None, **kwargs
+    ):
+        super().__init__(parent=parent, config=config, client=client, gui_id=gui_id, **kwargs)
+
+        # Set up the layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # Create the PDF document and view first
+        self._pdf_document = QPdfDocument(self)
+        self.pdf_view = QPdfView()
+        self.pdf_view.setZoomMode(QPdfView.ZoomMode.FitToWidth)
+
+        # Create toolbar after PDF components are initialized
+        self.toolbar = ModularToolBar(parent=self, orientation="horizontal")
+        self._setup_toolbar()
+
+        # Add widgets to layout
+        layout.addWidget(self.toolbar)
+        layout.addWidget(self.pdf_view)
+
+        # Current file path and spacing settings
+        self._current_file_path = None
+        self._page_spacing = 5  # Default spacing between pages in continuous mode
+        self._side_margins = 10  # Default side margins (horizontal spacing)
+
+    def _setup_toolbar(self):
+        """Set up the toolbar with PDF control buttons."""
+        # Create separate bundles for different control groups
+        file_bundle = self.toolbar.new_bundle("file_controls")
+        zoom_bundle = self.toolbar.new_bundle("zoom_controls")
+        view_bundle = self.toolbar.new_bundle("view_controls")
+        nav_bundle = self.toolbar.new_bundle("navigation_controls")
+
+        # File operations
+        open_action = MaterialIconAction(
+            icon_name="folder_open", tooltip="Open PDF File", parent=self
+        )
+        open_action.action.triggered.connect(self.open_file_dialog)
+        self.toolbar.components.add("open_file", open_action)
+        file_bundle.add_action("open_file")
+
+        # Zoom controls
+        zoom_in_action = MaterialIconAction(icon_name="zoom_in", tooltip="Zoom In", parent=self)
+        zoom_in_action.action.triggered.connect(self.zoom_in)
+        self.toolbar.components.add("zoom_in", zoom_in_action)
+        zoom_bundle.add_action("zoom_in")
+
+        zoom_out_action = MaterialIconAction(icon_name="zoom_out", tooltip="Zoom Out", parent=self)
+        zoom_out_action.action.triggered.connect(self.zoom_out)
+        self.toolbar.components.add("zoom_out", zoom_out_action)
+        zoom_bundle.add_action("zoom_out")
+
+        fit_width_action = MaterialIconAction(
+            icon_name="fit_screen", tooltip="Fit to Width", parent=self
+        )
+        fit_width_action.action.triggered.connect(self.fit_to_width)
+        self.toolbar.components.add("fit_width", fit_width_action)
+        zoom_bundle.add_action("fit_width")
+
+        fit_page_action = MaterialIconAction(
+            icon_name="fullscreen", tooltip="Fit to Page", parent=self
+        )
+        fit_page_action.action.triggered.connect(self.fit_to_page)
+        self.toolbar.components.add("fit_page", fit_page_action)
+        zoom_bundle.add_action("fit_page")
+
+        reset_zoom_action = MaterialIconAction(
+            icon_name="center_focus_strong", tooltip="Reset Zoom to 100%", parent=self
+        )
+        reset_zoom_action.action.triggered.connect(self.reset_zoom)
+        self.toolbar.components.add("reset_zoom", reset_zoom_action)
+        zoom_bundle.add_action("reset_zoom")
+
+        # View controls
+        continuous_scroll_action = MaterialIconAction(
+            icon_name="view_agenda", tooltip="Toggle Continuous Scroll", checkable=True, parent=self
+        )
+        continuous_scroll_action.action.toggled.connect(self.toggle_continuous_scroll)
+        self.toolbar.components.add("continuous_scroll", continuous_scroll_action)
+        view_bundle.add_action("continuous_scroll")
+
+        # Navigation controls
+        prev_page_action = MaterialIconAction(
+            icon_name="navigate_before", tooltip="Previous Page", parent=self
+        )
+        prev_page_action.action.triggered.connect(self.previous_page)
+        self.toolbar.components.add("prev_page", prev_page_action)
+        nav_bundle.add_action("prev_page")
+
+        next_page_action = MaterialIconAction(
+            icon_name="navigate_next", tooltip="Next Page", parent=self
+        )
+        next_page_action.action.triggered.connect(self.next_page)
+        self.toolbar.components.add("next_page", next_page_action)
+        nav_bundle.add_action("next_page")
+
+        # Page jump widget (in navigation bundle)
+        self._setup_page_jump_widget(nav_bundle)
+
+        # Show all bundles
+        self.toolbar.show_bundles(
+            ["file_controls", "zoom_controls", "view_controls", "navigation_controls"]
+        )
+
+        # Initialize navigation button tooltips for single page mode (default)
+        self._update_navigation_buttons_for_mode(continuous=False)
+
+        # Initialize navigation button states
+        self._update_navigation_button_states()
+
+    def _setup_page_jump_widget(self, nav_bundle):
+        """Set up the page jump widget (label + line edit)."""
+        # Create a container widget for the page jump controls
+        page_jump_container = QWidget()
+        page_jump_layout = QHBoxLayout(page_jump_container)
+        page_jump_layout.setContentsMargins(5, 0, 5, 0)
+        page_jump_layout.setSpacing(3)
+
+        # Page input field
+        self.page_input = QLineEdit()
+        self.page_input.setValidator(QIntValidator(1, 100000))  # restrict to 1–100000
+        self.page_input.setFixedWidth(50)
+        self.page_input.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.page_input.setPlaceholderText("1")
+        self.page_input.setToolTip("Enter page number and press Enter")
+        self.page_input.returnPressed.connect(self._line_edit_jump_to_page)
+
+        # Total pages label
+        self.total_pages_label = QLabel("/ 1")
+        self.total_pages_label.setStyleSheet("color: #666; font-size: 12px;")
+
+        # Add widgets to layout
+        page_jump_layout.addWidget(self.page_input)
+        page_jump_layout.addWidget(self.total_pages_label)
+
+        # Create a WidgetAction for the page jump controls
+        # No manual separator needed - bundles are automatically separated
+        page_jump_action = WidgetAction(
+            label="Page:", widget=page_jump_container, adjust_size=False, parent=self
+        )
+        self.toolbar.components.add("page_jump", page_jump_action)
+        nav_bundle.add_action("page_jump")
+
+    def _line_edit_jump_to_page(self):
+        """Jump to the page entered in the line edit."""
+        page_text = self.page_input.text().strip()
+        if not page_text:
+            return
+        # We validated input to be integer, so safe to convert directly
+        self.jump_to_page(int(page_text))
+
+    def _update_navigation_button_states(self):
+        """Update the enabled/disabled state of navigation buttons."""
+        if not self._pdf_document or self._pdf_document.status() != QPdfDocument.Status.Ready:
+            # No document loaded - disable all navigation
+            self._set_navigation_enabled(False, False)
+            self._update_page_display(1, 1)
+            return
+
+        navigator = self.pdf_view.pageNavigator()
+        current_page = navigator.currentPage()
+        total_pages = self._pdf_document.pageCount()
+
+        # Update button states
+        prev_enabled = current_page > 0
+        next_enabled = current_page < (total_pages - 1)
+        self._set_navigation_enabled(prev_enabled, next_enabled)
+
+        # Update page display
+        self._update_page_display(current_page + 1, total_pages)
+
+    def _set_navigation_enabled(self, prev_enabled: bool, next_enabled: bool):
+        """Set the enabled state of navigation buttons."""
+        prev_action = self.toolbar.components.get_action("prev_page")
+        if prev_action and hasattr(prev_action, "action") and prev_action.action:
+            prev_action.action.setEnabled(prev_enabled)
+
+        next_action = self.toolbar.components.get_action("next_page")
+        if next_action and hasattr(next_action, "action") and next_action.action:
+            next_action.action.setEnabled(next_enabled)
+
+    def _update_page_display(self, current_page: int, total_pages: int):
+        """Update the page display in the toolbar."""
+        if hasattr(self, "page_input"):
+            self.page_input.setText(str(current_page))
+            self.page_input.setPlaceholderText(str(current_page))
+
+        if hasattr(self, "total_pages_label"):
+            self.total_pages_label.setText(f"/ {total_pages}")
+
+    @SafeProperty(str)
+    def current_file_path(self):
+        """Get the current PDF file path."""
+        return self._current_file_path
+
+    @current_file_path.setter
+    def current_file_path(self, value: str):
+        """
+        Set the current PDF file path and load the document.
+
+        Args:
+            value (str): Path to the PDF file to load.
+        """
+        if not isinstance(value, str):
+            raise ValueError("current_file_path must be a string")
+        self.load_pdf(value)
+
+    @SafeProperty(int)
+    def page_spacing(self):
+        """Get the spacing between pages in continuous scroll mode."""
+        return self._page_spacing
+
+    @property
+    def current_page(self):
+        """Get the current page number (1-based index)."""
+        if not self._pdf_document or self._pdf_document.status() != QPdfDocument.Status.Ready:
+            return 0
+        navigator = self.pdf_view.pageNavigator()
+        return navigator.currentPage() + 1
+
+    @page_spacing.setter
+    def page_spacing(self, value: int):
+        """
+        Set the spacing between pages in continuous scroll mode.
+
+        Args:
+            value (int): Spacing in pixels (non-negative integer).
+        """
+        if not isinstance(value, int):
+            raise ValueError("page_spacing must be an integer")
+        if value < 0:
+            raise ValueError("page_spacing must be non-negative")
+
+        self._page_spacing = value
+
+        # If currently in continuous scroll mode, update the spacing immediately
+        if self.pdf_view.pageMode() == QPdfView.PageMode.MultiPage:
+            self.pdf_view.setPageSpacing(self._page_spacing)
+
+    @SafeProperty(int)
+    def side_margins(self):
+        """Get the horizontal margins (side spacing) around the PDF content."""
+        return self._side_margins
+
+    @side_margins.setter
+    def side_margins(self, value: int):
+        """Set the horizontal margins (side spacing) around the PDF content."""
+        if not isinstance(value, int):
+            raise ValueError("side_margins must be an integer")
+        if value < 0:
+            raise ValueError("side_margins must be non-negative")
+
+        self._side_margins = value
+
+        # Update the document margins immediately
+        # setDocumentMargins takes a QMargins(left, top, right, bottom)
+        margins = QMargins(self._side_margins, 0, self._side_margins, 0)
+        self.pdf_view.setDocumentMargins(margins)
+
+    def open_file_dialog(self):
+        """Open a file dialog to select a PDF file."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Open PDF File", "", "PDF Files (*.pdf);;All Files (*)"
+        )
+        if file_path:
+            self.load_pdf(file_path)
+
+    @SafeSlot(str, popup_error=True)
+    def load_pdf(self, file_path: str):
+        """
+        Load a PDF file into the viewer.
+
+        Args:
+            file_path (str): Path to the PDF file to load.
+        """
+        # Validate file exists
+        if not os.path.isfile(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        self._current_file_path = file_path
+
+        # Disconnect any existing signal connections
+        try:
+            self._pdf_document.statusChanged.disconnect(self._on_document_status_changed)
+        except (TypeError, RuntimeError):
+            pass
+
+        # Connect to statusChanged signal to handle when document is ready
+        self._pdf_document.statusChanged.connect(self._on_document_status_changed)
+
+        # Load the document
+        self._pdf_document.load(file_path)
+
+        # If already ready (synchronous loading), set document immediately
+        if self._pdf_document.status() == QPdfDocument.Status.Ready:
+            self._on_document_ready()
+
+    @SafeSlot(QPdfDocument.Status)
+    def _on_document_status_changed(self, status: QPdfDocument.Status):
+        """Handle document status changes."""
+        status = self._pdf_document.status()
+
+        if status == QPdfDocument.Status.Ready:
+            self._on_document_ready()
+        elif status == QPdfDocument.Status.Error:
+            raise RuntimeError(f"Failed to load PDF document: {self._current_file_path}")
+
+    def _on_document_ready(self):
+        """Handle when document is ready to be displayed."""
+        self.pdf_view.setDocument(self._pdf_document)
+
+        # Set initial margins
+        margins = QMargins(self._side_margins, 0, self._side_margins, 0)
+        self.pdf_view.setDocumentMargins(margins)
+
+        # Connect to page changes to update navigation button states
+        navigator = self.pdf_view.pageNavigator()
+        navigator.currentPageChanged.connect(self._on_page_changed)
+
+        # Make sure we start at the first page
+        navigator.update(0, navigator.currentLocation(), navigator.currentZoom())
+
+        # Update initial navigation state
+        self._update_navigation_button_states()
+        self.document_ready.emit(self._current_file_path)
+
+    def _on_page_changed(self, _page):
+        """Handle page change events to update navigation states."""
+        self._update_navigation_button_states()
+
+    # Toolbar action methods
+    @SafeSlot()
+    def zoom_in(self):
+        """Zoom in the PDF view."""
+        self.pdf_view.setZoomMode(QPdfView.ZoomMode.Custom)
+        current_factor = self.pdf_view.zoomFactor()
+        new_factor = current_factor * 1.25
+        self.pdf_view.setZoomFactor(new_factor)
+
+    @SafeSlot()
+    def zoom_out(self):
+        """Zoom out the PDF view."""
+        self.pdf_view.setZoomMode(QPdfView.ZoomMode.Custom)
+        current_factor = self.pdf_view.zoomFactor()
+        new_factor = max(current_factor / 1.25, 0.1)
+        self.pdf_view.setZoomFactor(new_factor)
+
+    @SafeSlot()
+    def fit_to_width(self):
+        """Fit PDF to width."""
+        self.pdf_view.setZoomMode(QPdfView.ZoomMode.FitToWidth)
+
+    @SafeSlot()
+    def fit_to_page(self):
+        """Fit PDF to page."""
+        self.pdf_view.setZoomMode(QPdfView.ZoomMode.FitInView)
+
+    @SafeSlot()
+    def reset_zoom(self):
+        """Reset zoom to 100% (1.0 factor)."""
+        self.pdf_view.setZoomMode(QPdfView.ZoomMode.Custom)
+        self.pdf_view.setZoomFactor(1.0)
+
+    @SafeSlot()
+    def previous_page(self):
+        """Go to previous page."""
+        if not self._pdf_document or self._pdf_document.status() != QPdfDocument.Status.Ready:
+            return
+
+        navigator = self.pdf_view.pageNavigator()
+        current_page = navigator.currentPage()
+        if current_page == 0:
+            self._update_navigation_button_states()
+            return
+
+        try:
+            target_page = current_page - 1
+            navigator.update(target_page, navigator.currentLocation(), navigator.currentZoom())
+        except Exception:
+            try:
+                # Fallback: Use scroll to approximate position
+                page_height = self.pdf_view.viewport().height()
+                self.pdf_view.verticalScrollBar().setValue(
+                    self.pdf_view.verticalScrollBar().value() - page_height
+                )
+            except Exception:
+                pass
+
+        # Update navigation button states (in case signal doesn't fire)
+        self._update_navigation_button_states()
+
+    @SafeSlot()
+    def next_page(self):
+        """Go to next page."""
+        if not self._pdf_document or self._pdf_document.status() != QPdfDocument.Status.Ready:
+            return
+
+        navigator = self.pdf_view.pageNavigator()
+        current_page = navigator.currentPage()
+        max_page = self._pdf_document.pageCount() - 1
+        if current_page < max_page:
+            try:
+                target_page = current_page + 1
+                navigator.update(target_page, navigator.currentLocation(), navigator.currentZoom())
+            except Exception:
+                try:
+                    # Fallback: Use scroll to approximate position
+                    page_height = self.pdf_view.viewport().height()
+                    self.pdf_view.verticalScrollBar().setValue(
+                        self.pdf_view.verticalScrollBar().value() + page_height
+                    )
+                except Exception:
+                    pass
+
+        # Update navigation button states (in case signal doesn't fire)
+        self._update_navigation_button_states()
+
+    @SafeSlot(bool)
+    def toggle_continuous_scroll(self, checked: bool):
+        """
+        Toggle between single page and continuous scroll mode.
+
+        Args:
+            checked (bool): True to enable continuous scroll, False for single page mode.
+        """
+        if checked:
+            self.pdf_view.setPageMode(QPdfView.PageMode.MultiPage)
+            self.pdf_view.setPageSpacing(self._page_spacing)
+            self._update_navigation_buttons_for_mode(continuous=True)
+            tooltip = "Switch to Single Page Mode"
+        else:
+            self.pdf_view.setPageMode(QPdfView.PageMode.SinglePage)
+            self._update_navigation_buttons_for_mode(continuous=False)
+            tooltip = "Switch to Continuous Scroll Mode"
+
+        # Update navigation button states after mode change
+        self._update_navigation_button_states()
+
+        # Update toggle button tooltip to reflect current state
+        action = self.toolbar.components.get_action("continuous_scroll")
+        if action and hasattr(action, "action") and action.action:
+            action.action.setToolTip(tooltip)
+
+    def _update_navigation_buttons_for_mode(self, continuous: bool):
+        """Update navigation button tooltips based on current mode."""
+        prev_action = self.toolbar.components.get_action("prev_page")
+        next_action = self.toolbar.components.get_action("next_page")
+
+        if continuous:
+            prev_actions_tooltip = "Previous Page (use scroll in continuous mode)"
+            next_actions_tooltip = "Next Page (use scroll in continuous mode)"
+        else:
+            prev_actions_tooltip = "Previous Page"
+            next_actions_tooltip = "Next Page"
+
+        if prev_action and hasattr(prev_action, "action") and prev_action.action:
+            prev_action.action.setToolTip(prev_actions_tooltip)
+        if next_action and hasattr(next_action, "action") and next_action.action:
+            next_action.action.setToolTip(next_actions_tooltip)
+
+    @SafeSlot()
+    def go_to_first_page(self):
+        """Go to the first page."""
+        if not self._pdf_document or self._pdf_document.status() != QPdfDocument.Status.Ready:
+            return
+
+        navigator = self.pdf_view.pageNavigator()
+        navigator.update(0, navigator.currentLocation(), navigator.currentZoom())
+
+    @SafeSlot()
+    def go_to_last_page(self):
+        """Go to the last page."""
+        if not self._pdf_document or self._pdf_document.status() != QPdfDocument.Status.Ready:
+            return
+
+        navigator = self.pdf_view.pageNavigator()
+        last_page = self._pdf_document.pageCount() - 1
+        navigator.update(last_page, navigator.currentLocation(), navigator.currentZoom())
+
+    @SafeSlot(int)
+    def jump_to_page(self, page_number: int):
+        """Jump to a specific page number (1-based index)."""
+        if not isinstance(page_number, int):
+            raise ValueError("page_number must be an integer")
+
+        if not self._pdf_document or self._pdf_document.status() != QPdfDocument.Status.Ready:
+            raise RuntimeError("No PDF document loaded")
+
+        max_page = self._pdf_document.pageCount()
+        page_number = max(min(page_number, max_page), 1)
+
+        target_page = page_number - 1  # Convert to 0-based index
+        navigator = self.pdf_view.pageNavigator()
+        navigator.update(target_page, navigator.currentLocation(), navigator.currentZoom())
+
+    def cleanup(self):
+        """Handle widget close event to prevent segfaults."""
+        if hasattr(self, "_pdf_document") and self._pdf_document:
+            self._pdf_document.statusChanged.disconnect()
+            empty_doc = QPdfDocument(self)
+            self.pdf_view.setDocument(empty_doc)
+
+        if hasattr(self, "toolbar"):
+            self.toolbar.cleanup()
+
+        super().cleanup()
+
+
+if __name__ == "__main__":
+    import sys
+
+    # from bec_qthemes import apply_theme
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    # apply_theme("dark")
+    viewer = PdfViewerWidget()
+    # viewer.load_pdf("/Path/To/Your/TestDocument.pdf")
+    viewer.next_page()
+    # viewer.page_spacing = 0
+    # viewer.side_margins = 0
+    viewer.resize(1000, 700)
+    viewer.show()
+
+    sys.exit(app.exec())

bec_widgets/widgets/utility/pdf_viewer/pdf_viewer_widget.pyproject

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

bec_widgets/widgets/utility/pdf_viewer/pdf_viewer_widget_plugin.py

@@ -0,0 +1,57 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.utility.pdf_viewer.pdf_viewer import PdfViewerWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='PdfViewerWidget' name='pdf_viewer_widget'>
+    </widget>
+</ui>
+"""
+
+
+class PdfViewerWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
+        t = PdfViewerWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Utils"
+
+    def icon(self):
+        return designer_material_icon(PdfViewerWidget.ICON_NAME)
+
+    def includeFile(self):
+        return "pdf_viewer_widget"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "PdfViewerWidget"
+
+    def toolTip(self):
+        return "A widget to display PDF documents with toolbar controls."
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/utility/pdf_viewer/register_pdf_viewer_widget.py

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

docs/user/widgets/pdf_viewer/pdf_viewer_widget.md

@@ -0,0 +1,119 @@
+(user.widgets.pdf_viewer_widget)=
+
+# PDF Viewer Widget
+
+````{tab} Overview
+
+The PDF Viewer Widget is a versatile tool designed for displaying and navigating PDF documents within your BEC applications. Directly integrated with the `BEC` framework, it provides a full-featured PDF viewing experience with zoom controls, page navigation, and customizable display options.
+
+## Key Features:
+- **Flexible Integration**: The widget can be integrated into [`BECDockArea`](user.widgets.bec_dock_area), or used as an individual component in your application through `BEC Designer`.
+- **Full PDF Support**: Display any PDF document with full rendering support through Qt's PDF rendering engine.
+- **Navigation Controls**: Built-in toolbar with page navigation, zoom controls, and document status indicators.
+- **Customizable Display**: Adjustable page spacing, margins, and zoom levels for optimal viewing experience.
+- **Document Management**: Load different PDF files dynamically during runtime with proper error handling.
+
+## User Interface Components:
+- **Toolbar**: Contains all navigation and zoom controls
+  - Previous/Next page buttons
+  - Page number input field with total page count
+  - First/Last page navigation buttons
+  - Zoom in/out buttons
+  - Fit to width/page buttons
+  - Reset zoom button
+- **PDF View Area**: Main display area for the PDF content
+
+````
+
+````{tab} Examples - CLI
+
+`PdfViewerWidget` can be embedded in [`BECDockArea`](user.widgets.bec_dock_area), or used as an individual component in your application through `BEC Designer`. The command-line API is the same for all cases.
+
+## Example 1 - Basic PDF Loading
+
+In this example, we demonstrate how to add a `PdfViewerWidget` to a [`BECDockArea`](user.widgets.bec_dock_area) and load a PDF document.
+
+```python
+# Add a new dock with PDF viewer widget
+dock_area = gui.new()
+pdf_viewer = dock_area.new().new(gui.available_widgets.PdfViewerWidget)
+
+# Load a PDF file
+pdf_viewer.load_pdf("/path/to/your/document.pdf")
+```
+
+## Example 2 - Customizing Display Properties
+
+This example shows how to customize the display properties of the PDF viewer for better presentation.
+
+```python
+# Create PDF viewer
+pdf_viewer = gui.new().new().new(gui.available_widgets.PdfViewerWidget)
+
+# Load PDF document
+pdf_viewer.load_pdf("/path/to/report.pdf")
+pdf_viewer.toggle_continuous_scroll(True)  # Enable continuous scroll mode
+
+# Customize display properties
+pdf_viewer.page_spacing = 20  # Increase spacing between pages
+pdf_viewer.side_margins = 50  # Add horizontal margins
+
+# Navigate to specific page
+pdf_viewer.jump_to_page(5)  # Go to page 5
+```
+
+## Example 3 - Navigation and Zoom Controls
+
+The PDF viewer provides programmatic access to all navigation and zoom functionality.
+
+```python
+# Create and load PDF
+pdf_viewer = gui.new().new().new(gui.available_widgets.PdfViewerWidget)
+pdf_viewer.load_pdf("/path/to/manual.pdf")
+
+# Navigation examples
+pdf_viewer.go_to_first_page()  # Go to first page
+pdf_viewer.go_to_last_page()   # Go to last page
+pdf_viewer.jump_to_page(10)    # Jump to specific page
+
+# Zoom controls
+pdf_viewer.zoom_in()           # Increase zoom
+pdf_viewer.zoom_out()          # Decrease zoom
+pdf_viewer.fit_to_width()      # Fit document to window width
+pdf_viewer.fit_to_page()       # Fit entire page to window
+pdf_viewer.reset_zoom()        # Reset to 100% zoom
+
+# Check current status
+current_page = pdf_viewer.current_page
+print(f"Currently viewing page {current_page}")
+```
+
+## Example 4 - Dynamic Document Loading
+
+This example demonstrates how to switch between different PDF documents dynamically.
+
+```python
+# Create PDF viewer
+pdf_viewer = gui.new().new().new(gui.available_widgets.PdfViewerWidget)
+
+# Load first document
+pdf_viewer.load_pdf("/path/to/document1.pdf")
+
+# Or simply set the current file path
+pdf_viewer.current_file_path = "/path/to/document2.pdf"
+# This automatically loads the new document
+
+# Check which file is currently loaded
+current_file = pdf_viewer.current_file_path
+print(f"Currently viewing: {current_file}")
+```
+
+````
+
+````{tab} API
+```{eval-rst}  
+.. autoclass:: bec_widgets.cli.client.PdfViewerWidget
+   :members:
+   :show-inheritance:
+```
+````

docs/user/widgets/widgets.md

@@ -270,6 +270,14 @@ Select DAP model from a list of DAP processes.
 
 Show and filter logs from the BEC Redis server.
 ```
+
+```{grid-item-card} PDF Viewer Widget
+:link: user.widgets.pdf_viewer_widget
+:link-type: ref
+:img-top: /assets/widget_screenshots/pdf_viewer.png
+
+Display and navigate PDF documents.
+```
 ````
 
 ```{toctree}
@@ -307,6 +315,7 @@ dap_combo_box/dap_combo_box.md
 games/games.md
 log_panel/log_panel.md
 signal_label/signal_label.md
+pdf_viewer/pdf_viewer_widget.md
 
 
 ```

pyproject.toml

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

tests/conftest.py

@@ -1,7 +1,33 @@
 import pytest
 import qtpy.QtCore
+from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
+from qtpy.QtCore import QTimer
+
+
+class TestableQTimer(QTimer):
+    _instances: list[tuple[QTimer, str]] = []
+    _current_test_name: str = ""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        TestableQTimer._instances.append((self, TestableQTimer._current_test_name))
+
+    @classmethod
+    def check_all_stopped(cls, qtbot):
+        def _is_done_or_deleted(t: QTimer):
+            try:
+                return not t.isActive()
+            except RuntimeError as e:
+                return "already deleted" in e.args[0]
+
+        try:
+            qtbot.waitUntil(lambda: all(_is_done_or_deleted(timer) for timer, _ in cls._instances))
+        except QtBotTimeoutError as exc:
+            active_timers = list(filter(lambda t: t[0].isActive(), cls._instances))
+            (t.stop() for t, _ in cls._instances)
+            raise TimeoutError(f"Failed to stop all timers: {active_timers}") from exc
+        cls._instances = []
 
-from bec_widgets.tests.utils import TestableQTimer
 
 # To support 'from qtpy.QtCore import QTimer' syntax we just replace this completely for the test session
 # see: https://docs.python.org/3/library/unittest.mock.html#where-to-patch

tests/end-2-end/test_plotting_framework_e2e.py

@@ -6,7 +6,7 @@ from bec_lib.endpoints import MessageEndpoints
 
 from bec_widgets.cli.client import Image, MotorMap, MultiWaveform, ScatterWaveform, Waveform
 from bec_widgets.cli.rpc.rpc_base import RPCReference
-from bec_widgets.tests.fake_devices import check_remote_data_size
+from bec_widgets.tests.utils import check_remote_data_size
 
 
 def test_rpc_waveform1d_custom_curve(qtbot, connected_client_gui_obj):

tests/unit_tests/client_mocks.py

@@ -9,7 +9,7 @@ from bec_lib.endpoints import MessageEndpoints
 from bec_lib.redis_connector import RedisConnector
 from bec_lib.scan_history import ScanHistory
 
-from bec_widgets.tests.fake_devices import DEVICES, DMMock, FakePositioner, Positioner
+from bec_widgets.tests.utils import DEVICES, DMMock, FakePositioner, Positioner
 
 
 def fake_redis_server(host, port):

tests/unit_tests/conftest.py

@@ -6,9 +6,12 @@ import numpy as np
 import pytest
 from bec_lib import messages
 from bec_lib.messages import _StoredDataInfo
-from qtpy.QtWidgets import QMessageBox
+from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
+from qtpy.QtWidgets import QApplication, QMessageBox
 
-from bec_widgets.tests import utils as test_utils
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
+from bec_widgets.utils import error_popups
 
 
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
@@ -22,22 +25,49 @@ def pytest_runtest_makereport(item, call):
 
 @pytest.fixture(autouse=True)
 def qapplication(qtbot, request, testable_qtimer_class):  # pylint: disable=unused-argument
-    yield from test_utils.qapplication_fixture(qtbot, request, testable_qtimer_class)
+    yield
+
+    # if the test failed, we don't want to check for open widgets as
+    # it simply pollutes the output
+    if request.node.stash._storage.get("failed"):
+        print("Test failed, skipping cleanup checks")
+        return
+    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
+    bec_dispatcher.stop_cli_server()
+
+    testable_qtimer_class.check_all_stopped(qtbot)
+    qapp = QApplication.instance()
+    qapp.processEvents()
+    if hasattr(qapp, "os_listener") and qapp.os_listener:
+        qapp.removeEventFilter(qapp.os_listener)
+    try:
+        qtbot.waitUntil(lambda: qapp.topLevelWidgets() == [])
+    except QtBotTimeoutError as exc:
+        raise TimeoutError(f"Failed to close all widgets: {qapp.topLevelWidgets()}") from exc
 
 
 @pytest.fixture(autouse=True)
 def rpc_register():
-    yield from test_utils.rpc_register_fixture()
+    yield RPCRegister()
+    RPCRegister.reset_singleton()
 
 
 @pytest.fixture(autouse=True)
 def bec_dispatcher(threads_check):  # pylint: disable=unused-argument
-    yield from test_utils.bec_dispatcher_fixture(threads_check)
+    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
+    yield bec_dispatcher
+    bec_dispatcher.disconnect_all()
+    # clean BEC client
+    bec_dispatcher.client.shutdown()
+    # stop the cli server
+    bec_dispatcher.stop_cli_server()
+    # reinitialize singleton for next test
+    bec_dispatcher_module.BECDispatcher.reset_singleton()
 
 
 @pytest.fixture(autouse=True)
 def clean_singleton():
-    yield from test_utils.clean_singleton_fixture()
+    error_popups._popup_utility_instance = None
 
 
 @pytest.fixture(autouse=True)

tests/unit_tests/test_abort_button.py

@@ -2,9 +2,10 @@
 
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.buttons.button_abort.button_abort import AbortButton
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def abort_button(qtbot, mocked_client):

tests/unit_tests/test_axis_settings.py

@@ -1,9 +1,9 @@
 import pytest
 from qtpy.QtWidgets import QDoubleSpinBox, QLineEdit
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.plot_base import PlotBase
 from bec_widgets.widgets.plots.setting_menus.axis_settings import AxisSettings
+from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 

tests/unit_tests/test_bec_connector.py

@@ -5,10 +5,11 @@ import pytest
 from qtpy.QtCore import QObject
 from qtpy.QtWidgets import QApplication
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils import BECConnector
 from bec_widgets.utils.error_popups import SafeSlot as Slot
 
+from .client_mocks import mocked_client
+
 
 class BECConnectorQObject(BECConnector, QObject): ...
 

tests/unit_tests/test_bec_dock.py

@@ -5,9 +5,9 @@ from unittest import mock
 import pytest
 from bec_lib.endpoints import MessageEndpoints
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.containers.dock import BECDockArea
 
+from .client_mocks import mocked_client
 from .test_bec_queue import bec_queue_msg_full
 
 

tests/unit_tests/test_bec_queue.py

@@ -1,9 +1,10 @@
 import pytest
 from bec_lib import messages
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.services.bec_queue.bec_queue import BECQueue
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def bec_queue_msg_full():

tests/unit_tests/test_bec_status_box.py

@@ -4,12 +4,13 @@ from unittest import mock
 import pytest
 from bec_lib.messages import BECStatus, ServiceMetricMessage, StatusMessage
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import (
     BECServiceInfoContainer,
     BECStatusBox,
 )
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def service_status_fixture():

tests/unit_tests/test_color_utils.py

@@ -4,11 +4,11 @@ from pydantic import ValidationError
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QVBoxLayout, QWidget
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils import Colors, ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.plots.waveform.curve import CurveConfig
+from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 

tests/unit_tests/test_crosshair.py

@@ -4,10 +4,10 @@ import pytest
 from qtpy.QtCore import QPointF, Qt
 from qtpy.QtGui import QTransform
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils import Crosshair
 from bec_widgets.widgets.plots.image.image_item import ImageItem
 from bec_widgets.widgets.plots.waveform.waveform import Waveform
+from tests.unit_tests.client_mocks import mocked_client
 
 from .conftest import create_widget
 

tests/unit_tests/test_curve_settings.py

@@ -6,13 +6,13 @@ from bec_lib.scan_history import ScanHistory
 from qtpy.QtGui import QValidator
 from qtpy.QtWidgets import QComboBox, QVBoxLayout
 
-from bec_widgets.tests.client_mocks import dap_plugin_message, mocked_client, mocked_client_with_dap
 from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_setting import CurveSetting
 from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_tree import (
     CurveTree,
     ScanIndexValidator,
 )
 from bec_widgets.widgets.plots.waveform.waveform import Waveform
+from tests.unit_tests.client_mocks import dap_plugin_message, mocked_client, mocked_client_with_dap
 from tests.unit_tests.conftest import create_widget
 
 ##################################################

tests/unit_tests/test_dap_combobox.py

@@ -1,8 +1,8 @@
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.dap.dap_combo_box.dap_combo_box import DapComboBox
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_dark_mode_button.py

@@ -4,11 +4,12 @@ import pytest
 from qtpy.QtCore import Qt
 from qtpy.QtWidgets import QApplication
 
-# pylint: disable=unused-import
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.colors import set_theme
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
+# pylint: disable=unused-import
+from .client_mocks import mocked_client
+
 # pylint: disable=redefined-outer-name
 
 

tests/unit_tests/test_device_browser.py

@@ -6,7 +6,6 @@ from bec_lib.device import Device
 from qtpy.QtCore import QPoint, Qt
 from qtpy.QtWidgets import QTabWidget
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.services.device_browser.device_browser import DeviceBrowser
 from bec_widgets.widgets.services.device_browser.device_item.device_config_form import (
     DeviceConfigForm,
@@ -15,6 +14,8 @@ from bec_widgets.widgets.services.device_browser.device_item.device_signal_displ
     SignalDisplay,
 )
 
+from .client_mocks import mocked_client
+
 if TYPE_CHECKING:  # pragma: no cover
     from qtpy.QtWidgets import QListWidgetItem
 

tests/unit_tests/test_device_input_base.py

@@ -4,13 +4,13 @@ import pytest
 from bec_lib.device import ReadoutPriority
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import (
     BECDeviceFilter,
     DeviceInputBase,
     DeviceInputConfig,
 )
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_device_input_widgets.py

@@ -1,13 +1,14 @@
 import pytest
 from bec_lib.device import ReadoutPriority
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
     DeviceLineEdit,
 )
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def device_input_combobox(qtbot, mocked_client):

tests/unit_tests/test_device_signal_input.py

@@ -4,7 +4,7 @@ import pytest
 from bec_lib.device import Signal
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.tests.client_mocks import mocked_client
+from bec_widgets.tests.utils import FakeDevice
 from bec_widgets.utils.ophyd_kind_util import Kind
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.control.device_input.base_classes.device_signal_input_base import (
@@ -16,6 +16,7 @@ from bec_widgets.widgets.control.device_input.signal_line_edit.signal_line_edit
     SignalLineEdit,
 )
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_filter_io.py

@@ -1,12 +1,12 @@
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.filter_io import FilterIO
 from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
     DeviceLineEdit,
 )
 from bec_widgets.widgets.dap.dap_combo_box.dap_combo_box import DapComboBox
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_heatmap_widget.py

@@ -5,10 +5,13 @@ import pytest
 from bec_lib import messages
 from bec_lib.scan_history import ScanHistory
 
-# pytest: disable=unused-import
-from bec_widgets.tests.client_mocks import create_dummy_scan_item, mocked_client
 from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap, HeatmapConfig, HeatmapDeviceSignal
 
+# pytest: disable=unused-import
+from tests.unit_tests.client_mocks import mocked_client
+
+from .client_mocks import create_dummy_scan_item
+
 
 @pytest.fixture
 def heatmap_widget(qtbot, mocked_client):

tests/unit_tests/test_image_roi_tree.py

@@ -4,10 +4,10 @@ import numpy as np
 import pytest
 from qtpy.QtCore import QPointF, Qt
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.image.image import Image
 from bec_widgets.widgets.plots.image.setting_widgets.image_roi_tree import ROIPropertyTree
 from bec_widgets.widgets.plots.roi.image_roi import CircularROI, RectangularROI
+from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 

tests/unit_tests/test_image_rois.py

@@ -5,7 +5,6 @@ from typing import Literal
 import numpy as np
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.image.image import Image
 from bec_widgets.widgets.plots.roi.image_roi import (
     CircularROI,
@@ -13,6 +12,7 @@ from bec_widgets.widgets.plots.roi.image_roi import (
     RectangularROI,
     ROIController,
 )
+from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 

tests/unit_tests/test_image_view_next_gen.py

@@ -3,8 +3,8 @@ import pyqtgraph as pg
 import pytest
 from qtpy.QtCore import QPointF
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.image.image import Image
+from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 ##################################################

tests/unit_tests/test_launch_window.py

@@ -8,10 +8,11 @@ from qtpy.QtGui import QFontMetrics
 
 import bec_widgets
 from bec_widgets.applications.launch_window import LaunchWindow
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 
+from .client_mocks import mocked_client
+
 base_path = os.path.dirname(bec_widgets.__file__)
 
 

tests/unit_tests/test_lmfit_dialog.py

@@ -3,9 +3,9 @@ from unittest import mock
 import numpy as np
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog import LMFitDialog
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_logpanel.py

@@ -8,12 +8,18 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 from bec_lib.messages import LogMessage
+from bec_lib.redis_connector import StreamMessage
 from qtpy.QtCore import QDateTime
 
-from bec_widgets.tests.client_mocks import mocked_client
-from bec_widgets.widgets.utility.logpanel._util import replace_escapes, simple_color_format
+from bec_widgets.widgets.utility.logpanel._util import (
+    log_time,
+    replace_escapes,
+    simple_color_format,
+)
 from bec_widgets.widgets.utility.logpanel.logpanel import DEFAULT_LOG_COLORS, LogPanel
 
+from .client_mocks import mocked_client
+
 TEST_TABLE_STRING = "2025-01-15 15:57:18 | bec_server.scan_server.scan_queue | [INFO] | \n \x1b[3m              primary queue / ScanQueueStatus.RUNNING              \x1b[0m\n┏━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━┓\n┃\x1b[1m \x1b[0m\x1b[1m queue_id  \x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mscan_id\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mis_scan\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mtype\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mscan_numb…\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mIQ status\x1b[0m\x1b[1m \x1b[0m┃\n┡━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━┩\n│ bbe50c82-6… │  None   │  False  │  mv  │    None    │  PENDING  │\n└─────────────┴─────────┴─────────┴──────┴────────────┴───────────┘\n\n"
 
 TEST_LOG_MESSAGES = [

tests/unit_tests/test_main_widnow.py

@@ -5,7 +5,6 @@ from qtpy.QtCore import QEvent, QPoint, QPointF
 from qtpy.QtGui import QEnterEvent
 from qtpy.QtWidgets import QApplication, QFrame, QLabel
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.containers.main_window.addons.hover_widget import (
     HoverWidget,
     WidgetTooltip,
@@ -14,6 +13,7 @@ from bec_widgets.widgets.containers.main_window.addons.scroll_label import Scrol
 from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_motor_map_next_gen.py

@@ -1,8 +1,8 @@
 import numpy as np
 import pyqtgraph as pg
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
+from tests.unit_tests.client_mocks import mocked_client
 
 from .conftest import create_widget
 

tests/unit_tests/test_multi_waveform_next_gen.py

@@ -1,7 +1,7 @@
 import numpy as np
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.multi_waveform.multi_waveform import MultiWaveform
+from tests.unit_tests.client_mocks import mocked_client
 
 from .conftest import create_widget
 

tests/unit_tests/test_notifications.py

@@ -1,7 +1,6 @@
 import pytest
 from qtpy import QtCore, QtGui, QtWidgets
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.error_popups import ErrorPopupUtility
 from bec_widgets.widgets.containers.main_window.addons.notification_center.notification_banner import (
     DARK_PALETTE,
@@ -14,6 +13,8 @@ from bec_widgets.widgets.containers.main_window.addons.notification_center.notif
     SeverityKind,
 )
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def toast(qtbot):

tests/unit_tests/test_pdf_viewer.py

@@ -0,0 +1,372 @@
+import pytest
+from qtpy.QtPdf import QPdfDocument
+from qtpy.QtPdfWidgets import QPdfView
+
+from bec_widgets.widgets.utility.pdf_viewer.pdf_viewer import PdfViewerWidget
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def pdf_viewer_widget(qtbot, mocked_client):
+    """Create a PDF viewer widget for testing."""
+    widget = PdfViewerWidget(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.cleanup()
+
+
+@pytest.fixture
+def temp_pdf_file(tmpdir):
+    """Create a minimal 3-page PDF file for testing."""
+    pdf_content = b"""%PDF-1.4
+1 0 obj
+<< /Type /Catalog /Pages 2 0 R >>
+endobj
+2 0 obj
+<< /Type /Pages /Kids [3 0 R 5 0 R 7 0 R] /Count 3 >>
+endobj
+
+3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>
+endobj
+4 0 obj
+<< /Length 44 >>
+stream
+BT /F1 12 Tf 100 700 Td (Page 1) Tj ET
+endstream
+endobj
+
+5 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 6 0 R >>
+endobj
+6 0 obj
+<< /Length 44 >>
+stream
+BT /F1 12 Tf 100 700 Td (Page 2) Tj ET
+endstream
+endobj
+
+7 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 8 0 R >>
+endobj
+8 0 obj
+<< /Length 44 >>
+stream
+BT /F1 12 Tf 100 700 Td (Page 3) Tj ET
+endstream
+endobj
+
+9 0 obj
+<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+endobj
+
+xref
+0 10
+0000000000 65535 f 
+0000000010 00000 n 
+0000000060 00000 n 
+0000000125 00000 n 
+0000000205 00000 n 
+0000000282 00000 n 
+0000000362 00000 n 
+0000000439 00000 n 
+0000000519 00000 n 
+0000000596 00000 n 
+trailer
+<< /Size 10 /Root 1 0 R >>
+startxref
+675
+%%EOF
+"""
+
+    pdf_path = tmpdir.join("test_3page.pdf")
+    pdf_path.write_binary(pdf_content)
+    return str(pdf_path)
+
+
+@pytest.fixture
+def temp_pdf_file_2(tmpdir):
+    """Create a second minimal temporary PDF file for testing."""
+    # Create a minimal PDF content for testing
+    pdf_content = b"""%PDF-1.4
+1 0 obj
+<<
+/Type /Catalog
+/Pages 2 0 R
+>>
+endobj
+2 0 obj
+<<
+/Type /Pages
+/Kids [3 0 R]
+/Count 1
+>>
+endobj
+3 0 obj
+<<
+/Type /Page
+/Parent 2 0 R
+/MediaBox [0 0 612 792]
+/Resources <<
+/Font <<
+/F1 <<
+/Type /Font
+/Subtype /Type1
+/BaseFont /Helvetica
+>>
+>>
+>>
+/Contents 4 0 R
+>>
+endobj
+4 0 obj
+<<
+/Length 44
+>>stream
+BT
+/F1 12 Tf
+100 700 Td
+(Second Test PDF) Tj
+ET
+endstream
+endobj
+xref
+0 5
+0000000000 65535 f 
+0000000009 00000 n 
+0000000058 00000 n 
+0000000115 00000 n 
+0000000307 00000 n 
+trailer
+<<
+/Size 5
+/Root 1 0 R
+>>
+startxref
+398
+%%EOF"""
+    # Create temporary PDF file using tmpdir
+    pdf_file = tmpdir.join("test2.pdf")
+    pdf_file.write_binary(pdf_content)
+    return str(pdf_file)
+
+
+def test_initialization(pdf_viewer_widget: PdfViewerWidget):
+    """Test that the widget initializes correctly."""
+    widget = pdf_viewer_widget
+
+    # Check basic widget setup
+    assert widget is not None
+    assert hasattr(widget, "pdf_view")
+    assert hasattr(widget, "toolbar")
+    assert hasattr(widget, "_pdf_document")
+
+    # Check initial state
+    assert widget._current_file_path is None
+    assert widget._page_spacing == 5
+    assert widget._side_margins == 10
+
+    # Check PDF view setup
+    assert isinstance(widget.pdf_view, QPdfView)
+    assert widget.pdf_view.zoomMode() == QPdfView.ZoomMode.FitToWidth
+
+    # Check PDF document setup
+    assert isinstance(widget._pdf_document, QPdfDocument)
+
+
+def test_toolbar_setup(pdf_viewer_widget: PdfViewerWidget):
+    """Test that toolbar is set up with all expected actions."""
+    widget = pdf_viewer_widget
+    toolbar = widget.toolbar
+
+    # Check that all expected actions exist
+    expected_actions = [
+        "open_file",
+        "zoom_in",
+        "zoom_out",
+        "fit_width",
+        "fit_page",
+        "reset_zoom",
+        "continuous_scroll",
+        "prev_page",
+        "next_page",
+        "page_jump",
+    ]
+
+    for action_name in expected_actions:
+        assert toolbar.components.exists(action_name), f"Action {action_name} not found"
+
+
+def test_load_pdf_file(qtbot, pdf_viewer_widget: PdfViewerWidget, temp_pdf_file, temp_pdf_file_2):
+    """Test loading a PDF file into the viewer."""
+    widget = pdf_viewer_widget
+
+    # Load the temporary PDF file
+    widget.load_pdf(temp_pdf_file)
+    qtbot.wait(100)  # Wait for loading
+
+    # Check that the document is loaded
+    assert widget._pdf_document.status() == QPdfDocument.Status.Ready
+    assert widget._pdf_document.pageCount() > 0
+    assert widget._current_file_path == temp_pdf_file
+
+    # Load a second PDF file to test reloading
+    widget.load_pdf(temp_pdf_file_2)
+    qtbot.wait(100)  # Wait for loading
+
+    # Check that the new document is loaded
+    assert widget._pdf_document.status() == QPdfDocument.Status.Ready
+    assert widget._pdf_document.pageCount() > 0
+    assert widget._current_file_path == temp_pdf_file_2
+
+    assert widget.current_file_path == temp_pdf_file_2
+
+    widget.current_file_path = temp_pdf_file
+    qtbot.wait(100)  # Wait for loading
+    assert widget.current_file_path == temp_pdf_file
+
+
+def test_load_invalid_pdf_file(qtbot, pdf_viewer_widget: PdfViewerWidget, tmpdir):
+    """Test loading an invalid PDF file into the viewer."""
+    widget = pdf_viewer_widget
+
+    # Try to open a non-existent file
+    invalid_pdf_file = tmpdir.join("non_existent.pdf")
+
+    # Attempt to load the invalid PDF file
+    with pytest.raises(FileNotFoundError):
+        widget.load_pdf(str(invalid_pdf_file), _override_slot_params={"raise_error": True})
+
+
+def test_page_navigation(qtbot, pdf_viewer_widget: PdfViewerWidget, temp_pdf_file):
+    """Test page navigation functionality."""
+    widget = pdf_viewer_widget
+
+    # Load the temporary PDF file
+    with qtbot.waitSignal(widget.document_ready, timeout=2000):
+        widget.load_pdf(temp_pdf_file)
+
+    # Check initial page
+    assert widget.current_page == 1
+    total_pages = widget._pdf_document.pageCount()
+    assert total_pages >= 1
+
+    # Navigate to next page
+    widget.next_page()
+    qtbot.wait(300)
+    assert widget.current_page == 2
+
+    # Navigate to previous page
+    widget.previous_page()
+    qtbot.wait(300)
+    assert widget.current_page == 1
+
+    # Jump to last page
+    widget.jump_to_page(total_pages)
+    qtbot.wait(300)
+    assert widget.current_page == total_pages
+
+    widget.jump_to_page(1)
+    qtbot.wait(300)
+    assert widget.current_page == 1
+
+    widget.jump_to_page(2)
+    qtbot.wait(300)
+    assert widget.current_page == 2
+
+    widget.go_to_last_page()
+    qtbot.wait(300)
+    assert widget.current_page == total_pages
+
+    widget.go_to_first_page()
+    qtbot.wait(300)
+    assert widget.current_page == 1
+
+    widget.page_input.setText(str(total_pages + 10))
+    widget.page_input.returnPressed.emit()
+    qtbot.wait(100)
+    assert widget.current_page == total_pages
+
+
+def test_zoom_controls(qtbot, pdf_viewer_widget: PdfViewerWidget, temp_pdf_file):
+    """Test zoom in, zoom out, fit width, fit page, and reset zoom functionality."""
+    widget = pdf_viewer_widget
+
+    # Load the temporary PDF file
+    with qtbot.waitSignal(widget.document_ready, timeout=2000):
+        widget.load_pdf(temp_pdf_file)
+
+    # Initial zoom mode should be FitToWidth
+    assert widget.pdf_view.zoomMode() == QPdfView.ZoomMode.FitToWidth
+
+    # Zoom in
+    initial_zoom = widget.pdf_view.zoomFactor()
+    widget.zoom_in()
+    qtbot.wait(100)
+    assert widget.pdf_view.zoomFactor() > initial_zoom
+
+    # Zoom out
+    zoom_after_in = widget.pdf_view.zoomFactor()
+    widget.zoom_out()
+    qtbot.wait(100)
+    assert widget.pdf_view.zoomFactor() < zoom_after_in
+
+    # Fit to page
+    widget.fit_to_page()
+    qtbot.wait(100)
+    assert widget.pdf_view.zoomMode() == QPdfView.ZoomMode.FitInView
+
+    # Fit to width
+    widget.fit_to_width()
+    qtbot.wait(100)
+    assert widget.pdf_view.zoomMode() == QPdfView.ZoomMode.FitToWidth
+
+    # Reset zoom
+    widget.reset_zoom()
+    qtbot.wait(100)
+    assert widget.pdf_view.zoomMode() == QPdfView.ZoomMode.Custom
+
+
+def test_page_spacing_and_margins(qtbot, pdf_viewer_widget: PdfViewerWidget, temp_pdf_file):
+    """Test setting page spacing and side margins."""
+    widget = pdf_viewer_widget
+
+    # Load the temporary PDF file
+    with qtbot.waitSignal(widget.document_ready, timeout=2000):
+        widget.load_pdf(temp_pdf_file)
+
+    # Set and verify page spacing
+    widget.page_spacing = 20
+    assert widget.page_spacing == 20
+
+    # Set and verify side margins
+    widget.side_margins = 30
+    assert widget.side_margins == 30
+
+
+def test_toggle_continuous_scroll(qtbot, pdf_viewer_widget: PdfViewerWidget, temp_pdf_file):
+    """Test toggling continuous scroll mode."""
+    widget = pdf_viewer_widget
+
+    # Load the temporary PDF file
+    with qtbot.waitSignal(widget.document_ready, timeout=2000):
+        widget.load_pdf(temp_pdf_file)
+
+    # Initial mode should be single page
+    assert widget.pdf_view.pageMode() == QPdfView.PageMode.SinglePage
+
+    # Toggle to continuous scroll
+    widget.toggle_continuous_scroll(True)
+    qtbot.wait(100)
+    assert widget.pdf_view.pageMode() == QPdfView.PageMode.MultiPage
+
+    # Toggle back to single page
+    widget.toggle_continuous_scroll(False)
+    qtbot.wait(100)
+    assert widget.pdf_view.pageMode() == QPdfView.PageMode.SinglePage
+
+    widget.jump_to_page(2)
+    qtbot.wait(100)
+    assert widget.current_page == 2

tests/unit_tests/test_plot_base_next_gen.py

@@ -1,8 +1,8 @@
 import numpy as np
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.plot_base import PlotBase, UIMode
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 # pylint: disable=unused-import

tests/unit_tests/test_positioner_box.py

@@ -7,8 +7,7 @@ from qtpy.QtCore import Qt, QTimer
 from qtpy.QtGui import QValidator
 from qtpy.QtWidgets import QPushButton
 
-from bec_widgets.tests.client_mocks import mocked_client
-from bec_widgets.tests.fake_devices import Positioner
+from bec_widgets.tests.utils import Positioner
 from bec_widgets.widgets.control.device_control.positioner_box import (
     PositionerBox,
     PositionerControlLine,
@@ -17,6 +16,7 @@ from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit
     DeviceLineEdit,
 )
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_positioner_box_2d.py

@@ -2,9 +2,9 @@ from unittest import mock
 
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox2D
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_reset_button.py

@@ -5,9 +5,10 @@ from unittest.mock import patch
 import pytest
 from qtpy.QtWidgets import QMessageBox
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.buttons.button_reset.button_reset import ResetButton
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def reset_button(qtbot, mocked_client):

tests/unit_tests/test_resume_button.py

@@ -2,9 +2,10 @@
 
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.buttons.button_resume.button_resume import ResumeButton
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def resume_button(qtbot, mocked_client):

tests/unit_tests/test_ring_progress_bar.py

@@ -4,12 +4,13 @@ import pytest
 from bec_lib.endpoints import MessageEndpoints
 from pydantic import ValidationError
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils import Colors
 from bec_widgets.widgets.progress.ring_progress_bar import RingProgressBar
 from bec_widgets.widgets.progress.ring_progress_bar.ring import ProgressbarConnections, RingConfig
 from bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar import RingProgressBarConfig
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def ring_progress_bar(qtbot, mocked_client):

tests/unit_tests/test_scan_control.py

@@ -7,11 +7,12 @@ from bec_lib.endpoints import MessageEndpoints
 from bec_lib.messages import AvailableResourceMessage, ScanHistoryMessage
 from qtpy.QtCore import QModelIndex, Qt
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.forms_from_types.items import StrFormItem
 from bec_widgets.utils.widget_io import WidgetIO
 from bec_widgets.widgets.control.scan_control import ScanControl
 
+from .client_mocks import mocked_client
+
 # pylint: disable=no-member
 # pylint: disable=missing-function-docstring
 # pylint: disable=redefined-outer-name

tests/unit_tests/test_scan_history_browser.py

@@ -2,9 +2,10 @@ from unittest import mock
 
 import pytest
 from bec_lib.messages import ScanHistoryMessage, _StoredDataInfo
+from pytestqt import qtbot
 from qtpy import QtCore
 
-from bec_widgets.tests.client_mocks import mocked_client
+from bec_widgets.utils.colors import get_accent_colors
 from bec_widgets.widgets.services.scan_history_browser.components import (
     ScanHistoryDeviceViewer,
     ScanHistoryMetadataViewer,
@@ -14,6 +15,8 @@ from bec_widgets.widgets.services.scan_history_browser.scan_history_browser impo
     ScanHistoryBrowser,
 )
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def scan_history_msg():

tests/unit_tests/test_scan_progress_bar.py

@@ -4,7 +4,6 @@ import numpy as np
 import pytest
 from bec_lib import messages
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.progress.bec_progressbar.bec_progressbar import (
     BECProgressBar,
     ProgressState,
@@ -15,6 +14,8 @@ from bec_widgets.widgets.progress.scan_progressbar.scan_progressbar import (
     ScanProgressBar,
 )
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def scan_progressbar(qtbot, mocked_client):

tests/unit_tests/test_scatter_waveform.py

@@ -2,12 +2,12 @@ import json
 
 import numpy as np
 
-from bec_widgets.tests.client_mocks import create_dummy_scan_item, mocked_client
 from bec_widgets.widgets.plots.scatter_waveform.scatter_curve import (
     ScatterCurveConfig,
     ScatterDeviceSignal,
 )
 from bec_widgets.widgets.plots.scatter_waveform.scatter_waveform import ScatterWaveform
+from tests.unit_tests.client_mocks import create_dummy_scan_item, mocked_client
 
 from .conftest import create_widget
 

tests/unit_tests/test_signal_label.py

@@ -4,14 +4,15 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 from qtpy import QtCore
-from qtpy.QtWidgets import QDialogButtonBox
+from qtpy.QtWidgets import QDialogButtonBox, QLabel
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.device_input.base_classes.device_signal_input_base import (
     DeviceSignalInputBaseConfig,
 )
 from bec_widgets.widgets.utility.signal_label.signal_label import ChoiceDialog, SignalLabel
 
+from .client_mocks import mocked_client
+
 SAMX_INFO_DICT = {
     "signals": {
         "readback": {

tests/unit_tests/test_stop_button.py

@@ -2,9 +2,10 @@
 
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def stop_button(qtbot, mocked_client):

tests/unit_tests/test_text_box_widget.py

@@ -1,8 +1,9 @@
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.editors.text_box.text_box import DEFAULT_TEXT, TextBox
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def text_box_widget(qtbot, mocked_client):

tests/unit_tests/test_utils_bec_signal_proxy.py

@@ -3,10 +3,10 @@ from unittest import mock
 import pyqtgraph as pg
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.bec_signal_proxy import BECSignalProxy
 from bec_widgets.widgets.dap.dap_combo_box.dap_combo_box import DapComboBox
 
+from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_utils_plot_indicators.py

@@ -1,9 +1,10 @@
 import pytest
 from qtpy.QtCore import QPointF
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.waveform.waveform import Waveform
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def plot_widget_with_arrow_item(qtbot, mocked_client):

tests/unit_tests/test_vscode_widget.py

@@ -5,9 +5,10 @@ from unittest import mock
 
 import pytest
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def vscode_widget(qtbot, mocked_client):

tests/unit_tests/test_waveform.py

@@ -12,7 +12,13 @@ from pyqtgraph.graphicsItems.DateAxisItem import DateAxisItem
 from qtpy.QtCore import QTimer
 from qtpy.QtWidgets import QApplication, QCheckBox, QDialog, QDialogButtonBox, QDoubleSpinBox
 
-from bec_widgets.tests.client_mocks import (
+from bec_widgets.widgets.plots.plot_base import UIMode
+from bec_widgets.widgets.plots.waveform.curve import DeviceSignal
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
+from bec_widgets.widgets.services.scan_history_browser.scan_history_browser import (
+    ScanHistoryBrowser,
+)
+from tests.unit_tests.client_mocks import (
     DummyData,
     create_dummy_scan_item,
     dap_plugin_message,
@@ -20,12 +26,6 @@ from bec_widgets.tests.client_mocks import (
     mocked_client,
     mocked_client_with_dap,
 )
-from bec_widgets.widgets.plots.plot_base import UIMode
-from bec_widgets.widgets.plots.waveform.curve import DeviceSignal
-from bec_widgets.widgets.plots.waveform.waveform import Waveform
-from bec_widgets.widgets.services.scan_history_browser.scan_history_browser import (
-    ScanHistoryBrowser,
-)
 
 from .conftest import create_widget
 

tests/unit_tests/test_web_console.py

@@ -3,9 +3,10 @@ from unittest import mock
 import pytest
 from qtpy.QtNetwork import QAuthenticator
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.editors.web_console.web_console import WebConsole, _web_console_registry
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def console_widget(qtbot, mocked_client):

tests/unit_tests/test_website_widget.py

@@ -1,9 +1,10 @@
 import pytest
 from qtpy.QtCore import QUrl
 
-from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.editors.website.website import WebsiteWidget
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def website_widget(qtbot, mocked_client):