bec-server 3.148.0__tar.gz → 3.149.0__tar.gz

{bec_server-3.148.0 → bec_server-3.149.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec-server
-Version: 3.148.0
+Version: 3.149.0
 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.148.0 → bec_server-3.149.0}/bec_server/scan_server/path_optimization.py

@@ -1,9 +1,15 @@
+from time import perf_counter
 from typing import Literal
 
 import numpy as np
 from pydantic import BaseModel
 from scipy.spatial import cKDTree  # type: ignore
 
+from bec_lib.logger import bec_logger
+from bec_server.scan_server.scans.position_generators import Direction
+
+logger = bec_logger.logger
+
 
 class PathQualityStats(BaseModel):
     max_jump: float
@@ -15,6 +21,19 @@ class PathQualityStats(BaseModel):
 
 
 class PathOptimizerMixin:
+    def _log_optimization_result(
+        self, method: str, original_path: np.ndarray, optimized_path: np.ndarray, duration_s: float
+    ) -> None:
+        original_length = self.get_path_length(original_path)
+        optimized_length = self.get_path_length(optimized_path)
+        reduced_by = original_length - optimized_length
+        reduction_pct = (reduced_by / original_length * 100) if original_length > 0 else 0.0
+
+        logger.info(
+            f"Path optimizer ({method}) reduced path length from {original_length:.4f} to {optimized_length:.4f} "
+            f"({reduced_by:.4f} reduction, {reduction_pct:.2f}% decrease) in {duration_s:.4f} seconds."
+        )
+
     def get_radius(self, pos: np.ndarray) -> np.ndarray:
         """
         Calculate the radial distance from the origin for each position
@@ -31,9 +50,10 @@ class PathOptimizerMixin:
         self,
         positions: np.ndarray,
         corridor_size: float | None = None,
-        sort_axis: int = 1,
+        fast_axis: Literal[0, 1] = 0,
         num_iterations: int = 1,
-        preferred_direction: int | None = None,
+        first_corridor_direction: Direction | Literal[-1, 1] = Direction.ASCENDING,
+        snaked: bool = True,
         corridor_estimation: Literal["density", "median_distance"] = "median_distance",
     ):
         """
@@ -45,12 +65,15 @@ class PathOptimizerMixin:
         Args:
             positions (np.ndarray): Array of positions
             corridor_size (float, optional): Width of each corridor. Defaults to None (auto-estimated).
-            sort_axis (int, optional): Axis along which to create corridors (0 or 1). Defaults to 1.
+            fast_axis (Literal[0, 1], optional): Axis traversed within each corridor (0 or 1). Defaults to 0.
             num_iterations (int, optional): Number of corridor sizes to try. Defaults to 1.
-            preferred_direction (int | None, optional): Preferred direction for the primary axis (1 or -1).
-                If None, alternates direction for each corridor.
-            corridor_estimation (str, optional): Method for estimating corridor size if not provided.
-                Options are "density" or "median_distance". Defaults to "density".
+            first_corridor_direction (Direction | Literal[-1, 1], optional): Traversal direction of the first
+                corridor along the fast axis. Positive means ascending, negative means
+                descending. Defaults to Direction.ASCENDING.
+            snaked (bool, optional): If True, alternate the traversal direction between
+                successive corridors. If False, keep the same direction in every corridor.
+            corridor_estimation (Literal["density", "median_distance"], optional): Method for estimating corridor size if not provided.
+                Options are "density" or "median_distance". Defaults to "median_distance".
 
         Returns:
             np.ndarray: Optimized positions
@@ -58,6 +81,9 @@ class PathOptimizerMixin:
         if positions.ndim != 2 or positions.shape[1] < 2:
             return positions
 
+        start_time = perf_counter()
+        original_path = positions
+
         # Estimate corridor size if needed
         if corridor_size is None:
             if corridor_estimation == "density":
@@ -70,8 +96,14 @@ class PathOptimizerMixin:
                     'Choose "density" or "median_distance".'
                 )
 
-        axis_vals = positions[:, sort_axis]
-        sec_axis = int(not sort_axis)
+        if not isinstance(first_corridor_direction, Direction):
+            first_corridor_direction = Direction(first_corridor_direction)
+
+        if fast_axis not in (0, 1):
+            raise ValueError("fast_axis must be 0 or 1")
+
+        slow_axis = int(not fast_axis)
+        axis_vals = positions[:, slow_axis]
 
         best_length = np.inf
         best_path = positions
@@ -97,17 +129,15 @@ class PathOptimizerMixin:
                 if block.size == 0:
                     continue
 
-                # Sort within corridor along secondary axis
-                block = block[np.argsort(positions[block, sec_axis])]
+                # Sort within corridor along fast axis
+                block = block[np.argsort(positions[block, fast_axis])]
 
                 # Direction handling
-                if preferred_direction is not None:
-                    if preferred_direction < 0:
-                        block = block[::-1]
-                else:
-                    # Alternate direction between corridors
-                    if step % 2 == 0:
-                        block = block[::-1]
+                direction = first_corridor_direction
+                if snaked and step % 2 == 1:
+                    direction = Direction(-direction)
+                if direction == Direction.DESCENDING:
+                    block = block[::-1]
 
                 index_sorted.append(block)
 
@@ -122,6 +152,9 @@ class PathOptimizerMixin:
                 best_length = path_length
                 best_path = path
 
+        self._log_optimization_result(
+            "corridor", original_path, best_path, perf_counter() - start_time
+        )
         return best_path
 
     def _corridor_estimate_density(self, positions: np.ndarray) -> float:
@@ -182,6 +215,9 @@ class PathOptimizerMixin:
         if pos.ndim != 2 or pos.shape[1] < 2 or len(pos) < 2:
             return pos
 
+        start_time = perf_counter()
+        original_path = pos
+
         # Calculate radii once
         radii = self.get_radius(pos)
         max_rad = np.max(radii)
@@ -227,7 +263,9 @@ class PathOptimizerMixin:
                     best_score = score
                     best_path = optimized_path
 
-        return best_path if best_path is not None else pos
+        result = best_path if best_path is not None else pos
+        self._log_optimization_result("shell", original_path, result, perf_counter() - start_time)
+        return result
 
     def _estimate_shell_width(self, pos: np.ndarray, radii: np.ndarray, max_rad: float) -> float:
         """
@@ -413,6 +451,9 @@ class PathOptimizerMixin:
         if len(positions) <= 1:
             return positions
 
+        start_time = perf_counter()
+        original_path = positions
+
         n_points = len(positions)
 
         # Use a copy to avoid modifying the original
@@ -455,4 +496,8 @@ class PathOptimizerMixin:
             path.append(current_pos)
             remaining_indices.remove(original_idx)
 
-        return np.array(path)
+        result = np.array(path)
+        self._log_optimization_result(
+            "nearest_neighbor", original_path, result, perf_counter() - start_time
+        )
+        return result

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scan_assembler.py

@@ -97,13 +97,15 @@ class ScanAssembler:
         )
         return scan_instance
 
-    def assemble_direct_scan(self, msg: messages.ScanQueueMessage, scan_id: str) -> ScanBaseV4:
+    def assemble_direct_scan(
+        self, msg: messages.ScanQueueMessage, scan_id: str | None
+    ) -> ScanBaseV4:
         """Assemble the device instructions for a given ScanQueueMessage.
         This will be achieved by calling the specified class (must be a derived class of ScanBaseV4)
 
         Args:
             msg (messages.ScanQueueMessage): scan queue message for which the instruction should be assembled
-            scan_id (str): scan id of the scan
+            scan_id (str | None): scan id of the scan
 
         Raises:
             ScanAbortion: Raised if the scan initialization fails.

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scan_queue.py

@@ -1594,7 +1594,9 @@ class DirectInstructionQueueItem:
         Args:
             msg (ScanQueueMessage): the scan queue message containing the scan information
         """
-        scan = self.assembler.assemble_direct_scan(msg, scan_id=self._scan_id)
+        scan_cls = self.assembler.scan_manager.scan_dict[msg.scan_type]
+        scan_id = self._scan_id if getattr(scan_cls, "is_scan", True) else None
+        scan = self.assembler.assemble_direct_scan(msg, scan_id=scan_id)
         self.scans.append(scan)
         self.scan_msgs.append(msg)
 
@@ -1718,7 +1720,7 @@ class DirectInstructionQueueItem:
     def _set_scan_as_active(self, scan: ScanBase_v4):
         """set a given scan as the active scan"""
         self.active_scan = scan
-        if scan.scan_info.scan_number is None:
+        if scan.scan_info.scan_number is None and scan.is_scan:
             with self.parent.queue_manager._lock:
                 self.parent.queue_manager.parent.scan_number += 1
                 if not self.scan_msgs[self.scans.index(scan)].metadata.get("dataset_id_on_hold"):

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scans/fermat_scan.py

@@ -24,6 +24,7 @@ from bec_lib.device import DeviceBase
 from bec_lib.logger import bec_logger
 from bec_lib.scan_args import DefaultArgType, ScanArgument, Units
 from bec_server.scan_server.scans import position_generators
+from bec_server.scan_server.scans.position_generators import Direction
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -173,6 +174,18 @@ class FermatSpiralScan(ScanBase):
             self.start_positions = self.components.get_start_positions(self.motors)
             self.positions += self.start_positions
 
+        if self.optim_trajectory:
+            self.positions = self.components.optimize_trajectory(
+                self.positions,
+                optimization_type=self.optim_trajectory,
+                fast_axis=0,
+                first_direction=(
+                    Direction.ASCENDING
+                    if self.motor1_start_stop[1] > self.motor1_start_stop[0]
+                    else Direction.DESCENDING
+                ),
+            )
+
         self.components.check_limits(self.motors, self.positions)
 
         self.update_scan_info(

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scans/legacy_scans.py

@@ -19,7 +19,7 @@ from bec_lib.logger import bec_logger
 from bec_server.scan_server.instruction_handler import InstructionHandler
 
 from ..errors import LimitError, ScanAbortion
-from ..path_optimization import PathOptimizerMixin
+from ..path_optimization import Direction, PathOptimizerMixin
 from ..scan_stubs import ScanStubs
 
 logger = bec_logger.logger
@@ -519,26 +519,14 @@ class ScanBase(RequestBase, PathOptimizerMixin):
         if not self.optim_trajectory:
             return
 
-        # Get preferred directions from scan parameters if available
-        preferred_directions = getattr(self, "preferred_directions", None)
-
         if self.optim_trajectory == "corridor":
-            # For corridor optimization, we use the primary axis preferred direction
-            if preferred_directions and len(preferred_directions) > 0:
-                primary_axis = getattr(self, "sort_axis", 1)
-                preferred_direction = (
-                    preferred_directions[primary_axis]
-                    if len(preferred_directions) > primary_axis
-                    else None
-                )
-                self.positions = self.optimize_corridor(
-                    self.positions,
-                    num_iterations=5,
-                    sort_axis=primary_axis,
-                    preferred_direction=preferred_direction,
-                )
-            else:
-                self.positions = self.optimize_corridor(self.positions, num_iterations=5)
+            # Corridor traversal direction follows the first pass along the axis within each corridor.
+            self.positions = self.optimize_corridor(
+                self.positions,
+                num_iterations=5,
+                fast_axis=getattr(self, "fast_axis", 0),
+                first_corridor_direction=getattr(self, "first_direction", 1),
+            )
             return
 
         if self.optim_trajectory == "shell":
@@ -1102,6 +1090,9 @@ class FermatSpiralScan(ScanBase):
         self.stop_motor2 = stop_motor2
         self.step = step
         self.spiral_type = spiral_type
+        self.first_direction = (
+            Direction.ASCENDING if self.stop_motor1 > self.start_motor1 else Direction.DESCENDING
+        )
 
     def update_scan_motors(self):
         self.scan_motors = [self.motor1, self.motor2]

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scans/position_generators.py

@@ -1,10 +1,16 @@
 from __future__ import annotations
 
+import enum
 from collections.abc import Iterator, Sequence
 
 import numpy as np
 
 
+class Direction(int, enum.Enum):
+    ASCENDING = 1
+    DESCENDING = -1
+
+
 def rotate_points(
     points: np.ndarray, angle: float, center: tuple[float, float] | None = None
 ) -> np.ndarray:

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scans/scan_actions.py

@@ -153,15 +153,7 @@ class ScanActions:
 
         # We support str and DeviceBase inputs as well as lists of those.
         # We convert them to a list of device names for easier processing.
-        if isinstance(device, list):
-            device_names = []
-            for dev in device:
-                if isinstance(dev, DeviceBase):
-                    device_names.append(dev.name)
-                else:
-                    device_names.append(dev)
-        else:
-            device_names = [device.name if isinstance(device, DeviceBase) else device]
+        device_names = self._normalize_device_names(device)
         if len(device_names) == 1:
             device_names = device_names[0]
         status = self._create_status(name=status_name or f"stage_{device_names}")
@@ -290,7 +282,7 @@ class ScanActions:
 
         status = self._create_status(is_container=True, name="set")
         for dev, val in zip(devices, values, strict=False):
-            device_name = dev.name if isinstance(dev, DeviceBase) else dev
+            device_name = self._normalize_device_name(dev)
             sub_status = self._create_status(name=f"set_{device_name}")
             instr = messages.DeviceInstructionMessage(
                 device=device_name,
@@ -320,7 +312,7 @@ class ScanActions:
         Returns:
             ScanStubStatus: status object to track the kickoff process
         """
-        device_name = device.name if isinstance(device, DeviceBase) else device
+        device_name = self._normalize_device_name(device)
         status = self._create_status(name=f"kickoff_{device_name}")
 
         instr = messages.DeviceInstructionMessage(
@@ -347,7 +339,7 @@ class ScanActions:
         Returns:
             ScanStubStatus: status object to track the completion process
         """
-        device_name = device.name if isinstance(device, DeviceBase) else device
+        device_name = self._normalize_device_name(device)
         status = self._create_status(name=f"complete_{device_name}")
 
         instr = messages.DeviceInstructionMessage(
@@ -620,7 +612,7 @@ class ScanActions:
         Returns:
             ScanStubStatus: status object to track the unstaging process
         """
-        device_name = device.name if isinstance(device, DeviceBase) else device
+        device_name = self._normalize_device_name(device)
         status = self._create_status(name=f"unstage_{device_name}")
 
         instr = messages.DeviceInstructionMessage(
@@ -687,7 +679,7 @@ class ScanActions:
             request_id (str, optional): request ID to associate the readback instruction with. If None, the scan's RID will be used. Defaults to None.
         """
         request_id = request_id or self._scan.scan_info.metadata["RID"]
-        device_names = [dev.name if isinstance(dev, DeviceBase) else dev for dev in devices]
+        device_names = self._normalize_device_names(devices)
         scan_report_instruction = {
             "readback": {"RID": request_id, "devices": device_names, "start": start, "end": stop}
         }
@@ -705,10 +697,7 @@ class ScanActions:
         Args:
             device (str | DeviceBase): name of the device or DeviceBase instance to report
         """
-        if isinstance(device, DeviceBase):
-            device_name = device.name
-        else:
-            device_name = device
+        device_name = self._normalize_device_name(device)
         scan_report_instruction = {"device_progress": [device_name]}
         self._scan.scan_info.scan_report_instructions.append(scan_report_instruction)
         if self._update_queue_info_callback is not None:
@@ -762,10 +751,7 @@ class ScanActions:
             devices = [devices]
 
         for device in devices:
-            if isinstance(device, DeviceBase):
-                device_name = device.name
-            else:
-                device_name = device
+            device_name = self._normalize_device_name(device)
             self._scan.scan_info.readout_priority_modification[priority].append(device_name)
 
     def close_scan(self):
@@ -834,13 +820,15 @@ class ScanActions:
         """
         if isinstance(device, list):
             for dev in device:
-                device_name = dev.name if isinstance(dev, DeviceBase) else dev
+                device_name = self._normalize_device_name(dev)
                 self._devices_with_required_response.add(device_name)
         else:
-            device_name = device.name if isinstance(device, DeviceBase) else device
+            device_name = self._normalize_device_name(device)
             self._devices_with_required_response.add(device_name)
 
-    def rpc_call(self, device: str, func_name: str, *args, **kwargs) -> Any | ScanStubStatus:
+    def rpc_call(
+        self, device: str | DeviceBase, func_name: str, *args, **kwargs
+    ) -> Any | ScanStubStatus:
         """
         Make an RPC call to a device. This will call the given function on the device with the given arguments.
         The device server will execute the function and return the result in the instruction response.
@@ -864,26 +852,49 @@ class ScanActions:
             Any | ScanStubStatus: The result of the RPC call or a ScanStubStatus object if the result is a status object.
 
         """
-        status = self._create_status(name=f"rpc_{device}_{func_name}")
         rpc_id = str(uuid.uuid4())
+        status = self.rpc_call_no_wait(device, func_name, rpc_id, *args, **kwargs)
+        status.wait(resolve_on_known_type=True)
+        if status._result_is_status:
+            return status
+        return status.result
+
+    def rpc_call_no_wait(
+        self, device: str | DeviceBase, func_name: str, rpc_id: str, *args, **kwargs
+    ) -> ScanStubStatus:
+        """
+        Make an RPC call to a device without waiting for the result. This will call the given function on the device with the given arguments.
+        The device server will execute the function and return the result in the instruction response.
+        This method is a low-level interface to call arbitrary functions on the device server and should be used with caution.
+
+        Args:
+            device (str | DeviceBase): name of the device or device instance to call the function on
+            func_name (str): name of the function to call on the device
+            rpc_id (str): unique identifier for the RPC call, used to match the response with the request
+            *args: positional arguments to pass to the function
+            **kwargs: keyword arguments to pass to the function
+
+        Returns:
+            ScanStubStatus: A ScanStubStatus object that can be used to wait for the result of the RPC call.
+        """
+        device_name = self._normalize_device_name(device)
+        status = self._create_status(name=f"rpc_{device_name}_{func_name}")
+
         parameter = {
-            "device": device,
+            "device": device_name,
             "func": func_name,
             "rpc_id": rpc_id,
             "args": args,
             "kwargs": kwargs,
         }
         msg = messages.DeviceInstructionMessage(
-            device=device,
+            device=device_name,
             action="rpc",
             parameter=parameter,
             metadata={"device_instr_id": status._device_instr_id},
         )
         self._send(msg)
-        status.wait(resolve_on_known_type=True)
-        if status._result_is_status:
-            return status
-        return status.result
+        return status
 
     def send_client_info(self, message: str):
         """
@@ -959,12 +970,37 @@ class ScanActions:
                 metadata[key] = value + self._metadata_suffix
         return metadata
 
-    def _normalize_device_names(
-        self, devices: str | DeviceBase | list[str | DeviceBase]
-    ) -> list[str]:
+    @staticmethod
+    def _normalize_device_name(device: str | DeviceBase) -> str:
+        """
+        Normalize the device name to a string. If the device is a DeviceBase instance, return its dotted name.
+        We use the dotted name because it is uniquely identifying a device in the device tree, even for
+        sub-devices.
+
+        Args:
+            device (str | DeviceBase): device name or DeviceBase instance
+
+        Returns:
+            str: normalized device name
+        """
+        if isinstance(device, DeviceBase):
+            return getattr(device, "dotted_name", None) or device.name
+        return device
+
+    @staticmethod
+    def _normalize_device_names(devices: str | DeviceBase | list[str | DeviceBase]) -> list[str]:
+        """
+        Normalize a list of device names to a list of strings. If the devices are DeviceBase instances, return their dotted names.
+
+        Args:
+            devices (str | DeviceBase | list[str | DeviceBase]): device name(s) or DeviceBase instance(s)
+
+        Returns:
+            list[str]: list of normalized device names
+        """
         if not isinstance(devices, list):
             devices = [devices]
-        return [dev.name if isinstance(dev, DeviceBase) else dev for dev in devices]
+        return [ScanActions._normalize_device_name(dev) for dev in devices]
 
     def _get_monitored_device_names(self) -> list[str]:
         monitored_devices = [

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scans/scan_base.py

@@ -54,7 +54,7 @@ class ScanInfo(BaseModel):
 
     # General scan information
     scan_name: Annotated[str, Field(description="Name of the scan type, e.g. 'grid_scan'")]
-    scan_id: Annotated[str, Field(description="Unique identifier for the scan")]
+    scan_id: Annotated[str | None, Field(description="Unique identifier for the scan")] = None
     scan_type: Annotated[
         ScanType | None,
         Field(
@@ -167,7 +167,7 @@ class ScanBase(ABC):
 
     def __init__(
         self,
-        scan_id: str,
+        scan_id: str | None,
         redis_connector: RedisConnector,
         device_manager: DeviceManager,
         instruction_handler: InstructionHandler,

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/scans/scan_components.py

@@ -8,6 +8,7 @@ import numpy as np
 from bec_lib.device import DeviceBase
 from bec_server.scan_server.errors import LimitError
 from bec_server.scan_server.path_optimization import PathOptimizerMixin
+from bec_server.scan_server.scans.position_generators import Direction
 
 if TYPE_CHECKING:
     from bec_lib.devicemanager import DeviceContainer
@@ -160,49 +161,43 @@ class ScanComponents:
         self,
         positions: np.ndarray,
         optimization_type: Literal["corridor", "shell", "nearest"] = "corridor",
-        primary_axis: int = 1,
-        preferred_directions: list[int] | None = None,
+        fast_axis: Literal[0, 1] = 0,
+        first_direction: Literal[-1, 1] | Direction = Direction.ASCENDING,
+        snaked: bool = True,
         corridor_size: float | None = None,
         num_iterations: int = 5,
     ) -> np.ndarray:
         """
         Optimize the trajectory of the scan by reordering the positions. This can help to minimize the movement time of the motors.
+
+        Important note: The optimization is only done for 2D scans. For higher-dimensional scans, the positions are not reordered and simply
+        returned as they are.
+
         The optimization can be done in different ways, depending on the optimization_type parameter:
-            - "corridor": optimize the trajectory in a corridor-like way, where the scan moves back and forth along the primary axis. This is typically a good choice for grid scans. If preferred_directions are provided, the optimizer will try to optimize the trajectory in a way that minimizes the movement in the non-preferred direction.
+            - "corridor": optimize the trajectory in a corridor-like way, where the scan progresses between corridors along the slow axis and traverses each corridor along the fast axis. This is typically a good choice for grid scans. If first_direction is provided, it sets the traversal direction of the first corridor and snaked controls whether later corridors alternate direction, producing a snaked path along the fast axis.
             - "shell": optimize the trajectory in a shell-like way, where the scan moves in a spiral from the outside to the inside. This is typically a good choice for round scans.
             - "nearest": optimize the trajectory by always moving to the nearest next point. This is typically a good choice for random scans.
 
         Args:
             positions (np.ndarray): Array of positions to optimize, shape (num_points, num_motors).
             optimization_type (str, optional): Type of optimization to perform. Defaults to "corridor".
-            primary_axis (int, optional): Primary axis for corridor optimization. Defaults to 1.
-            preferred_directions (list[int] | None, optional): List of preferred directions for the non-primary axes. Each entry should be -1, 0, or 1, indicating the preferred direction of movement along that axis. The length of the list should be equal to the number of non-primary axes. Defaults to None, which means no preferred directions.
+            fast_axis (int, optional): Fast axis for corridor optimization. Defaults to 0.
+            first_direction (Direction | Literal[-1, 1], optional): Traversal direction for the first corridor along the fast axis. Positive means ascending, negative means descending. Defaults to Direction.ASCENDING.
+            snaked (bool, optional): If True, alternate direction between corridors. Defaults to True.
             corridor_size (float | None, optional): Size of the corridor for corridor optimization. Defaults to None, which means the default corridor size will be used.
         Returns:
             np.ndarray: Optimized array of positions, shape (num_points, num_motors).
         """
 
         if optimization_type == "corridor":
-            if preferred_directions is None or len(preferred_directions) == 0:
-                positions = self._path_optimizer.optimize_corridor(
-                    positions,
-                    num_iterations=num_iterations,
-                    corridor_size=corridor_size,
-                    sort_axis=primary_axis,
-                )
-            else:
-                preferred_direction = (
-                    preferred_directions[primary_axis]
-                    if len(preferred_directions) > primary_axis
-                    else None
-                )
-                positions = self._path_optimizer.optimize_corridor(
-                    positions,
-                    num_iterations=num_iterations,
-                    sort_axis=primary_axis,
-                    preferred_direction=preferred_direction,
-                    corridor_size=corridor_size,
-                )
+            positions = self._path_optimizer.optimize_corridor(
+                positions,
+                num_iterations=num_iterations,
+                corridor_size=corridor_size,
+                fast_axis=fast_axis,
+                first_corridor_direction=first_direction,
+                snaked=snaked,
+            )
 
         elif optimization_type == "shell":
             positions = self._path_optimizer.optimize_shell(

{bec_server-3.148.0 → bec_server-3.149.0}/bec_server/scan_server/tests/scan_fixtures.py

@@ -119,6 +119,10 @@ class _MockDevice(DeviceBase):
     def full_name(self):
         return self.name
 
+    @property
+    def dotted_name(self):
+        return self.name
+
     @property
     def limits(self):
         return self._limits
@@ -222,6 +226,10 @@ class MockCustomDevice(DeviceBase):
     def full_name(self):
         return self.name
 
+    @property
+    def dotted_name(self):
+        return self.name
+
     @property
     def limits(self):
         return self._limits

{bec_server-3.148.0 → bec_server-3.149.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec-server"
-version = "3.148.0"
+version = "3.149.0"
 description = "BEC server"
 requires-python = ">=3.11"
 classifiers = [
@@ -135,6 +135,7 @@ Homepage = "https://github.com/bec-project/bec"
 
 
 
+
 
 
 [tool.hatch.build.targets.wheel]