bec-server 3.150.0__tar.gz → 3.150.2__tar.gz

{bec_server-3.150.0 → bec_server-3.150.2}/PKG-INFO

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

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/data_processing/cli/launch.py

@@ -8,7 +8,6 @@ import bec_server.data_processing as data_processing
 from bec_lib.bec_service import parse_cmdline_args
 from bec_lib.logger import bec_logger
 from bec_lib.redis_connector import RedisConnector
-from bec_server.data_processing.image_analysis_service import ImageAnalysisService
 from bec_server.data_processing.lmfit1d_service import LmfitService1D
 
 logger = bec_logger.logger
@@ -22,9 +21,7 @@ def main():
     _, _, config = parse_cmdline_args()
 
     bec_server = data_processing.dap_server.DAPServer(
-        config=config,
-        connector_cls=RedisConnector,
-        provided_services=[LmfitService1D, ImageAnalysisService],
+        config=config, connector_cls=RedisConnector, provided_services=[LmfitService1D]
     )
     bec_server.start()
 

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/device_server/device_server.py

@@ -429,7 +429,6 @@ class DeviceServer(BECService):
                     dev.obj.stop()
                 except Exception as exc:  # pylint: disable=broad-except
                     content = traceback.format_exc()
-                    logger.error(content)
                     error_info = messages.ErrorInfo(
                         error_message=content,
                         compact_error_message=traceback.format_exc(limit=0),

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/file_writer/file_writer_manager.py

@@ -424,7 +424,7 @@ class FileWriterManager(BECService):
         # pylint: disable=unused-variable
         except Exception as exc:
             content = traceback.format_exc()
-            logger.error(f"Failed to write to file {file_path}. Error: {content}")
+            logger.error(f"Failed to write to file {file_path}.")
             error_info = messages.ErrorInfo(
                 error_message=content,
                 compact_error_message=traceback.format_exc(limit=0),

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/scan_server/beamline_state_manager.py

@@ -6,7 +6,6 @@ from bec_lib import bl_states, messages
 from bec_lib.alarm_handler import Alarms
 from bec_lib.devicemanager import DeviceManagerBase
 from bec_lib.endpoints import MessageEndpoints
-from bec_lib.logger import bec_logger
 from bec_lib.messages import ErrorInfo
 from bec_lib.redis_connector import RedisConnector
 
@@ -32,7 +31,6 @@ class BeamlineStateManager:
             self.update_states(msg)
         except Exception as exc:
             content = traceback.format_exc()
-            bec_logger.logger.error(content)
             info = ErrorInfo(
                 exception_type=type(exc).__name__,
                 error_message=content,

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/scan_server/direct_scan_worker.py

@@ -187,7 +187,6 @@ class DirectScanWorker:
             exc (Exception): The exception that was raised, which will be included in the alarm information.
         """
 
-        logger.error(content)
         error_info = messages.ErrorInfo(
             error_message=content,
             compact_error_message=traceback.format_exc(limit=0),

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/scan_server/scan_manager.py

@@ -115,9 +115,6 @@ class ScanManager:
         for name, scan_cls in members:
 
             if not scan_cls.scan_name.isidentifier():
-                logger.error(
-                    f"Invalid scan_name '{scan_cls.scan_name}' for scan class {name}. scan_name must be a valid Python identifier, that is, it can only contain letters, numbers, and underscores, and must not start with a number. Skipping."
-                )
                 self.parent.connector.raise_alarm(
                     severity=Alarms.WARNING,
                     info=ErrorInfo(
@@ -130,7 +127,6 @@ class ScanManager:
                 continue
 
             if scan_cls.scan_name in self.available_scans:
-                logger.error(f"{scan_cls.scan_name} already exists. Skipping.")
                 self.parent.connector.raise_alarm(
                     severity=Alarms.WARNING,
                     info=ErrorInfo(

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/scan_server/scan_queue.py

@@ -90,7 +90,6 @@ class QueueManager:
         # pylint: disable=broad-except
         except Exception as exc:
             content = traceback.format_exc()
-            logger.error(content)
             error_info = messages.ErrorInfo(
                 error_message=content,
                 compact_error_message=traceback.format_exc(limit=0),

{bec_server-3.150.0 → bec_server-3.150.2}/bec_server/scan_server/scan_worker.py

@@ -80,7 +80,6 @@ class ScanWorker(threading.Thread):
         # pylint: disable=broad-except
         except Exception as exc:
             content = traceback.format_exc()
-            logger.error(content)
             error_info = messages.ErrorInfo(
                 error_message=content,
                 compact_error_message=traceback.format_exc(limit=0),

{bec_server-3.150.0 → bec_server-3.150.2}/pyproject.toml

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

bec_server-3.150.0/bec_server/data_processing/image_analysis_service.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import TYPE_CHECKING
-
-import numpy as np
-from scipy.ndimage import center_of_mass
-from typeguard import typechecked
-
-from bec_lib.device_monitor_plugin import DeviceMonitorPlugin
-from bec_lib.logger import bec_logger
-from bec_server.data_processing.dap_service import DAPError, DAPServiceBase
-
-if TYPE_CHECKING:
-    from bec_lib.client import BECClient
-    from bec_lib.device import DeviceBase
-    from bec_lib.scan_items import ScanItem
-
-logger = bec_logger.logger
-
-
-class ReturnType(str, Enum):
-    """The possible return data types for the image analysis service."""
-
-    MIN = "min"
-    MAX = "max"
-    MEAN = "mean"
-    MEDIAN = "median"
-    STD = "std"
-    CENTER_OF_MASS = "center_of_mass"
-
-
-class ImageAnalysisService(DAPServiceBase):
-    """Service for image analysis."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.device_monitor_plugin = DeviceMonitorPlugin(self.client.connector)
-        self.data = []
-        self.device = None
-        self.return_type = None
-
-    def configure(self, scan_item=None, device=None, images=None, return_type=None, **kwargs):
-        # TODO Add type hints for np.ndarray and list[np.ndarray] do not work yet in the signature_serializer
-        # This will be addressed in a different MR, issue is created #395
-        # scan_item: ScanItem | str = None,
-        # device: DeviceBase | str = None,
-        # images: np.ndarray | list[np.ndarray] | None = None,
-        # **kwargs,
-        # ):
-        """Configure the image analysis service. Either provide a scan item and a device which
-        has a 2D monitor active, or provide the images directly. If no data is found for the input
-        the service will return an empty stream output.
-
-        Args:
-            scan_item: Scan Item to consider for the analysis
-            device: The device for the 2D monitor data
-            images: Alternatively, you can provide the images directly
-            return_type: The type of data to return, can be "min", "max", "mean", "median", "std", "center_of_mass"
-        """
-        if return_type is None:
-            return_type = ReturnType.CENTER_OF_MASS
-        else:
-            return_type = ReturnType(return_type)
-        self.return_type = return_type
-        # If images are provided, use them
-        if images is not None:
-            if isinstance(images, np.ndarray):
-                self.data = [images]
-            elif isinstance(images, list) and all(
-                isinstance(image, np.ndarray) for image in images
-            ):
-                self.data = images
-            return
-        # Else if scan item is provided, get the images
-        if device is None or scan_item is None:
-            raise DAPError(
-                f"Either provide a device: {device} and scan_id {scan_item} or images {images}"
-            )
-        self.device = str(device)
-        self.data = self.get_images_for_scan_item(scan_id=scan_item)
-
-    def get_images_for_scan_item(self, scan_id: str) -> list[np.ndarray]:
-        """Get the data for the scan item."""
-        self.scan_id = scan_id
-        data = self.device_monitor_plugin.get_data_for_scan(device=self.device, scan=self.scan_id)
-        if len(data) == 0:
-            logger.warning(f"No data found for scan {scan_id} and device {self.device}")
-        return data
-
-    @typechecked
-    def compute_statistics(self, images: list[np.ndarray]) -> dict:
-        """Compute the image analysis.
-
-        Args:
-            images: The images to analyze
-
-        Returns:
-            dict: The statistics
-        """
-        stacked_images = np.stack(images, axis=0)
-        stats = {
-            "min": stacked_images.min(axis=(1, 2)),
-            "max": stacked_images.max(axis=(1, 2)),
-            "mean": stacked_images.mean(axis=(1, 2)),
-            "median": np.median(stacked_images, axis=(1, 2)),
-            "std": np.std(stacked_images, axis=(1, 2)),
-            "center_of_mass": np.array([center_of_mass(img) for img in images]),
-        }
-        return stats
-
-    def process(self):
-        """Process the image analysis."""
-        stats = self.compute_statistics(self.data)
-        metadata = {"scan_id": self.scan_id, "device": self.device, "stats": stats}
-        stream_output = self._compute_stream_output(stats)
-        return stream_output, metadata
-
-    @classmethod
-    def get_user_friendly_name(cls, *args, **kwargs):
-        """
-        Get the user friendly name for the service.
-        """
-        return "image_analysis"
-
-    def _compute_stream_output(self, stats: dict) -> dict:
-        """
-        Compute the stream output from the statistics.
-
-        Args:
-            stats (dict): Statistics
-
-        Returns:
-            dict: Stream output
-        """
-        if self.return_type == ReturnType.CENTER_OF_MASS:
-            return {"x": stats["center_of_mass"].T[0], "y": stats["center_of_mass"].T[1]}
-        else:
-            ret_type = self.return_type.value
-            values = stats[ret_type]
-            length = len(values)
-            return {"x": np.linspace(0, length - 1, length), "y": values}

bec_server-3.150.0/tests/tests_data_processing/test_image_analysis_service.py

@@ -1,105 +0,0 @@
-from unittest import mock
-
-import numpy as np
-import pytest
-
-from bec_server.data_processing.image_analysis_service import (
-    DAPError,
-    ImageAnalysisService,
-    ReturnType,
-)
-
-
-@pytest.fixture
-def image_analysis_service():
-    yield ImageAnalysisService(client=mock.MagicMock())
-
-
-def test_image_analysis_configure(image_analysis_service):
-    """Test the configure method of the image analysis service."""
-
-    # Test with scan item
-    scan_item = mock.MagicMock()
-    dummy_data = [np.linspace(0, 1, 100) for _ in range(10)]
-    scan_item.return_value = "mock_scan_id"
-    with mock.patch.object(
-        image_analysis_service, "get_images_for_scan_item", return_value=dummy_data
-    ):
-        image_analysis_service.configure(scan_item=scan_item, device="eiger")
-        assert image_analysis_service.data == dummy_data
-        assert image_analysis_service.device == "eiger"
-        assert image_analysis_service.return_type == ReturnType.CENTER_OF_MASS
-        # Reset the imageanalysisService
-        image_analysis_service.data = []
-        image_analysis_service.device = None
-        image_analysis_service.return_type = None
-
-        # Missing device argument
-        with pytest.raises(DAPError):
-            image_analysis_service.configure(scan_item=scan_item)
-
-        # Reset the imageanalysisService
-        image_analysis_service.data = []
-        image_analysis_service.device = None
-        image_analysis_service.return_type = None
-
-        # Missing scan item
-        with pytest.raises(DAPError):
-            image_analysis_service.configure(device="eiger")
-
-        # Reset the imageanalysisService
-        image_analysis_service.data = []
-        image_analysis_service.device = None
-        image_analysis_service.return_type = None
-
-        # Test with images
-        image_analysis_service.configure(images=dummy_data)
-        assert image_analysis_service.data == dummy_data
-
-
-def test_get_images_for_scan_item(image_analysis_service):
-    """Test the get_images_for_scan_item method of the image analysis service."""
-
-    dummy_data = [np.linspace(0, 1, 100) for _ in range(10)]
-
-    with mock.patch.object(
-        image_analysis_service.device_monitor_plugin,
-        "get_data_for_scan",
-        side_effect=[dummy_data, []],
-    ):
-        # Test with existing scan id
-        scan_id = "mock_scan_id"
-        image_analysis_service.scan_id = scan_id
-        data = image_analysis_service.get_images_for_scan_item(scan_id)
-        assert data == dummy_data
-        assert image_analysis_service.scan_id == scan_id
-
-        # Test with empty return
-        data = image_analysis_service.get_images_for_scan_item(scan_id)
-        assert data == []
-
-
-def test_compute_statistics(image_analysis_service):
-    """Test the compute_statistics method of the image analysis service."""
-
-    dummy_data = [np.zeros((10, 10)), np.ones((10, 10))]
-    stats = image_analysis_service.compute_statistics(dummy_data)
-    assert stats["min"].shape == (2,)
-    assert stats["max"].shape == (2,)
-    assert np.isclose(stats["mean"], np.array([0, 1])).all()
-    assert np.isclose(stats["min"], np.array([0, 1])).all()
-
-
-def test_get_stream_output(image_analysis_service):
-    """Test the get_stream_output method of the image analysis service."""
-    dummy_data = [np.ones((10, 10)), np.ones((10, 10))]
-    stats = image_analysis_service.compute_statistics(dummy_data)
-    image_analysis_service.return_type = ReturnType.MIN
-    stream_output = image_analysis_service._compute_stream_output(stats)
-    assert np.isclose(stream_output["x"], np.linspace(0, 1, 2)).all()
-    assert (stream_output["y"] == stats["min"]).all()
-    # Test center of Mass
-    image_analysis_service.return_type = ReturnType.CENTER_OF_MASS
-    stream_output = image_analysis_service._compute_stream_output(stats)
-    assert (stream_output["x"] == stats["center_of_mass"].T[0]).all()
-    assert (stream_output["y"] == stats["center_of_mass"].T[1]).all()