bec-widgets 0.44.4__py3-none-any.whl → 0.45.0__py3-none-any.whl

bec_widgets-0.45.0.dist-info/RECORD

@@ -0,0 +1,98 @@
+bec_widgets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bec_widgets/cli/__init__.py,sha256=yFyAmDteCcndbReunhnrfDib6JujQ7-BKWeVvuU0Ylw,30
+bec_widgets/cli/client.py,sha256=J3yvhteGky9XHXMoyN0am75uAE4qeo7Oj_dZbdtMHRM,37300
+bec_widgets/cli/client_utils.py,sha256=8tVOmAMo5x0tUywTfivvCt8n0tJoT5WzoCa3GtsZ-qE,9694
+bec_widgets/cli/generate_cli.py,sha256=QqTacqaG3zYi-Zmun62j-4Tv-Az5rDbvFXA2ESFjWZ0,4010
+bec_widgets/cli/server.py,sha256=4552dbbdJlalIllQGJFR3AsN0iLl5Qs23BAeqQiof0s,4721
+bec_widgets/examples/__init__.py,sha256=WWQ0cu7m8sA4Ehy-DWdTIqSISjaHsbxhsNmNrMnhDZU,202
+bec_widgets/examples/eiger_plot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bec_widgets/examples/eiger_plot/eiger_plot.py,sha256=Uxl2Usf8jEzaX7AT8zVqa1x8ZIEgI1HmazSlb-tRFWE,10359
+bec_widgets/examples/eiger_plot/eiger_plot.ui,sha256=grHfnO3OG_lelJhdRsnA0badCvRdDunPrIMIyNQ5N-w,5809
+bec_widgets/examples/mca_readout/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bec_widgets/examples/mca_readout/mca_plot.py,sha256=do7mSK_nzHtojRiMi8JoN_Rckg9yfjYYWz2S_Nl3xbE,5079
+bec_widgets/examples/mca_readout/mca_sim.py,sha256=Dv_yYJ-uCmfMTBX0l-yVZqn-UHpfo8L3jNZ-JOPtzHk,867
+bec_widgets/examples/motor_movement/__init__.py,sha256=LzPJkxLAxOsZCbXR-fRCPmeYobp7Yqds6tDxW4W1gSw,214
+bec_widgets/examples/motor_movement/config_example.yaml,sha256=YT8Bl3ViTaP03cX9X8kIgWnkoxaQOFqS-oRrclGS2hc,356
+bec_widgets/examples/motor_movement/csax_bec_config.yaml,sha256=cqhzwfIhFgHfCt90oVW3no8aVlWg7V42t4iiJCnydSw,146
+bec_widgets/examples/motor_movement/csaxs_config.yaml,sha256=poNndp-1ptdnriIJ_RTnbAimFlOJ45VdxfkclGEQlgc,344
+bec_widgets/examples/motor_movement/motor_control_compilations.py,sha256=HIDauBIkNmKB8oCuGy_toNkIYxsdBCEniK2zj6vZFVg,8979
+bec_widgets/examples/motor_movement/motor_controller.ui,sha256=83XX6NGILwntoUIghvzWnMuGf80O8khK3SduVKTAEFM,29105
+bec_widgets/examples/motor_movement/motor_example.py,sha256=_0S_VnksFhwb3WM3dQuI9BUrn8UYzXJg5q6ayPCsaoI,53414
+bec_widgets/examples/stream_plot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bec_widgets/examples/stream_plot/line_plot.ui,sha256=rgNfhOXu1AcWF0P6wnOlmJKDjS-VIoduVrREvmzJQR8,4626
+bec_widgets/examples/stream_plot/stream_plot.py,sha256=ZzvJm4T--oxmAGj4IeDWsNuBrWq_MyY04vI_OFJYs4A,12184
+bec_widgets/simulations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bec_widgets/utils/__init__.py,sha256=-szVMxtb6Aoz5_e6Py652ExbGnmSVjd0w6ULBvumguk,353
+bec_widgets/utils/bec_connector.py,sha256=h4GGoaPSsdBolG5n8uCVWILHTe46NckTQqdBHBPlRaE,3652
+bec_widgets/utils/bec_dispatcher.py,sha256=nzocqIcVzJpWP5hTnAx0l-M6Wm7pU2sfW5KmQrMVbu0,7365
+bec_widgets/utils/bec_table.py,sha256=Xy5qM343K8EvEpB4g_129b63yo1wdEvEY3wqxB_p_Iw,716
+bec_widgets/utils/colors.py,sha256=JsLxzkxbw-I8GIuvnIKyiM83n0edhyMG2Fa4Ffm62ww,2392
+bec_widgets/utils/crosshair.py,sha256=5gG4G6jjtp6Bd1Y5EySHP2EkmtR4mYdxLCgVtx9fokE,9406
+bec_widgets/utils/ctrl_c.py,sha256=NMJlPDZcuqMUGykyhuZY5Ibed4yRI1K_uh16z2MmlXQ,1198
+bec_widgets/utils/entry_validator.py,sha256=nPdu87Ry9Vka2QVbOLW4YbLJwEWpRYypNl7hlXaMaHM,614
+bec_widgets/utils/rpc_decorator.py,sha256=pIvtqySQLnuS7l2Ti_UAe4WX7CRivZnsE5ZdKAihxh0,479
+bec_widgets/utils/validator_delegate.py,sha256=Emj1WF6W8Ke1ruBWUfmHdVJpmOSPezuOt4zvQTay_44,442
+bec_widgets/utils/widget_io.py,sha256=JKl508VnqQSxcaHqKaoBQ1TWSOm3pXhxQGx7iF_pRA0,10875
+bec_widgets/utils/yaml_dialog.py,sha256=soZI8BOjlqYGfYDga70MEvkxJTsktq4y7B3uog2cSik,1851
+bec_widgets/validation/__init__.py,sha256=ismd1bU5FhFb0zFPwNKuq7oT48G4Y2GfaMZOdNKUtGk,132
+bec_widgets/validation/monitor_config_validator.py,sha256=M9p8K_nvxicnqJB4X7j90R377WHYVH4wMCtSXsRI51M,8150
+bec_widgets/widgets/__init__.py,sha256=QNCuDcg0o3uvGbf74qXeFjEsgIzOeEcd1hoWabJ4tKQ,437
+bec_widgets/widgets/editor/__init__.py,sha256=5mBdFYi_IpygCz81kbLEZUWhd1b6oqiO3nASejuV_ug,30
+bec_widgets/widgets/editor/editor.py,sha256=pIIYLPqqqhXqT11Xj10cyGEiy-ieNGE4ZujN5lf0e68,15110
+bec_widgets/widgets/figure/__init__.py,sha256=3hGx_KOV7QHCYAV06aNuUgKq4QIYCjUTad-DrwkUaBM,44
+bec_widgets/widgets/figure/figure.py,sha256=-3SJu93gE73ttrfxD9NGPRmgvaZjH0jOX_7ovhrHXck,32454
+bec_widgets/widgets/figure/figure_debug_minimal.ui,sha256=GodXBvBvs5QAUsHbo3pcxR4o51Tvce4DTqpTluk3hOs,742
+bec_widgets/widgets/monitor/__init__.py,sha256=afXuZcBOxNAuYdCkIQXX5J60R5A3Q_86lNEW2vpFtPI,32
+bec_widgets/widgets/monitor/config_dialog.py,sha256=Z1a4WRIVlfEGdwC-QG25kba2EHCZWi5J843tBVZlWiI,20275
+bec_widgets/widgets/monitor/config_dialog.ui,sha256=ISMcF7CLTAMXhfZh2Yv5yezzAjMtb9fxY1pmX4B_jCg,5932
+bec_widgets/widgets/monitor/monitor.py,sha256=ET5O48kqRlwd8_jCMCrp8QwnL8LvoNgb5nQmVw36pKg,30219
+bec_widgets/widgets/monitor/tab_template.ui,sha256=JVB5fkzVhTjxMn9EdZCXsnfzBkeZpFMdTRuqTNSDSSo,4904
+bec_widgets/widgets/monitor_scatter_2D/__init__.py,sha256=hgiRKV5PBdesYLFbLmYb-qfqNTIGwzpdQFvkLi6-qnE,52
+bec_widgets/widgets/monitor_scatter_2D/monitor_scatter_2D.py,sha256=AKx3SUKxbyUxpXAHG5T-_horr02coKHbcMQppRZ_eEY,13108
+bec_widgets/widgets/motor_control/__init__.py,sha256=_4-G9AKcEnOyS6qVE26meRw3grEohNeMzACNMU5Sig0,153
+bec_widgets/widgets/motor_control/motor_control.py,sha256=sfH_uGes4B3mOFPP9BYVMtqMSCFD5fWJNQwNxV06288,42458
+bec_widgets/widgets/motor_control/motor_control_absolute.ui,sha256=nR3p6oevAkIBTLW5wM_zYOVWsCAUgeMZdRm10Q77COE,4126
+bec_widgets/widgets/motor_control/motor_control_relative.ui,sha256=PulNJNiws7TRAxHM2snNyvlmQ0tRShdArHmtaC85h4U,8684
+bec_widgets/widgets/motor_control/motor_control_selection.ui,sha256=vXXpvNWuL6xyHhW7Lx1zmVFX-95Z5AXGlhKQD2HmM1A,1779
+bec_widgets/widgets/motor_control/motor_control_table.ui,sha256=t6aRKiSmutMfp0AyupavbCs0cal-FANEnlKQiPzC9PQ,2792
+bec_widgets/widgets/motor_map/__init__.py,sha256=K3c-3A_LbxK0UJ0_bV3opL-wGLTwBLendsJXsg8GAqE,32
+bec_widgets/widgets/motor_map/motor_map.py,sha256=A7VOs8RAiXaLZF4_oxOYJX5BwMhRvir0k0u5eEPFtLc,21909
+bec_widgets/widgets/plots/__init__.py,sha256=ncGc6re47T9Bq75RQrPrk2rX2V89QZWRFOwZjmvkQPw,241
+bec_widgets/widgets/plots/image.py,sha256=Ty-8etIYBQl1MJLcuwCtlLUcAuXbxBq4RLDikbTL34c,31748
+bec_widgets/widgets/plots/motor_map.py,sha256=yBqVvLgEQhiIpQyvmsoTUToEyLblVmS2sTST7N8hNQA,15115
+bec_widgets/widgets/plots/plot_base.py,sha256=tF0oamgCVIXFrfD8jnMVTltkzYLLSQ0Dq9HAG57Ji3E,8446
+bec_widgets/widgets/plots/waveform1d.py,sha256=RbI5dQlbAaC4A1WuQLS1DWpk5UjeELpaUEvHkFvZAbA,25631
+bec_widgets/widgets/scan_control/__init__.py,sha256=IOfHl15vxb_uC6KN62-PeUzbBha_vQyqkkXbJ2HU674,38
+bec_widgets/widgets/scan_control/scan_control.py,sha256=tbO9tbVynRvs4VCxTZ4ZFBDTVAojIr-zkl70vuHbWgw,17116
+bec_widgets/widgets/toolbar/__init__.py,sha256=d-TP4_cr_VbpwreMM4ePnfZ5YXsEPQ45ibEf75nuGoE,36
+bec_widgets/widgets/toolbar/toolbar.py,sha256=sxz7rbc8XNPS6n2WMObF4-2PqdYfPxVtsOZEGV6mqa0,5124
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/client_mocks.py,sha256=925yW3vFnS8h6ym_4kpgX299WGVeObkGneuiXNWRE7s,3596
+tests/conftest.py,sha256=wMFVnerrLZjpi-OnPf7Ugah_DCb51QD1WWcbR4e_M6k,1055
+tests/test_bec_connector.py,sha256=f2XXGGw3NoZLIUrDuZuEWwF_ttOYmmquCgUrV5XkIOY,1951
+tests/test_bec_dispatcher.py,sha256=vWQGdUyMvssrOyiVxdsOpErOh4awX_NSQWvKSBoRfAI,9223
+tests/test_bec_figure.py,sha256=-2KYedk32pCsXNmAN0OFUrQT101YV3rrSL0ET3KXjjA,7464
+tests/test_bec_monitor.py,sha256=mN7gBY7oXY6j65zzihpy8r-FvwVoCQlie3F6SoVq0mo,7042
+tests/test_bec_monitor_scatter2D.py,sha256=UYs0pe9uBX7GpFVkhxw-Hx_MwTz7NKMtWIBqONTZ1JI,5797
+tests/test_bec_motor_map.py,sha256=5D-xPQQ731Q6wsEzAmqJqoy_FpHtlK1siwqql8sJ0p0,4613
+tests/test_config_dialog.py,sha256=5uNGcpvrx8qDdMwFCTXr8HMzFZF4rFi-ZHoDpMxGMf8,6955
+tests/test_crosshair.py,sha256=d7fX-ymboZPALNqqiAj86PZ96llmGZ_3jf0yjVP0S94,5039
+tests/test_editor.py,sha256=TED5k1xFJHRZ4KDAg2VxSRu_hMJnra-lbAmVwsDicsM,6784
+tests/test_eiger_plot.py,sha256=bWnKBQid0YcLMQeBLy6ojb4ZpwTG-rFVT0kMg9Y08p8,4427
+tests/test_generate_cli_client.py,sha256=BdpTZMNUFOBJa2e-rme9AJUoXfueYyLiUCOpGi3SNvc,2400
+tests/test_motor_control.py,sha256=jdTG35z3jOL9XCAIDNIGfdv60vcwGLHa3KJjKqJkoZw,20322
+tests/test_motor_map.py,sha256=UEjmtIYI2mxq9BUeopqoqNNy7UiPJEts9h45ufsFcrA,5979
+tests/test_plot_base.py,sha256=bOdlgAxh9oKk5PwiQ_MSFmzr44uJ61Tlg242RCIhl5c,2610
+tests/test_scan_control.py,sha256=e6_YpyxcayK35jXBSfxinGNL_8G-jcrWap25eg3z4QI,7560
+tests/test_stream_plot.py,sha256=LNCYIj9CafremGaz-DwDktCRJRrjgfOdVewCUwwZE5s,5843
+tests/test_validator_errors.py,sha256=NFxyv0TIOXeZKZRRUBfVQ7bpunwY4KkG95yTUdQmvns,3532
+tests/test_waveform1d.py,sha256=GzlQTAjbg35mMKhopLCiHy3fIx0ld6WTr46ZuMTeSTE,13644
+tests/test_widget_io.py,sha256=FeL3ZYSBQnRt6jxj8VGYw1cmcicRQyHKleahw7XIyR0,3475
+tests/test_yaml_dialog.py,sha256=HNrqferkdg02-9ieOhhI2mr2Qvt7GrYgXmQ061YCTbg,5794
+tests/test_msgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_msgs/available_scans_message.py,sha256=m_z97hIrjHXXMa2Ex-UvsPmTxOYXfjxyJaGkIY6StTY,46532
+bec_widgets-0.45.0.dist-info/LICENSE,sha256=YRKe85CBRyP7UpEAWwU8_qSIyuy5-l_9C-HKg5Qm8MQ,1511
+bec_widgets-0.45.0.dist-info/METADATA,sha256=9EPs7EAqxS-MNM5INN1K7kdqlawrd_oeyHwDhotp5wI,3714
+bec_widgets-0.45.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bec_widgets-0.45.0.dist-info/top_level.txt,sha256=EXCwhJYmXmd1DjYYL3hrGsddX-97IwYSiIHrf27FFVk,18
+bec_widgets-0.45.0.dist-info/RECORD,,

tests/client_mocks.py

@@ -1,7 +1,9 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+from unittest.mock import MagicMock, patch
 
 import pytest
-from unittest.mock import MagicMock
+from bec_lib.device import Positioner
+from bec_lib.devicemanager import DeviceContainer
 
 
 class FakeDevice:
@@ -11,7 +13,7 @@ class FakeDevice:
         self.name = name
         self.enabled = enabled
         self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
 
     def __contains__(self, item):
         return item == self.name
@@ -37,41 +39,85 @@ class FakeDevice:
         return self.description
 
 
-def get_mocked_device(device_name: str):
-    """
-    Helper function to mock the devices
-    Args:
-        device_name(str): Name of the device to mock
-    """
-    return FakeDevice(name=device_name, enabled=True)
+class FakePositioner(FakeDevice):
+    def __init__(self, name, enabled=True, limits=None, read_value=1.0):
+        super().__init__(name, enabled)
+        self.limits = limits if limits is not None else [0, 0]
+        self.read_value = read_value
+
+    def set_read_value(self, value):
+        self.read_value = value
+
+    def read(self):
+        return {self.name: {"value": self.read_value}}
+
+    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 DMMock:
+    def __init__(self):
+        self.devices = DeviceContainer()
+
+    def add_devives(self, devices: list):
+        for device in devices:
+            self.devices[device.name] = device
+
+
+DEVICES = [
+    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
+    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
+    FakePositioner("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"),
+]
 
 
 @pytest.fixture(scope="function")
 def mocked_client():
-    # Create a dictionary of mocked devices
-    device_names = [
-        "samx",
-        "samy",
-        "gauss_bpm",
-        "gauss_adc1",
-        "gauss_adc2",
-        "gauss_adc3",
-        "bpm4i",
-        "bpm3a",
-        "bpm3i",
-    ]
-    mocked_devices = {name: get_mocked_device(name) for name in device_names}
-
     # Create a MagicMock object
     client = MagicMock()
 
     # Mock the device_manager.devices attribute
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: mocked_devices.get(x)
-    client.device_manager.devices.__contains__.side_effect = lambda x: x in mocked_devices
+    client.device_manager = DMMock()
+    client.device_manager.add_devives(DEVICES)
+
+    def mock_mv(*args, relative=False):
+        # Extracting motor and value pairs
+        for i in range(0, len(args), 2):
+            motor = args[i]
+            value = args[i + 1]
+            motor.move(value, relative=relative)
+        return MagicMock(wait=MagicMock())
+
+    client.scans = MagicMock(mv=mock_mv)
+
+    # Ensure isinstance check for Positioner passes
+    original_isinstance = isinstance
 
-    # Set each device as an attribute of the mock
-    for name, device in mocked_devices.items():
-        setattr(client.device_manager.devices, name, device)
+    def isinstance_mock(obj, class_info):
+        if class_info == Positioner and isinstance(obj, FakePositioner):
+            return True
+        return original_isinstance(obj, class_info)
 
-    return client
+    with patch("builtins.isinstance", new=isinstance_mock):
+        yield client

tests/conftest.py

@@ -1,7 +1,8 @@
-import pytest
 import threading
 
+import pytest
 from bec_lib.bec_service import BECService
+
 from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
 
 

tests/test_bec_connector.py

@@ -1,9 +1,10 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import pytest
 
-from .client_mocks import mocked_client
 from bec_widgets.utils import BECConnector, ConnectionConfig
 
+from .client_mocks import mocked_client
+
 
 @pytest.fixture
 def bec_connector(mocked_client):

tests/test_bec_dispatcher.py

@@ -2,11 +2,10 @@
 from unittest.mock import Mock
 
 import pytest
-from bec_lib.messages import ScanMessage
 from bec_lib.connector import MessageObject
+from bec_lib.messages import ScanMessage
 
-
-msg = MessageObject(topic="", value=ScanMessage(point_id=0, scanID=0, data={}))
+msg = MessageObject(topic="", value=ScanMessage(point_id=0, scan_id=0, data={}))
 
 
 @pytest.fixture(name="consumer")
@@ -206,7 +205,7 @@ def test_connect_one_slot_multiple_topics_single_callback(bec_dispatcher, consum
     # Simulate messages being published on each topic
     for topic in topics:
         msg_with_topic = MessageObject(
-            topic=topic, value=ScanMessage(point_id=0, scanID=0, data={})
+            topic=topic, value=ScanMessage(point_id=0, scan_id=0, data={})
         )
         consumer.register.call_args.kwargs["cb"](msg_with_topic)
 

tests/test_bec_figure.py

@@ -1,12 +1,14 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
 import os
+from unittest.mock import MagicMock
 
 import numpy as np
 import pytest
-from unittest.mock import MagicMock
+
+from bec_widgets.widgets import BECFigure, BECMotorMap, BECWaveform1D
+from bec_widgets.widgets.plots import BECImageShow
 
 from .client_mocks import mocked_client
-from bec_widgets.widgets import BECFigure
 
 
 @pytest.fixture
@@ -65,6 +67,16 @@ def test_bec_figure_add_remove_plot(bec_figure):
     assert bec_figure._widgets["widget_2"].config.widget_class == "BECWaveform1D"
 
 
+def test_add_different_types_of_widgets(bec_figure):
+    plt = bec_figure.plot("samx", "bpm4i")
+    im = bec_figure.image("eiger")
+    motor_map = bec_figure.motor_map("samx", "samy")
+
+    assert plt.__class__ == BECWaveform1D
+    assert im.__class__ == BECImageShow
+    assert motor_map.__class__ == BECMotorMap
+
+
 def test_access_widgets_access_errors(bec_figure):
     bec_figure.add_plot(row=0, col=0)
 

tests/test_bec_monitor.py

@@ -1,12 +1,14 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import os
-import yaml
+from unittest.mock import MagicMock
 
 import pytest
-from unittest.mock import MagicMock
+import yaml
 
 from bec_widgets.widgets import BECMonitor
 
+from .client_mocks import mocked_client
+
 
 def load_test_config(config_name):
     """Helper function to load config from yaml file."""
@@ -16,69 +18,6 @@ def load_test_config(config_name):
     return config
 
 
-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name}}
-
-    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 get_mocked_device(device_name: str):
-    """
-    Helper function to mock the devices
-    Args:
-        device_name(str): Name of the device to mock
-    """
-    return FakeDevice(name=device_name, enabled=True)
-
-
-@pytest.fixture(scope="function")
-def mocked_client():
-    # Create a dictionary of mocked devices
-    device_names = ["samx", "gauss_bpm", "gauss_adc1", "gauss_adc2", "gauss_adc3", "bpm4i"]
-    mocked_devices = {name: get_mocked_device(name) for name in device_names}
-
-    # Create a MagicMock object
-    client = MagicMock()
-
-    # Mock the device_manager.devices attribute
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: mocked_devices.get(x)
-    client.device_manager.devices.__contains__.side_effect = lambda x: x in mocked_devices
-
-    # Set each device as an attribute of the mock
-    for name, device in mocked_devices.items():
-        setattr(client.device_manager.devices, name, device)
-
-    return client
-
-
 @pytest.fixture(scope="function")
 def monitor(bec_dispatcher, qtbot, mocked_client):
     # client = MagicMock()
@@ -126,12 +65,7 @@ def test_on_config_update(monitor, config_initial, config_update):
 @pytest.mark.parametrize(
     "config_name, expected_num_columns, expected_plot_names, expected_coordinates",
     [
-        (
-            "config_device",
-            1,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (1, 0)],
-        ),
+        ("config_device", 1, ["BPM4i plots vs samx", "Gauss plots vs samx"], [(0, 0), (1, 0)]),
         (
             "config_scan",
             3,
@@ -186,7 +120,7 @@ msg_1 = {
         "gauss_adc1": {"gauss_adc1": {"value": 8}},
         "gauss_adc2": {"gauss_adc2": {"value": 9}},
     },
-    "scanID": 1,
+    "scan_id": 1,
 }
 metadata_grid = {"scan_name": "grid_scan"}
 metadata_line = {"scan_name": "line_scan"}
@@ -195,7 +129,7 @@ metadata_line = {"scan_name": "line_scan"}
 @pytest.mark.parametrize(
     "config_name, msg, metadata, expected_data",
     [
-        # case: msg does not have 'scanID'
+        # case: msg does not have 'scan_id'
         (
             "config_device",
             {"data": {}},
@@ -271,9 +205,6 @@ def test_on_scan_segment(monitor, config_name, msg, metadata, expected_data):
     config = load_test_config(config_name)
     monitor.on_config_update(config)
 
-    # Get hints
-    monitor.dev.__getitem__.side_effect = mock_getitem
-
     # Mock scan_storage.find_scan_by_ID
     mock_scan_data = MagicMock()
     mock_scan_data.data = {

tests/test_bec_monitor_scatter2D.py

@@ -1,17 +1,14 @@
 # pylint: disable=missing-module-docstring, missing-function-docstring
 from collections import defaultdict
+from unittest.mock import MagicMock
 
 import pytest
-from unittest.mock import MagicMock
 from qtpy import QtGui
 
 from bec_widgets.widgets import BECMonitor2DScatter
 
 CONFIG_DEFAULT = {
-    "plot_settings": {
-        "colormap": "CET-L4",
-        "num_columns": 1,
-    },
+    "plot_settings": {"colormap": "CET-L4", "num_columns": 1},
     "waveform2D": [
         {
             "plot_name": "Waveform 2D Scatter (1)",
@@ -37,10 +34,7 @@ CONFIG_DEFAULT = {
 }
 
 CONFIG_ONE_PLOT = {
-    "plot_settings": {
-        "colormap": "CET-L4",
-        "num_columns": 1,
-    },
+    "plot_settings": {"colormap": "CET-L4", "num_columns": 1},
     "waveform2D": [
         {
             "plot_name": "Waveform 2D Scatter (1)",
@@ -51,7 +45,7 @@ CONFIG_ONE_PLOT = {
                 "y": [{"name": "aptry", "entry": "aptry"}],
                 "z": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
             },
-        },
+        }
     ],
 }
 
@@ -65,13 +59,7 @@ def monitor_2Dscatter(qtbot):
     yield widget
 
 
-@pytest.mark.parametrize(
-    "config, number_of_plots",
-    [
-        (CONFIG_DEFAULT, 2),
-        (CONFIG_ONE_PLOT, 1),
-    ],
-)
+@pytest.mark.parametrize("config, number_of_plots", [(CONFIG_DEFAULT, 2), (CONFIG_ONE_PLOT, 1)])
 def test_initialization(monitor_2Dscatter, config, number_of_plots):
     config_load = config
     monitor_2Dscatter.on_config_update(config_load)
@@ -81,13 +69,7 @@ def test_initialization(monitor_2Dscatter, config, number_of_plots):
     assert len(monitor_2Dscatter.plot_data) == number_of_plots
 
 
-@pytest.mark.parametrize(
-    "config ",
-    [
-        (CONFIG_DEFAULT),
-        (CONFIG_ONE_PLOT),
-    ],
-)
+@pytest.mark.parametrize("config ", [(CONFIG_DEFAULT), (CONFIG_ONE_PLOT)])
 def test_database_initialization(monitor_2Dscatter, config):
     monitor_2Dscatter.on_config_update(config)
     # Check if the database is a defaultdict
@@ -108,13 +90,7 @@ def test_database_initialization(monitor_2Dscatter, config):
                 assert isinstance(monitor_2Dscatter.database[plot_name][axis][signal_name], list)
 
 
-@pytest.mark.parametrize(
-    "config ",
-    [
-        (CONFIG_DEFAULT),
-        (CONFIG_ONE_PLOT),
-    ],
-)
+@pytest.mark.parametrize("config ", [(CONFIG_DEFAULT), (CONFIG_ONE_PLOT)])
 def test_ui_initialization(monitor_2Dscatter, config):
     monitor_2Dscatter.on_config_update(config)
     assert len(monitor_2Dscatter.plots) == len(config["waveform2D"])
@@ -133,7 +109,7 @@ def simulate_scan_data(monitor, x_value, y_value, z_value):
             "samy": {"samy": {"value": y_value}},
             "gauss_bpm": {"gauss_bpm": {"value": z_value}},
         },
-        "scanID": 1,
+        "scan_id": 1,
     }
     monitor.on_scan_segment(msg, {})
 

tests/test_bec_motor_map.py

@@ -0,0 +1,125 @@
+import pytest
+
+from bec_widgets.widgets import BECMotorMap
+from bec_widgets.widgets.plots.motor_map import MotorMapConfig
+from bec_widgets.widgets.plots.waveform1d import Signal, SignalData
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture(scope="function")
+def bec_motor_map(qtbot, mocked_client):
+    widget = BECMotorMap(client=mocked_client, gui_id="BECMotorMap_test")
+    # qtbot.addWidget(widget)
+    # qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_motor_map_init(bec_motor_map):
+    default_config = MotorMapConfig(widget_class="BECMotorMap", gui_id="BECMotorMap_test")
+
+    assert bec_motor_map.config == default_config
+
+
+def test_motor_map_change_motors(bec_motor_map):
+    bec_motor_map.change_motors("samx", "samy")
+
+    assert bec_motor_map.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
+    assert bec_motor_map.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
+
+
+def test_motor_map_get_limits(bec_motor_map):
+    expected_limits = {
+        "samx": [-10, 10],
+        "samy": [-5, 5],
+    }
+
+    for motor_name, expected_limit in expected_limits.items():
+        actual_limit = bec_motor_map._get_motor_limit(motor_name)
+        assert actual_limit == expected_limit
+
+
+def test_motor_map_get_init_position(bec_motor_map):
+    bec_motor_map.set_precision(2)
+
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    expected_positions = {
+        ("samx", "samx"): motor_map_dev["samx"].read()["samx"]["value"],
+        ("samy", "samy"): motor_map_dev["samy"].read()["samy"]["value"],
+        ("aptrx", "aptrx"): motor_map_dev["aptrx"].read()["aptrx"]["value"],
+        ("aptry", "aptry"): motor_map_dev["aptry"].read()["aptry"]["value"],
+    }
+
+    for (motor_name, entry), expected_position in expected_positions.items():
+        actual_position = bec_motor_map._get_motor_init_position(motor_name, entry, 2)
+        assert actual_position == expected_position
+
+
+def test_motor_movement_updates_position_and_database(bec_motor_map):
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+
+    bec_motor_map.change_motors("samx", "samy")
+
+    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+
+    # Simulate motor movement for 'samx' only
+    new_position_samx = 4.0
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+
+    init_positions["samx"].append(new_position_samx)
+    init_positions["samy"].append(init_positions["samy"][-1])
+    # Verify database update for 'samx'
+    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+
+    # Verify 'samy' retains its last known position
+    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+
+
+def test_scatter_plot_rendering(bec_motor_map):
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+
+    bec_motor_map.change_motors("samx", "samy")
+
+    # Simulate motor movement for 'samx' only
+    new_position_samx = 4.0
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+    bec_motor_map._update_plot()
+
+    # Get the scatter plot item
+    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+
+    # Check the scatter plot item properties
+    assert len(scatter_plot_item.data) > 0, "Scatter plot data is empty"
+    x_data = scatter_plot_item.data["x"]
+    y_data = scatter_plot_item.data["y"]
+    assert x_data[-1] == new_position_samx, "Scatter plot X data not updated correctly"
+    assert (
+        y_data[-1] == init_positions["samy"][-1]
+    ), "Scatter plot Y data should retain last known position"
+
+
+def test_plot_visualization_consistency(bec_motor_map):
+    bec_motor_map.change_motors("samx", "samy")
+    # Simulate updating the plot with new data
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": 5}}})
+    bec_motor_map.on_device_readback({"signals": {"samy": {"value": 9}}})
+    bec_motor_map._update_plot()
+
+    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+
+    # Check if the scatter plot reflects the new data correctly
+    assert (
+        scatter_plot_item.data["x"][-1] == 5 and scatter_plot_item.data["y"][-1] == 9
+    ), "Plot not updated correctly with new data"