bec-lib 4.3.2__tar.gz → 4.4.0__tar.gz

{bec_lib-4.3.2 → bec_lib-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec_lib
-Version: 4.3.2
+Version: 4.4.0
 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-4.3.2 → bec_lib-4.4.0}/bec_lib/devicemanager.py

@@ -598,13 +598,15 @@ class DeviceManagerBase:
                     )
                 if "enabled" in config[dev]:
                     self.devices[dev]._config["enabled"] = config[dev]["enabled"]
-                    if self.devices[dev].enabled:
-                        dev_info_msg = self._get_device_info(dev)
-                        self.devices[dev]._info = dev_info_msg.info
-                        if self._use_proxy_objects:
-                            self.devices[dev]._parse_info()
                     status = "enabled" if self.devices[dev].enabled else "disabled"
                     logger.info(f"Device {dev} has been {status}.")
+                if ("deviceConfig" in config[dev] or "enabled" in config[dev]) and self.devices[
+                    dev
+                ].enabled:
+                    dev_info_msg = self._get_device_info(dev)
+                    self.devices[dev]._info = dev_info_msg.info
+                    if self._use_proxy_objects:
+                        self.devices[dev]._parse_info()
                 if "readOnly" in config[dev]:
                     self.devices[dev]._config["readOnly"] = config[dev]["readOnly"]
                 if "userParameter" in config[dev]:

{bec_lib-4.3.2 → bec_lib-4.4.0}/bec_lib/endpoints.py

@@ -2166,10 +2166,32 @@ class MessageEndpoints:
             message_op=MessageOp.SET_PUBLISH,
         )
 
+    @staticmethod
+    def roi_config_request(device: str, signal: str, username: str) -> EndpointInfo:
+        """Request an ROI configuration change, scoped to the submitting user by Redis ACLs.
+
+        Args:
+            device (str): Name of the device.
+            signal (str): Name of the signal.
+            username (str): Username of the submitting user; subscribers may use ``*``.
+
+        Returns:
+            EndpointInfo: Endpoint for ROI configuration requests.
+        """
+        return EndpointInfo(
+            endpoint=(
+                f"{EndpointType.PERSONAL.value}/{username}/devices/roi_config_request/"
+                f"{device}/{signal}"
+            ),
+            message_type=messages.ROIConfigurationMessage,
+            message_op=MessageOp.SEND,
+        )
+
     @staticmethod
     def roi_config(device: str, signal: str):
         """
-        Endpoint for ROI configuration. This endpoint is used to publish ROI configuration updates using a messages.ROIConfigurationMessage message.
+        Current ROI configuration published by the device after applying a request.
+        Clients send changes to roi_config_request instead.
 
         Args:
             device (str): Name of the device.

{bec_lib-4.3.2 → bec_lib-4.4.0}/bec_lib/messages.py

@@ -56,15 +56,116 @@ class BECStatus(Enum):
     ERROR = -1
 
 
-class ROIConfig(BaseModel):
-    """Configuration for the ROI processing signal."""
+class RectROIConfig(BaseModel):
+    """Axis-aligned rectangle in pixels, with x/y at the top-left corner."""
 
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["rect"] = "rect"
     x: int
     y: int
     width: int
     height: int
 
 
+class RotatedRectROIConfig(BaseModel):
+    """Rectangle in pixels, rotated about its unrotated bounding-box center.
+
+    x/y locate the top-left of the unrotated box. The rotation center is
+    (x + width / 2, y + height / 2). Positive angles are clockwise in degrees
+    in image coordinates (x right, y down).
+    """
+
+    model_config = ConfigDict(extra="forbid", allow_inf_nan=False)
+
+    type: Literal["rotated_rect"] = "rotated_rect"
+    x: float
+    y: float
+    width: float = Field(gt=0)
+    height: float = Field(gt=0)
+    angle: float
+
+
+class CircleROIConfig(BaseModel):
+    """Circle in pixels; x/y locate the top-left of its bounding box.
+
+    Its center is (x + radius, y + radius) in image coordinates (x right, y down).
+    """
+
+    model_config = ConfigDict(extra="forbid", allow_inf_nan=False)
+
+    type: Literal["circle"] = "circle"
+    x: float
+    y: float
+    radius: float = Field(gt=0)
+
+
+class EllipseROIConfig(BaseModel):
+    """Ellipse in pixels, rotated about the center of its unrotated bounding box.
+
+    x/y locate the top-left of that box; width/height are its full dimensions.
+    The rotation center is (x + width / 2, y + height / 2). Positive angles are
+    clockwise in degrees in image coordinates (x right, y down).
+    """
+
+    model_config = ConfigDict(extra="forbid", allow_inf_nan=False)
+
+    type: Literal["ellipse"] = "ellipse"
+    x: float
+    y: float
+    width: float = Field(gt=0)
+    height: float = Field(gt=0)
+    angle: float
+
+
+class PixelMapROIConfig(BaseModel):
+    """Full-image mask indexed as mask[y][x]; True pixels belong to the ROI."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["pixelmap"] = "pixelmap"
+    mask: list[list[bool]]
+
+    @field_validator("mask")
+    @classmethod
+    def validate_mask(cls, mask: list[list[bool]]) -> list[list[bool]]:
+        """Require a nonempty, rectangular two-dimensional mask."""
+        if not mask or not mask[0] or any(len(row) != len(mask[0]) for row in mask):
+            raise ValueError("Pixel map must be a nonempty rectangular 2D mask.")
+        return mask
+
+
+class CustomAnchorROIConfig(BaseModel):
+    """Closed polygon of ordered (x, y) vertices in pixels.
+
+    The closing edge is implicit; the first vertex need not be repeated.
+    """
+
+    model_config = ConfigDict(extra="forbid", allow_inf_nan=False)
+
+    type: Literal["custom_anchor"] = "custom_anchor"
+    vertices: list[tuple[float, float]] = Field(min_length=3)
+
+    @field_validator("vertices")
+    @classmethod
+    def validate_vertices(cls, vertices: list[tuple[float, float]]) -> list[tuple[float, float]]:
+        """Require at least three distinct polygon vertices."""
+        if len(set(vertices)) < 3:
+            raise ValueError("A polygon requires at least three distinct vertices.")
+        return vertices
+
+
+ROIConfiguration = Annotated[
+    RectROIConfig
+    | RotatedRectROIConfig
+    | CircleROIConfig
+    | EllipseROIConfig
+    | PixelMapROIConfig
+    | CustomAnchorROIConfig,
+    Field(discriminator="type"),
+]
+
+
 class ROIAnalysisConfig(BaseModel):
     """Configuration for the ROI analysis operation."""
 
@@ -158,10 +259,18 @@ class ROIConfigurationMessage(BECMessage):
     signal: str
     name: str
     active: bool
-    roi_config: ROIConfig
+    roi_config: ROIConfiguration
     selected_operations: list[str]
     block_while_scanning: bool = True
 
+    @field_validator("roi_config", mode="before")
+    @classmethod
+    def accept_legacy_rectangle(cls, value: Any) -> Any:
+        """Interpret untagged rectangle payloads from older clients as rect ROIs."""
+        if isinstance(value, dict) and "type" not in value:
+            return {"type": "rect", **value}
+        return value
+
 
 class ROIAvailableAnalysisMessage(BECMessage):
     """Message for providing the available ROI analysis operations."""

{bec_lib-4.3.2 → bec_lib-4.4.0}/pyproject.toml

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

{bec_lib-4.3.2 → bec_lib-4.4.0}/tests/test_device_manager.py

@@ -691,3 +691,37 @@ def test_set_rpc_method_context(dm_with_devices):
             assert rpc_method_context.get() == dummy_method
         assert rpc_method_context.get() == another_dummy_method
     assert rpc_method_context.get() is None
+
+
+def test_device_config_update_refreshes_saved_signal_metadata(dm_with_devices):
+    """A file-writer proxy must see changed persistence flags before the next scan."""
+    manager = dm_with_devices
+    device = manager.devices.samx
+    old_info = copy.deepcopy(device._info)
+    old_info.setdefault("signals", {})["roi.result_scalar"] = {
+        "signal_class": "DynamicSignal",
+        "describe": {"signal_info": {"saved": True}},
+    }
+    device._info = old_info
+    new_info = copy.deepcopy(old_info)
+    new_info["signals"]["roi.result_scalar"]["describe"]["signal_info"]["saved"] = False
+    msg = messages.DeviceConfigMessage(
+        action="update", config={"samx": {"deviceConfig": {"save_roi_data": False}}}
+    )
+    with (
+        mock.patch.object(
+            manager,
+            "_get_device_info",
+            return_value=messages.DeviceInfoMessage(device="samx", info=new_info),
+        ) as get_info,
+        mock.patch.object(device, "_parse_info") as parse_info,
+    ):
+        manager.parse_config_message(msg)
+    get_info.assert_called_once_with("samx")
+    parse_info.assert_called_once()
+    roi = next(
+        info
+        for name, component, info in manager.get_bec_signals("DynamicSignal")
+        if name == "samx" and component == "roi.result_scalar"
+    )
+    assert roi["describe"]["signal_info"]["saved"] is False

bec_lib-4.4.0/tests/test_roi_endpoints.py

@@ -0,0 +1,24 @@
+"""ROI clients send requests; devices publish the current configuration."""
+
+from bec_lib.endpoints import MessageEndpoints, MessageOp
+from bec_lib.messages import ROIConfigurationMessage
+
+
+def test_roi_request_and_current_configuration_are_separate():
+    request = MessageEndpoints.roi_config_request("camera", "roi_processing2", "alice")
+    current = MessageEndpoints.roi_config("camera", "roi_processing2")
+    assert request.endpoint != current.endpoint
+    assert request.endpoint == "personal/alice/devices/roi_config_request/camera/roi_processing2"
+    assert (
+        request.endpoint
+        != MessageEndpoints.roi_config_request("camera", "roi_processing2", "bob").endpoint
+    )
+    assert request.message_type is ROIConfigurationMessage
+    assert current.message_type is ROIConfigurationMessage
+    assert request.message_op == MessageOp.SEND
+    assert current.message_op == MessageOp.SET_PUBLISH
+
+
+def test_roi_request_subscription_can_match_all_users():
+    request = MessageEndpoints.roi_config_request("camera", "roi_processing2", "*")
+    assert request.endpoint == "personal/*/devices/roi_config_request/camera/roi_processing2"

bec_lib-4.4.0/tests/test_roi_messages.py

@@ -0,0 +1,93 @@
+"""ROI geometry validation and cross-service serialization compatibility."""
+
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from bec_lib import messages
+from bec_lib.serialization import MsgpackSerialization, json_ext
+
+
+def make_message(config):
+    """Build a configuration message for a geometry payload."""
+    return messages.ROIConfigurationMessage(
+        device="camera",
+        signal="roi",
+        name="sample",
+        active=True,
+        roi_config=config,
+        selected_operations=["sum"],
+    )
+
+
+@pytest.mark.parametrize("serializer", [MsgpackSerialization, json_ext])
+@pytest.mark.parametrize(
+    "config, model",
+    [
+        ({"type": "rect", "x": 1, "y": 2, "width": 3, "height": 4}, messages.RectROIConfig),
+        (
+            {"type": "rotated_rect", "x": 1.5, "y": 2, "width": 3, "height": 4, "angle": 30},
+            messages.RotatedRectROIConfig,
+        ),
+        ({"type": "circle", "x": 1, "y": 2, "radius": 3}, messages.CircleROIConfig),
+        (
+            {"type": "ellipse", "x": 1, "y": 2, "width": 3, "height": 4, "angle": -45},
+            messages.EllipseROIConfig,
+        ),
+        ({"type": "pixelmap", "mask": [[True, False], [False, True]]}, messages.PixelMapROIConfig),
+        (
+            {"type": "custom_anchor", "vertices": [[0, 0], [2, 0], [1, 3]]},
+            messages.CustomAnchorROIConfig,
+        ),
+    ],
+)
+def test_roi_geometries_roundtrip(config, model, serializer):
+    msg = make_message(config)
+    assert isinstance(msg.roi_config, model)
+    restored = serializer.loads(serializer.dumps(msg))
+    assert restored == msg
+    assert isinstance(restored.roi_config, model)
+    assert restored.roi_config.model_dump() == msg.roi_config.model_dump()
+    assert make_message(msg.roi_config).roi_config == msg.roi_config
+
+
+def test_legacy_rectangle_payload_remains_supported():
+    class LegacyROIConfig(BaseModel):
+        """Rectangle schema used before the geometry discriminator was added."""
+
+        x: int
+        y: int
+        width: int
+        height: int
+
+    config = {"x": 1, "y": 2, "width": 3, "height": 4}
+    msg = make_message(config)
+    assert isinstance(msg.roi_config, messages.RectROIConfig)
+    assert msg.roi_config.type == "rect"
+    assert config == {"x": 1, "y": 2, "width": 3, "height": 4}
+    assert make_message(messages.RectROIConfig(**config)) == msg
+    # Older readers ignore the newly added rectangle discriminator.
+    assert LegacyROIConfig.model_validate(msg.roi_config.model_dump()).model_dump() == config
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        {"type": "unknown", "x": 1, "y": 2, "width": 3, "height": 4},
+        {"type": "rect", "x": 1, "y": 2, "width": 3, "height": 4, "angle": 30},
+        {"type": "rotated_rect", "x": 1, "y": 2, "width": 3, "height": 4},
+        {"type": "ellipse", "x": 1, "y": 2, "width": 0, "height": 4, "angle": 0},
+        {"type": "circle", "x": 1, "y": 2, "radius": -1},
+        {"type": "circle", "x": float("nan"), "y": 2, "radius": 1},
+        {"type": "pixelmap", "mask": []},
+        {"type": "pixelmap", "mask": [[]]},
+        {"type": "pixelmap", "mask": [[True], [True, False]]},
+        {"type": "pixelmap", "mask": [[2]]},
+        {"type": "custom_anchor", "vertices": [[0, 0], [1, 1]]},
+        {"type": "custom_anchor", "vertices": [[0, 0], [1, 1], [0, 0]]},
+        {"type": "custom_anchor", "vertices": [[0, 0, 1], [1, 1], [1, 0]]},
+        {"type": "custom_anchor", "vertices": [[0, 0], [1, 1], [float("inf"), 0]]},
+    ],
+)
+def test_invalid_roi_geometry_is_rejected(config):
+    with pytest.raises(ValidationError):
+        make_message(config)