bec-server 4.2.1__tar.gz → 4.3.1__tar.gz

{bec_server-4.2.1 → bec_server-4.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec-server
-Version: 4.2.1
+Version: 4.3.1
 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-4.2.1 → bec_server-4.3.1}/bec_server/actors/worker.py

@@ -1,14 +1,12 @@
 import importlib
 import os
-from contextlib import redirect_stdout
 from inspect import isclass
 
 from bec_lib.client import BECClient
-from bec_lib.logger import LogLevel, bec_logger
+from bec_lib.logger import bec_logger
 from bec_lib.messages import ProcedureWorkerStatus
-from bec_lib.redis_connector import RedisConnector
 from bec_server.actors.actor import ActorBase
-from bec_server.procedures.oop_worker_base import RedisOutputDiverter, get_env, push_status, setup
+from bec_server.procedures.oop_worker_base import get_env, push_status, setup
 from bec_server.procedures.subprocess_worker import SubProcessWorker
 
 logger = bec_logger.logger
@@ -53,20 +51,12 @@ def get_actor_env():
 def main():
     env, helper, client, conn = setup(get_env())
     actor_env = get_actor_env()
-    logger_connector = RedisConnector(env["redis_server"])
-    output_diverter = RedisOutputDiverter(logger_connector, env["queue"])
-    with redirect_stdout(output_diverter):
-        logger.add(
-            output_diverter,
-            level=LogLevel.SUCCESS,
-            format=bec_logger.formatting(is_container=True),
-            filter=bec_logger.filter(),
-        )
-        logger.success(f"Starting ActorProcedureWorker with env: {actor_env}")
+    # The parent SubProcessWorker streams stdout and stderr to Redis.
+    logger.success(f"Starting ActorProcedureWorker with env: {actor_env}")
     push_status(conn, env["queue"], ProcedureWorkerStatus.IDLE)
     actor_procedure(bec=client, **actor_env)
+    push_status(conn, env["queue"], ProcedureWorkerStatus.FINISHED)
     conn.shutdown()
-    logger_connector.shutdown()
 
 
 if __name__ == "__main__":

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/procedures/container_utils.py

@@ -220,7 +220,7 @@ class PodmanCliUtils(_PodmanUtilsBase):
         _name_arg = ["--replace", "--name", container_name] if container_name else []
         if container_name:
             # in case of incomplete cleanup previously, even with --replace it is possible to get an error
-            _run_and_capture_error("podman", "rm", "-f", container_name)
+            _run_and_capture_error("podman", "rm", "-f", "--ignore", container_name)
         return (
             _run_and_capture_error(
                 "podman",
@@ -251,7 +251,8 @@ class PodmanCliUtils(_PodmanUtilsBase):
 
     def logs(self, id: str) -> list[str]:
         try:
-            return _run_and_capture_error("podman", "logs", id).stderr.decode().splitlines()
+            output = _run_and_capture_error("podman", "logs", id)
+            return (output.stdout + output.stderr).decode(errors="replace").splitlines()
         except ProcedureWorkerError as e:
             logger.error(e)
             return [f"No logs found for container {id}\n"]

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/procedures/container_worker.py

@@ -28,7 +28,7 @@ class ContainerProcedureWorker(OutOfProcessWorkerBase):
             self._backend.build_worker_image()
         self._container_id = self._backend.run(
             image_tag,
-            self._worker_environment(),
+            self._worker_environment() | self._additional_env,
             [
                 {
                     "source": str(PROCEDURE.CONTAINER.DEPLOYMENT_PATH),

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/procedures/manager.py

@@ -46,6 +46,8 @@ class RedisCredentials(TypedDict):
 
 def _log_on_end(future: Future):
     """Use as a callback so that future is always done."""
+    if future.cancelled():
+        return
     if e := future.exception():
         logger.error(f"Worker failed with exception: {e}")
     else:
@@ -141,9 +143,9 @@ class ProcedureManagerBase(ABC, Generic[_ReqMsgT, _ExecMsgT]):
         with self.lock:
             if exec_msg.queue not in self._active_workers:
                 new_worker = self.executor.submit(self.spawn, queue=queue, env=env)
+                self._active_workers[queue] = {"worker": None, "future": new_worker}
                 new_worker.add_done_callback(_log_on_end)
                 new_worker.add_done_callback(self._cleanup_worker_function(queue))
-                self._active_workers[queue] = {"worker": None, "future": new_worker}
         return exec_msg
 
     def spawn(self, queue: str, env: dict[str, str]):
@@ -156,11 +158,20 @@ class ProcedureManagerBase(ABC, Generic[_ReqMsgT, _ExecMsgT]):
             raise WorkerAlreadyExists(
                 f"Queue {queue} already has an active worker in {self._active_workers}!"
             )
-        with self._worker_cls(self._server, queue, PROCEDURE.WORKER.QUEUE_TIMEOUT_S, env) as worker:
-            with self.lock:
-                self._active_workers[queue]["worker"] = worker
-            worker.work()
-            self._logs.extend(worker.logs())
+        worker = None
+        try:
+            with self._worker_cls(
+                self._server, queue, PROCEDURE.WORKER.QUEUE_TIMEOUT_S, env
+            ) as worker:
+                with self.lock:
+                    self._active_workers[queue]["worker"] = worker
+                worker.work()
+        finally:
+            if worker is not None:
+                logs = worker.logs()
+                self._logs.extend(logs)
+                for line in logs:
+                    logger.info(f"Procedure worker '{queue}': {line}")
 
     def _wait_for_all_futures(self):
         with self.lock:
@@ -195,7 +206,7 @@ class ProcedureManagerBase(ABC, Generic[_ReqMsgT, _ExecMsgT]):
         self._conn.shutdown()
         # cancel futures by hand to give us the opportunity to detach them from redis if they have started
         with self.lock:
-            for entry in self._active_workers.values():
+            for entry in list(self._active_workers.values()):
                 cancelled = entry["future"].cancel()
                 if not cancelled:
                     # unblock any waiting workers and let them shutdown
@@ -292,6 +303,20 @@ class ProcedureManager(ProcedureManagerBase[ProcedureRequestMessage, ProcedureEx
         def cleanup_worker(fut):
             with self.lock:
                 logger.debug(f"cleaning up worker {fut} for queue {queue}...")
+                error = None if fut.cancelled() else fut.exception()
+                if error is not None:
+                    pending = self._helper.get.exec_queue(queue)
+                    running = [
+                        msg for msg in self._helper.get.running_procedures() if msg.queue == queue
+                    ]
+                    self._helper.move.execution_queue_to_unhandled(queue)
+                    for msg in running:
+                        self._helper.push.unhandled(queue, msg)
+                    for msg in pending + running:
+                        self._helper.status_update(
+                            msg.execution_id, "Finished", error=f"Procedure worker failed: {error}"
+                        )
+                    self._helper.notify_watchers(queue, "unhandled")
                 self._helper.remove_from_active.by_queue(queue)
                 self._run_callbacks(queue)
                 self._helper.notify_watchers(queue, "execution")

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/procedures/oop_worker_base.py

@@ -59,7 +59,7 @@ class OutOfProcessWorkerBase(ProcedureWorker):
         minimum necessary, or things which are only necessary for the functioning of the worker,
         and other information should be passed through redis"""
         return {
-            "redis_server": f"{PROCEDURE.REDIS_HOST}:{self._conn.port}",
+            "redis_server": self._redis_server,
             "queue": self._queue,
             "timeout_s": str(self._lifetime_s),
         }
@@ -70,7 +70,7 @@ class OutOfProcessWorkerBase(ProcedureWorker):
         # on timeout check if container is still running
 
         status_update = None
-        while not self._ending_or_ended():
+        while not self._aborted.is_set():
             status_update = self._conn.blocking_list_pop(
                 MessageEndpoints.procedure_worker_status_update(self._queue), timeout_s=0.2
             )
@@ -82,10 +82,17 @@ class OutOfProcessWorkerBase(ProcedureWorker):
                 logger.info(
                     f"Procedure worker '{self._queue}' status update: {status_update.status.name}"
                 )
+            elif self._ending_or_ended():
+                break
             # TODO: we probably do want to handle some kind of timeout here but we don't know how
             # long a running procedure should actually take - it could theoretically be infinite
         if self.status != ProcedureWorkerStatus.FINISHED:
             self.status = ProcedureWorkerStatus.DEAD
+            if not self._aborted.is_set():
+                logs = "\n".join(self.logs())
+                raise ProcedureWorkerError(
+                    f"Procedure worker for queue {self._queue} exited unexpectedly.\n{logs}"
+                )
 
 
 def _default_env() -> dict[str, str]:
@@ -230,10 +237,21 @@ def _main(
             helper.remove_from_active.by_exec_id(item.execution_id)
 
 
-def main():
-    """Replaces the main contents of Worker.work() - should be called as the container entrypoint or command"""
+def main(*, output_to_redis: bool = True) -> None:
+    """Run the worker entry point.
+
+    Args:
+        output_to_redis (bool): Redirect procedure output to Redis in this process. Subprocess
+            workers disable this because their parent streams both output pipes instead.
+    """
 
     env, helper, client, conn = setup(get_env())
+    if not output_to_redis:
+        try:
+            _main(env, helper, client, conn)
+        finally:
+            conn.shutdown()
+        return
     logger_connector = RedisConnector(env["redis_server"])
     output_diverter = RedisOutputDiverter(logger_connector, env["queue"])
     with redirect_stdout(output_diverter):

bec_server-4.3.1/bec_server/procedures/subprocess_worker.py

@@ -0,0 +1,144 @@
+import os
+import subprocess
+import sys
+from codecs import getincrementaldecoder
+from collections import deque
+from signal import SIGINT
+from threading import Lock, Thread
+
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from bec_lib.messages import RawMessage
+from bec_lib.redis_connector import RedisConnector
+from bec_server.procedures.constants import ProcedureWorkerError
+from bec_server.procedures.oop_worker_base import PROCESS_TIMEOUT, OutOfProcessWorkerBase, main
+
+logger = bec_logger.logger
+
+
+class SubProcessWorker(OutOfProcessWorkerBase):
+    """Run procedures in a subprocess, streaming stdout and stderr to Redis."""
+
+    WORKER_FILE = __file__
+
+    def _setup_execution_environment(self):
+        # Match the UTF-8 decoder in the parent even when the host uses another encoding.
+        env: dict[str, str] = {"PYTHONIOENCODING": "utf-8"} | self._worker_environment()
+        first_start = not hasattr(self, "_output_logs")
+        self._output_error_logged = False
+        if first_start:
+            self._output_logs: deque[str] = deque(maxlen=10000)
+            self._output_lock = Lock()
+        output_conn = RedisConnector(
+            [self._redis_server], name=f"ProcedureWorker-{self._queue} output"
+        )
+        try:
+            if first_start:
+                output_conn.delete(MessageEndpoints.procedure_logs(self._queue))
+            self._process = subprocess.Popen(
+                [sys.executable, "-u", self.WORKER_FILE],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=0,
+                env=os.environ | env | self._additional_env,
+            )
+        except BaseException:
+            output_conn.shutdown()
+            raise
+        self._output_thread = Thread(
+            target=self._capture_output,
+            args=(self._process, output_conn),
+            name=f"ProcedureWorker-{self._queue} output",
+            daemon=True,
+        )
+        self._output_thread.start()
+        logger.success("Subprocess Procedure Worker started.")
+        self._ending: bool = False
+
+    def _capture_output(self, process: subprocess.Popen, conn: RedisConnector) -> None:
+        """Drain both streams even if Redis rejects an output write."""
+        decoder = getincrementaldecoder("utf-8")(errors="replace")
+        try:
+            with process.stdout as output:
+                while True:
+                    chunk = output.read(4096)
+                    if not chunk:
+                        self._publish_output(decoder.decode(b"", final=True), conn)
+                        break
+                    self._publish_output(decoder.decode(chunk), conn)
+        finally:
+            conn.shutdown()
+
+    def _publish_output(self, text: str, conn: RedisConnector) -> None:
+        if not text:
+            return
+        with self._output_lock:
+            self._output_logs.append(text)
+        try:
+            conn.xadd(
+                MessageEndpoints.procedure_logs(self._queue),
+                {"data": RawMessage(data=text)},
+                max_size=10000,
+                expire=3600,
+            )
+        except Exception as exc:
+            if not self._output_error_logged:
+                logger.error(f"Failed to publish procedure output: {exc}")
+            self._output_error_logged = True
+
+    def _join_output(self) -> None:
+        if hasattr(self, "_output_thread"):
+            self._output_thread.join(timeout=PROCESS_TIMEOUT)
+            if self._output_thread.is_alive():
+                raise ProcedureWorkerError("Subprocess output reader failed to stop")
+
+    def _cleanup_execution_environment(self) -> None:
+        try:
+            super()._cleanup_execution_environment()
+        finally:
+            self._join_output()
+
+    def _ending_or_ended(self):
+        return self._ending or (self._process.poll() is not None)
+
+    def _kill_process(self):
+        """Attempts to end the process gently by first sending SIGINT, which is handled by the BECIpythonClient to
+        gracefully shut down, and end any scans it has started. See:
+        bec_ipython_client/main.py#L125 and bec_ipython_client/signals.py#L103
+        If the process fails to shut down naturally, kills it unceremoniously. This will leave the running scan running
+        on the ScanServer.
+        """
+        if not self._ending_or_ended():
+            self._ending = True
+            self._process.send_signal(SIGINT)
+            self._process.send_signal(SIGINT)
+            try:
+                self._process.wait(PROCESS_TIMEOUT)
+            except subprocess.TimeoutExpired:
+                logger.warning(
+                    f"Subprocess Procedure Worker failed to exit in {PROCESS_TIMEOUT} s. Killing."
+                )
+                self._process.kill()
+                self._process.wait(PROCESS_TIMEOUT)
+
+    def abort_execution(self, execution_id: str):
+        """Abort the execution with the given id. Has no effect if the given ID is not the current job"""
+        if execution_id == self._current_execution_id:
+            self._kill_process()
+            self._helper.remove_from_active.by_exec_id(execution_id)
+            logger.info(
+                f"Aborting execution {execution_id}, restarting worker for queue: {self._queue}"
+            )
+            self._join_output()
+            self._setup_execution_environment()
+
+    def logs(self) -> list[str]:
+        """Return captured output without consuming it or waiting for a live process."""
+        if self._process.poll() is not None:
+            self._join_output()
+        with self._output_lock:
+            return "".join(self._output_logs).splitlines()
+
+
+if __name__ == "__main__":
+    main(output_to_redis=False)

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/procedures/worker_base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from threading import Event
+from threading import Event, Lock
 
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
@@ -52,15 +52,27 @@ class ProcedureWorker(ABC):
         self.client_id = self._conn.client_id()
         self._current_execution_id: str | None = None
         self._aborted = Event()
+        self._shutdown_lock = Lock()
 
-        self._setup_execution_environment()
+        try:
+            self._setup_execution_environment()
+        except BaseException:
+            self._conn.shutdown()
+            raise
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self._conn.shutdown()
-        self._kill_process()
+        self._cleanup_execution_environment()
+
+    def _cleanup_execution_environment(self) -> None:
+        """Serialize abort and context teardown, always stopping the external process."""
+        with self._shutdown_lock:
+            try:
+                self._conn.shutdown()
+            finally:
+                self._kill_process()
 
     @abstractmethod
     def _kill_process(self):
@@ -86,8 +98,7 @@ class ProcedureWorker(ABC):
     def abort(self):
         """Abort the entire worker"""
         self._aborted.set()
-        self._conn.shutdown()
-        self._kill_process()
+        self._cleanup_execution_environment()
 
     @abstractmethod
     def abort_execution(self, execution_id: str):

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scan_manager.py

@@ -164,6 +164,10 @@ class ScanManager:
                 "doc": scan_doc_with_modifiers(scan_cls),
                 "signature": scan_signature_with_modifiers(scan_cls),
                 "gui_visibility": gui_visibility,
+                "position_preview": getattr(scan_cls, "position_preview", None),
+                "position_preview_parameter_mapping": getattr(
+                    scan_cls, "position_preview_parameter_mapping", {}
+                ),
             }
 
     @staticmethod

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/fermat_scan.py

@@ -20,11 +20,11 @@ from typing import Annotated
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.logger import bec_logger
+from bec_lib.position_generators import Direction
 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
 
@@ -59,6 +59,16 @@ class FermatSpiralScan(ScanBase):
         ],
     }
 
+    position_preview = "bec_lib.position_generators.fermat_spiral_pos"
+    position_preview_parameter_mapping = {
+        "m1_start": "start_motor1",
+        "m1_stop": "stop_motor1",
+        "m2_start": "start_motor2",
+        "m2_stop": "stop_motor2",
+        "step": "step",
+        "spiral_type": "spiral_type",
+    }
+
     def __init__(
         self,
         motor1: DeviceBase,

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/grid_scan.py

@@ -20,10 +20,10 @@ from typing import Annotated
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.logger import bec_logger
 from bec_lib.scan_args import DefaultArgType, ScanArgument
-from bec_server.scan_server.scans import position_generators
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType, bundle_args
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -69,6 +69,9 @@ class GridScan(ScanBase):
         ],
     }
 
+    position_preview = "bec_lib.position_generators.nd_grid_positions"
+    position_preview_parameter_mapping = {"axes": {"bundle": [1, 2, 3]}, "snaked": "snaked"}
+
     def __init__(
         self,
         *args,

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/hexagonal_scan.py

@@ -20,9 +20,9 @@ from typing import Annotated
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.scan_args import DefaultArgType, ScanArgument
-from bec_server.scan_server.scans import position_generators
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -53,6 +53,15 @@ class HexagonalScan(ScanBase):
         ],
     }
 
+    position_preview = "bec_lib.position_generators.hex_grid_2d"
+    position_preview_parameter_mapping = {
+        "axes": [
+            ["start_motor1", "stop_motor1", "step_motor1"],
+            ["start_motor2", "stop_motor2", "step_motor2"],
+        ],
+        "snaked": "snaked",
+    }
+
     def __init__(
         self,
         motor1: DeviceBase,

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/line_scan.py

@@ -20,9 +20,9 @@ from typing import Annotated
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.scan_args import DefaultArgType, ScanArgument
-from bec_server.scan_server.scans import position_generators
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType, bundle_args
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -64,6 +64,9 @@ class LineScan(ScanBase):
         ],
     }
 
+    position_preview = "bec_lib.position_generators.line_scan_positions"
+    position_preview_parameter_mapping = {"axes": {"bundle": [1, 2]}, "steps": "steps"}
+
     def __init__(
         self,
         *args,

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/log_scan.py

@@ -20,9 +20,9 @@ from typing import Annotated
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.scan_args import DefaultArgType, ScanArgument
-from bec_server.scan_server.scans import position_generators
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType, bundle_args
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -64,6 +64,9 @@ class LogScan(ScanBase):
         ],
     }
 
+    position_preview = "bec_lib.position_generators.log_scan_positions"
+    position_preview_parameter_mapping = {"axes": {"bundle": [1, 2]}, "steps": "steps"}
+
     def __init__(
         self,
         *args,

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/multi_region_grid_scan.py

@@ -18,9 +18,9 @@ from __future__ import annotations
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.scan_args import DefaultArgType
-from bec_server.scan_server.scans import position_generators
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -44,6 +44,9 @@ class MultiRegionGridScan(ScanBase):
         "Acquisition Parameters": ["exp_time", "settling_time", "burst_at_each_point"],
     }
 
+    position_preview = "bec_lib.position_generators.multi_region_grid_positions"
+    position_preview_parameter_mapping = {"regions": "regions", "snaked": "snaked"}
+
     def __init__(
         self,
         motor1: DeviceBase,

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/multi_region_line_scan.py

@@ -18,9 +18,9 @@ from __future__ import annotations
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.scan_args import DefaultArgType
-from bec_server.scan_server.scans import position_generators
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -50,6 +50,9 @@ class MultiRegionLineScan(ScanBase):
         ],
     }
 
+    position_preview = "bec_lib.position_generators.multi_region_line_positions"
+    position_preview_parameter_mapping = {"regions": "regions"}
+
     def __init__(
         self,
         motor: DeviceBase,

bec_server-4.3.1/bec_server/scan_server/scans/path_optimization.py

@@ -0,0 +1,5 @@
+"""Compatibility imports; use :mod:`bec_lib.path_optimization` for new code."""
+
+from bec_lib.path_optimization import PathOptimizerMixin, PathQualityStats
+
+__all__ = ["PathOptimizerMixin", "PathQualityStats"]

bec_server-4.3.1/bec_server/scan_server/scans/position_generators.py

@@ -0,0 +1,33 @@
+"""Compatibility imports; use :mod:`bec_lib.position_generators` for new code."""
+
+from bec_lib.position_generators import (
+    Direction,
+    fermat_spiral_pos,
+    get_round_roi_scan_positions,
+    hex_grid_2d,
+    line_scan_positions,
+    log_scan_positions,
+    multi_region_grid_positions,
+    multi_region_line_positions,
+    nd_grid_positions,
+    oscillating_positions,
+    rotate_points,
+    round_scan_positions,
+    spiral_positions,
+)
+
+__all__ = [
+    "Direction",
+    "rotate_points",
+    "spiral_positions",
+    "line_scan_positions",
+    "log_scan_positions",
+    "oscillating_positions",
+    "multi_region_line_positions",
+    "multi_region_grid_positions",
+    "nd_grid_positions",
+    "fermat_spiral_pos",
+    "round_scan_positions",
+    "get_round_roi_scan_positions",
+    "hex_grid_2d",
+]

{bec_server-4.2.1 → bec_server-4.3.1}/bec_server/scan_server/scans/round_roi_scan.py

@@ -20,9 +20,9 @@ from typing import Annotated
 
 import numpy as np
 
+from bec_lib import position_generators
 from bec_lib.device import DeviceBase
 from bec_lib.scan_args import DefaultArgType, ScanArgument
-from bec_server.scan_server.scans import position_generators
 from bec_server.scan_server.scans.scan_base import ScanBase, ScanType
 from bec_server.scan_server.scans.scan_modifier import scan_hook
 
@@ -54,6 +54,18 @@ class RoundROIScan(ScanBase):
         ],
     }
 
+    position_preview = "bec_lib.position_generators.get_round_roi_scan_positions"
+    position_preview_parameter_mapping = {
+        "motor_1_start": "start_motor_1",
+        "motor_1_stop": "stop_motor_1",
+        "motor_2_start": "start_motor_2",
+        "motor_2_stop": "stop_motor_2",
+        "radial_step": "shell_spacing",
+        "points_in_first_shell": "pos_in_first_ring",
+        "center_1": "center_1",
+        "center_2": "center_2",
+    }
+
     def __init__(
         self,
         motor_1: DeviceBase,