bec-lib 3.150.2__tar.gz → 3.151.1__tar.gz

{bec_lib-3.150.2 → bec_lib-3.151.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_lib
-Version: 3.150.2
+Version: 3.151.1
 Summary: BEC library
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec

{bec_lib-3.150.2 → bec_lib-3.151.1}/bec_lib/bl_state_manager.py

@@ -44,6 +44,26 @@ def build_signature_from_model(model: BaseModel, skip: set[str] | None = None) -
     return Signature(parameters)
 
 
+def _state_class_for_state_type(state_type: str) -> type[bl_states.BeamlineState]:
+    """
+    Resolve and validate a serialized beamline state type.
+
+    The state type identifies the concrete runtime state class that will be
+    started by the scan server.
+    """
+    state_class = getattr(bl_states, state_type, None)
+    if (
+        not inspect.isclass(state_class)
+        or not issubclass(state_class, bl_states.BeamlineState)
+        or inspect.isabstract(state_class)
+    ):
+        raise ValueError(f"State type {state_type!r} is not a concrete beamline state.")
+    if getattr(state_class, "CONFIG_CLASS", None) is None:
+        raise ValueError(f"State type {state_type!r} does not define a config class.")
+
+    return state_class
+
+
 class BeamlineStateGet(TypedDict):
     """
     TypedDict for the return value of the get method of a beamline state client.
@@ -154,10 +174,11 @@ class BeamlineStateManager:
         self, state: messages.BeamlineStateConfig | bl_states.BeamlineStateConfig
     ) -> None:
         if isinstance(state, messages.BeamlineStateConfig):
-            state_class = getattr(bl_states, state.state_type)
+            state_class = _state_class_for_state_type(state.state_type)
             model_cls = state_class.CONFIG_CLASS
             model_instance = model_cls(**state.parameters)
         else:
+            _state_class_for_state_type(state.state_type)
             model_instance = state
         instance = BeamlineStateClientBase(manager=self, state=model_instance)
         setattr(self, state.name, instance)

{bec_lib-3.150.2 → bec_lib-3.151.1}/bec_lib/bl_states.py

@@ -408,33 +408,6 @@ class DeviceBeamlineState(BeamlineState[D], Generic[D]):
         return self.evaluate(msg)
 
 
-class ShutterState(DeviceBeamlineState[DeviceStateConfig]):
-    """
-    A state that checks if the shutter is open.
-
-    Example:
-        shutter_state = DeviceStateConfig(
-            name="shutter_open",
-            device="shutter1",
-        )
-        bec.beamline_states.add(shutter_state)
-    """
-
-    CONFIG_CLASS = DeviceStateConfig
-
-    def evaluate(
-        self, msg: messages.DeviceMessage, *args, **kwargs
-    ) -> messages.BeamlineStateMessage:
-        val = msg.signals.get(self.signal_name, {}).get("value", "").lower()
-        if val == "open":
-            return messages.BeamlineStateMessage(
-                name=self.config.name, status="valid", label="Shutter is open."
-            )
-        return messages.BeamlineStateMessage(
-            name=self.config.name, status="invalid", label="Shutter is closed."
-        )
-
-
 class DeviceWithinLimitsState(DeviceBeamlineState[DeviceWithinLimitsStateConfig]):
     """
     A state that checks if a device signal is within limits.

{bec_lib-3.150.2 → bec_lib-3.151.1}/bec_lib/messages.py

@@ -2093,7 +2093,7 @@ class FeedbackMessage(BECMessage):
 
     Args:
         feedback (str): User feedback
-        rating (int): User rating (1-5)
+        rating (int): User rating (0-5)
         feedback_type (Literal["bug_report", "feature_request", "general_feedback"]): Type of feedback. Defaults to "general_feedback"
         contact (str | None): User contact information, if they want to be contacted regarding their feedback
         realm_id (str | None): Realm ID, if applicable
@@ -2109,7 +2109,7 @@ class FeedbackMessage(BECMessage):
 
     feedback: str
 
-    rating: int = Field(ge=1, le=5)
+    rating: int = Field(ge=0, le=5)
     feedback_type: Literal["bug_report", "feature_request", "general_feedback"] = "general_feedback"
     contact: str | None = None
     realm_id: str | None = None

{bec_lib-3.150.2 → bec_lib-3.151.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_lib"
-version = "3.150.2"
+version = "3.151.1"
 description = "BEC library"
 requires-python = ">=3.11"
 classifiers = [

{bec_lib-3.150.2 → bec_lib-3.151.1}/tests/test_beamline_states.py

@@ -44,8 +44,8 @@ class TestHelpers:
 
 class TestConfigModels:
     def test_beamline_state_config_valid_name(self):
-        config = bl_states.BeamlineStateConfig(name="shutter_open")
-        assert config.name == "shutter_open"
+        config = bl_states.BeamlineStateConfig(name="sample_x_limits")
+        assert config.name == "sample_x_limits"
 
     @pytest.mark.parametrize("invalid_name", ["state-name", "class", "add", "remove", "show_all"])
     def test_beamline_state_config_invalid_name(self, invalid_name):
@@ -91,18 +91,25 @@ class TestBeamlineStateBase:
 
 class TestDeviceBeamlineState:
     def test_start_requires_connector(self, dm_with_devices):
-        state = bl_states.ShutterState(
-            name="shutter_open", device="samy", signal="samy", device_manager=dm_with_devices
+        state = bl_states.DeviceWithinLimitsState(
+            name="sample_y_limits",
+            device="samy",
+            signal="samy",
+            low_limit=0.0,
+            high_limit=10.0,
+            device_manager=dm_with_devices,
         )
 
         with pytest.raises(RuntimeError, match="Redis connector is not set"):
             state.start()
 
     def test_start_registers_device_callback(self, connected_connector, dm_with_devices):
-        state = bl_states.ShutterState(
-            name="shutter_open",
+        state = bl_states.DeviceWithinLimitsState(
+            name="sample_x_limits",
             device="samx",
             signal="samx",
+            low_limit=0.0,
+            high_limit=10.0,
             redis_connector=connected_connector,
             device_manager=dm_with_devices,
         )
@@ -115,10 +122,12 @@ class TestDeviceBeamlineState:
         )
 
     def test_stop_unregisters_device_callback(self, connected_connector, dm_with_devices):
-        state = bl_states.ShutterState(
-            name="shutter_open",
+        state = bl_states.DeviceWithinLimitsState(
+            name="sample_x_limits",
             device="samx",
             signal="samx",
+            low_limit=0.0,
+            high_limit=10.0,
             redis_connector=connected_connector,
             device_manager=dm_with_devices,
         )
@@ -134,50 +143,55 @@ class TestDeviceBeamlineState:
     def test_update_device_state_publishes_when_state_changes(
         self, connected_connector, dm_with_devices
     ):
-        state = bl_states.ShutterState(
-            name="shutter_open",
+        state = bl_states.DeviceWithinLimitsState(
+            name="sample_x_limits",
             device="samx",
             signal="samx",
+            low_limit=0.0,
+            high_limit=10.0,
             redis_connector=connected_connector,
             device_manager=dm_with_devices,
         )
 
         msg = messages.DeviceMessage(
-            signals={"samx": {"value": "open", "timestamp": 1.0}}, metadata={"stream": "primary"}
+            signals={"samx": {"value": 5.0, "timestamp": 1.0}}, metadata={"stream": "primary"}
         )
-        msg_obj = MessageObject(value=msg, topic="test")
 
         state._update_device_state(MessageObject(value=msg, topic="test"))
 
         assert state._last_state is not None
         assert state._last_state.status == "valid"
         out = connected_connector.xread(
-            MessageEndpoints.beamline_state("shutter_open"), from_start=True
+            MessageEndpoints.beamline_state("sample_x_limits"), from_start=True
         )
         assert out is not None
         assert out[0]["data"].status == "valid"
 
 
 class TestConcreteStates:
-    def test_shutter_state_open_and_closed(self, connected_connector, dm_with_devices):
-        state = bl_states.ShutterState(
-            name="shutter_open",
+    def test_device_within_limits_state_valid_and_invalid(
+        self, connected_connector, dm_with_devices
+    ):
+        state = bl_states.DeviceWithinLimitsState(
+            name="sample_x_limits",
             device="samx",
             signal="samx",
+            low_limit=0.0,
+            high_limit=10.0,
             redis_connector=connected_connector,
             device_manager=dm_with_devices,
         )
         state.start()
 
-        open_msg = messages.DeviceMessage(
-            signals={"samx": {"value": "OPEN", "timestamp": 1.0}}, metadata={"stream": "primary"}
+        valid_msg = messages.DeviceMessage(
+            signals={"samx": {"value": 5.0, "timestamp": 1.0}}, metadata={"stream": "primary"}
         )
-        closed_msg = messages.DeviceMessage(
-            signals={"samx": {"value": "closed", "timestamp": 2.0}}, metadata={"stream": "primary"}
+        invalid_msg = messages.DeviceMessage(
+            signals={"samx": {"value": 11.0, "timestamp": 2.0}}, metadata={"stream": "primary"}
         )
 
-        assert state.evaluate(open_msg).status == "valid"
-        assert state.evaluate(closed_msg).status == "invalid"
+        assert state.evaluate(valid_msg).status == "valid"
+        assert state.evaluate(invalid_msg).status == "invalid"
 
     def test_device_within_limits_state(self, connected_connector, dm_with_devices):
         state = bl_states.DeviceWithinLimitsState(
@@ -253,9 +267,14 @@ class TestBeamlineStateManager:
 
     def test_manager_loads_existing_state_update_on_init(self, connected_connector):
         config = messages.BeamlineStateConfig(
-            name="shutter_open",
-            state_type="ShutterState",
-            parameters={"name": "shutter_open", "device": "samy"},
+            name="sample_y_limits",
+            state_type="DeviceWithinLimitsState",
+            parameters={
+                "name": "sample_y_limits",
+                "device": "samy",
+                "low_limit": 0.0,
+                "high_limit": 10.0,
+            },
         )
         connected_connector.xadd(
             MessageEndpoints.available_beamline_states(),
@@ -268,22 +287,46 @@ class TestBeamlineStateManager:
         manager = BeamlineStateManager(client)
 
         assert manager.ready is True
-        assert "shutter_open" in manager._states
-        assert isinstance(getattr(manager, "shutter_open"), BeamlineStateClientBase)
+        assert "sample_y_limits" in manager._states
+        assert isinstance(getattr(manager, "sample_y_limits"), BeamlineStateClientBase)
+
+    def test_manager_rejects_abstract_state_type_on_init(self, connected_connector):
+        config = messages.BeamlineStateConfig(
+            name="generic_device_state",
+            state_type="DeviceBeamlineState",
+            parameters={"name": "generic_device_state", "device": "samy"},
+        )
+        connected_connector.xadd(
+            MessageEndpoints.available_beamline_states(),
+            {"data": messages.AvailableBeamlineStatesMessage(states=[config])},
+            max_size=1,
+        )
+        client = mock.MagicMock()
+        client.connector = connected_connector
+
+        with pytest.raises(ValueError, match="not a concrete beamline state"):
+            BeamlineStateManager(client)
 
     def test_on_state_update_creates_client_attribute(self, state_manager):
         config = messages.BeamlineStateConfig(
-            name="shutter_open",
-            state_type="ShutterState",
-            parameters={"name": "shutter_open", "device": "samy"},
+            name="sample_y_limits",
+            state_type="DeviceWithinLimitsState",
+            parameters={
+                "name": "sample_y_limits",
+                "device": "samy",
+                "low_limit": 0.0,
+                "high_limit": 10.0,
+            },
         )
         update = messages.AvailableBeamlineStatesMessage(states=[config])
 
         state_manager._on_state_update({"data": update}, parent=state_manager)
 
-        assert "shutter_open" in state_manager._states
-        assert isinstance(state_manager._states["shutter_open"], bl_states.DeviceStateConfig)
-        assert isinstance(getattr(state_manager, "shutter_open"), BeamlineStateClientBase)
+        assert "sample_y_limits" in state_manager._states
+        assert isinstance(
+            state_manager._states["sample_y_limits"], bl_states.DeviceWithinLimitsStateConfig
+        )
+        assert isinstance(getattr(state_manager, "sample_y_limits"), BeamlineStateClientBase)
 
     def test_update_parameters_from_client_updates_state_and_publishes(self, state_manager):
         config = messages.BeamlineStateConfig(
@@ -338,48 +381,60 @@ class TestBeamlineStateManager:
 
     def test_client_get_returns_unknown_without_status_message(self, state_manager):
         config = messages.BeamlineStateConfig(
-            name="shutter_open",
-            state_type="ShutterState",
-            parameters={"name": "shutter_open", "device": "samy"},
+            name="sample_y_limits",
+            state_type="DeviceWithinLimitsState",
+            parameters={
+                "name": "sample_y_limits",
+                "device": "samy",
+                "low_limit": 0.0,
+                "high_limit": 10.0,
+            },
         )
         update = messages.AvailableBeamlineStatesMessage(states=[config])
         state_manager._on_state_update({"data": update}, parent=state_manager)
 
-        result = state_manager.shutter_open.get()
+        result = state_manager.sample_y_limits.get()
         assert result == {"status": "unknown", "label": "No state information available."}
 
     def test_client_get_returns_latest_status_message(self, state_manager):
         config = messages.BeamlineStateConfig(
-            name="shutter_open",
-            state_type="ShutterState",
-            parameters={"name": "shutter_open", "device": "samy"},
+            name="sample_y_limits",
+            state_type="DeviceWithinLimitsState",
+            parameters={
+                "name": "sample_y_limits",
+                "device": "samy",
+                "low_limit": 0.0,
+                "high_limit": 10.0,
+            },
         )
         update = messages.AvailableBeamlineStatesMessage(states=[config])
         state_manager._on_state_update({"data": update}, parent=state_manager)
 
         state_manager._connector.xadd(
-            MessageEndpoints.beamline_state("shutter_open"),
+            MessageEndpoints.beamline_state("sample_y_limits"),
             {
                 "data": messages.BeamlineStateMessage(
-                    name="shutter_open", status="valid", label="ok"
+                    name="sample_y_limits", status="valid", label="ok"
                 )
             },
             max_size=1,
         )
 
-        result = state_manager.shutter_open.get()
+        result = state_manager.sample_y_limits.get()
         assert result == {"status": "valid", "label": "ok"}
 
     def test_add_waits_for_initial_state_message(self, state_manager):
-        state = bl_states.DeviceStateConfig(name="shutter_open", device="samy")
+        state = bl_states.DeviceWithinLimitsStateConfig(
+            name="sample_y_limits", device="samy", low_limit=0.0, high_limit=10.0
+        )
 
         def publish_initial_state():
             time.sleep(0.05)
             state_manager._connector.xadd(
-                MessageEndpoints.beamline_state("shutter_open"),
+                MessageEndpoints.beamline_state("sample_y_limits"),
                 {
                     "data": messages.BeamlineStateMessage(
-                        name="shutter_open", status="valid", label="ok"
+                        name="sample_y_limits", status="valid", label="ok"
                     )
                 },
                 max_size=1,
@@ -392,37 +447,52 @@ class TestBeamlineStateManager:
         finally:
             publisher.join()
 
-        assert state_manager.shutter_open.get() == {"status": "valid", "label": "ok"}
+        assert state_manager.sample_y_limits.get() == {"status": "valid", "label": "ok"}
+
+    def test_add_rejects_abstract_device_state_config(self, state_manager):
+        state = bl_states.DeviceStateConfig(name="generic_device_state", device="samy")
+
+        with pytest.raises(ValueError, match="not a concrete beamline state"):
+            state_manager.add(state)
 
     def test_add_and_delete_publish_updates(self, state_manager):
-        state = bl_states.DeviceStateConfig(name="shutter_open", device="samy")
+        state = bl_states.DeviceWithinLimitsStateConfig(
+            name="sample_y_limits", device="samy", low_limit=0.0, high_limit=10.0
+        )
 
         with mock.patch.object(state_manager, "_wait_for_initial_state"):
             state_manager.add(state)
-        assert "shutter_open" in state_manager._states
+        assert "sample_y_limits" in state_manager._states
 
-        state_manager.delete("shutter_open")
-        assert "shutter_open" not in state_manager._states
+        state_manager.delete("sample_y_limits")
+        assert "sample_y_limits" not in state_manager._states
 
     def test_client_remove_state(self, state_manager):
         config = messages.BeamlineStateConfig(
-            name="shutter_open",
-            state_type="ShutterState",
-            parameters={"name": "shutter_open", "device": "samy"},
+            name="sample_y_limits",
+            state_type="DeviceWithinLimitsState",
+            parameters={
+                "name": "sample_y_limits",
+                "device": "samy",
+                "low_limit": 0.0,
+                "high_limit": 10.0,
+            },
         )
         update = messages.AvailableBeamlineStatesMessage(states=[config])
         state_manager._on_state_update({"data": update}, parent=state_manager)
 
-        state_manager.shutter_open.remove()
+        state_manager.sample_y_limits.remove()
 
-        assert "shutter_open" not in state_manager._states
+        assert "sample_y_limits" not in state_manager._states
 
     def test_show_all_prints_table(self, state_manager, capsys):
-        state = bl_states.DeviceStateConfig(name="shutter_open", device="samy")
+        state = bl_states.DeviceWithinLimitsStateConfig(
+            name="sample_y_limits", device="samy", low_limit=0.0, high_limit=10.0
+        )
         with mock.patch.object(state_manager, "_wait_for_initial_state"):
             state_manager.add(state)
 
         state_manager.show_all()
 
         captured = capsys.readouterr()
-        assert "shutter_open" in (captured.out + captured.err)
+        assert "sample_y_limits" in (captured.out + captured.err)