dls-dodal 1.29.4__py3-none-any.whl → 1.30.0__py3-none-any.whl

dodal/devices/util/epics_util.py

@@ -1,5 +1,5 @@
+from collections.abc import Callable, Sequence
 from functools import partial
-from typing import Callable, Sequence
 
 from bluesky.protocols import Movable
 from ophyd import Component, EpicsSignal
@@ -61,9 +61,9 @@ def run_functions_without_blocking(
     # Wrap each function by first checking the previous status and attaching a callback
     # to the next function in the chain
     def wrap_func(
-        old_status: Status, current_func: Callable[[], StatusBase], next_func
+        old_status: Status | None, current_func: Callable[[], StatusBase], next_func
     ):
-        if old_status.exception() is not None:
+        if old_status is not None and old_status.exception() is not None:
             set_global_exception_and_log(old_status)
             return
 
@@ -96,7 +96,7 @@ def run_functions_without_blocking(
     )
 
     # Wrap each function in reverse
-    for num, func in enumerate(list(reversed(functions_to_chain))[1:-1]):
+    for func in list(reversed(functions_to_chain))[1:-1]:
         wrapped_funcs.append(
             partial(
                 wrap_func,
@@ -105,10 +105,8 @@ def run_functions_without_blocking(
             )
         )
 
-    starting_status = Status(done=True, success=True)
-
     # Initiate the chain of functions
-    wrap_func(starting_status, functions_to_chain[0], wrapped_funcs[-1])
+    wrap_func(None, functions_to_chain[0], wrapped_funcs[-1])
     return full_status
 
 

dodal/devices/util/lookup_tables.py

@@ -3,9 +3,8 @@ All the public methods in this module return a lookup table of some kind that
 converts the source value s to a target value t for different values of s.
 """
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from io import StringIO
-from typing import Callable
 
 import aiofiles
 import numpy as np
@@ -36,7 +35,7 @@ async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
 def linear_interpolation_lut(filename: str) -> Callable[[float], float]:
     """Returns a callable that converts values by linear interpolation of lookup table values"""
     LOGGER.info(f"Using lookup table {filename}")
-    s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]))
+    s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
 
     s_values: Sequence
     t_values: Sequence

dodal/devices/util/save_panda.py

@@ -0,0 +1,87 @@
+import argparse
+import os
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import cast
+
+from bluesky.run_engine import RunEngine
+from ophyd_async.core import Device, save_device
+from ophyd_async.panda import phase_sorter
+
+from dodal.beamlines import module_name_for_beamline
+from dodal.utils import make_device
+
+
+def main(argv: list[str]):
+    """CLI Utility to save the panda configuration."""
+    parser = ArgumentParser(description="Save an ophyd_async panda to yaml")
+    parser.add_argument(
+        "--beamline", help="beamline to save from e.g. i03. Defaults to BEAMLINE"
+    )
+    parser.add_argument(
+        "--device-name",
+        help='name of the device. The default is "panda"',
+        default="panda",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action=argparse.BooleanOptionalAction,
+        help="Force overwriting an existing file",
+    )
+    parser.add_argument("output_file", help="output filename")
+
+    # this exit()s with message/help unless args parsed successfully
+    args = parser.parse_args(argv[1:])
+
+    beamline = args.beamline
+    device_name = args.device_name
+    output_file = args.output_file
+    force = args.force
+
+    if beamline:
+        os.environ["BEAMLINE"] = beamline
+    else:
+        beamline = os.environ.get("BEAMLINE", None)
+
+    if not beamline:
+        sys.stderr.write("BEAMLINE not set and --beamline not specified\n")
+        return 1
+
+    if Path(output_file).exists() and not force:
+        sys.stderr.write(
+            f"Output file {output_file} already exists and --force not specified."
+        )
+        return 1
+
+    _save_panda(beamline, device_name, output_file)
+
+    print("Done.")
+    return 0
+
+
+def _save_panda(beamline, device_name, output_file):
+    RE = RunEngine()
+    print("Creating devices...")
+    module_name = module_name_for_beamline(beamline)
+    try:
+        devices = make_device(f"dodal.beamlines.{module_name}", device_name)
+    except Exception as error:
+        sys.stderr.write(f"Couldn't create device {device_name}: {error}\n")
+        sys.exit(1)
+
+    panda = devices[device_name]
+    print(f"Saving to {output_file} from {device_name} on {beamline}...")
+    _save_panda_to_file(RE, cast(Device, panda), output_file)
+
+
+def _save_panda_to_file(RE: RunEngine, panda: Device, path: str):
+    def save_to_file():
+        yield from save_device(panda, path, sorter=phase_sorter)
+
+    RE(save_to_file())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main(sys.argv))

dodal/devices/util/test_utils.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import (
+    callback_on_mock_put,
+    set_mock_value,
+)
+from ophyd_async.epics.motion import Motor
+
+
+def patch_motor(motor: Motor, initial_position=0):
+    set_mock_value(motor.user_setpoint, initial_position)
+    set_mock_value(motor.user_readback, initial_position)
+    set_mock_value(motor.deadband, 0.001)
+    set_mock_value(motor.motor_done_move, 1)
+    set_mock_value(motor.velocity, 3)
+    return callback_on_mock_put(
+        motor.user_setpoint,
+        lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
+    )

dodal/devices/webcam.py

@@ -3,7 +3,7 @@ from pathlib import Path
 import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_rw
+from ophyd_async.core import AsyncStatus, HintedSignal, StandardReadable, soft_signal_rw
 
 from dodal.log import LOGGER
 
@@ -15,7 +15,7 @@ class Webcam(StandardReadable, Triggerable):
         self.directory = soft_signal_rw(str, name="directory")
         self.last_saved_path = soft_signal_rw(str, name="last_saved_path")
 
-        self.set_readable_signals([self.last_saved_path])
+        self.add_readables([self.last_saved_path], wrapper=HintedSignal)
         super().__init__(name=name)
 
     async def _write_image(self, file_path: str):
@@ -24,7 +24,7 @@ class Webcam(StandardReadable, Triggerable):
                 response.raise_for_status()
                 LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
                 async with aiofiles.open(file_path, "wb") as file:
-                    await file.write((await response.read()))
+                    await file.write(await response.read())
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:

dodal/devices/xbpm_feedback.py

@@ -1,9 +1,6 @@
 from enum import Enum
 
-import ophyd
 from bluesky.protocols import Triggerable
-from ophyd import Component, EpicsSignal, EpicsSignalRO
-from ophyd.status import StatusBase, SubscriptionStatus
 from ophyd_async.core import Device, observe_value
 from ophyd_async.core.async_status import AsyncStatus
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
@@ -31,23 +28,3 @@ class XBPMFeedback(Device, Triggerable):
         async for value in observe_value(self.pos_stable):
             if value:
                 return
-
-
-class XBPMFeedbackI04(ophyd.Device):
-    """The I04 version of this device has a slightly different trigger method"""
-
-    # Values to set to pause_feedback
-    PAUSE = 0
-    RUN = 1
-
-    pos_ok = Component(EpicsSignalRO, "-EA-FDBK-01:XBPM2POSITION_OK")
-    pause_feedback = Component(EpicsSignal, "-EA-FDBK-01:FB_PAUSE")
-    x = Component(EpicsSignalRO, "-EA-XBPM-02:PosX:MeanValue_RBV")
-    y = Component(EpicsSignalRO, "-EA-XBPM-02:PosY:MeanValue_RBV")
-
-    def trigger(self) -> StatusBase:
-        return SubscriptionStatus(
-            self.pos_ok,
-            lambda *, old_value, value, **kwargs: value == 1,
-            timeout=60,
-        )

dodal/devices/zebra.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 from enum import Enum
 from functools import partialmethod
-from typing import List
 
 from ophyd_async.core import (
     AsyncStatus,
@@ -95,7 +94,7 @@ class ArmingDevice(StandardReadable):
     """A useful device that can abstract some of the logic of arming.
     Allows a user to just call arm.set(ArmDemand.ARM)"""
 
-    TIMEOUT = 3
+    TIMEOUT: float = 3
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.arm_set = epics_signal_rw(float, prefix + "PC_ARM")
@@ -110,10 +109,9 @@ class ArmingDevice(StandardReadable):
             if reading == demand.value:
                 return
 
-    def set(self, demand: ArmDemand) -> AsyncStatus:
-        return AsyncStatus(
-            asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
-        )
+    @AsyncStatus.wrap
+    async def set(self, demand: ArmDemand):
+        await asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
 
 
 class PositionCompare(StandardReadable):
@@ -166,7 +164,7 @@ class ZebraOutputPanel(StandardReadable):
         super().__init__(name)
 
 
-def boolean_array_to_integer(values: List[bool]) -> int:
+def boolean_array_to_integer(values: list[bool]) -> int:
     """Converts a boolean array to integer by interpretting it in binary with LSB 0 bit
     numbering.
 
@@ -245,8 +243,8 @@ class LogicGateConfiguration:
     NUMBER_OF_INPUTS = 4
 
     def __init__(self, input_source: int, invert: bool = False) -> None:
-        self.sources: List[int] = []
-        self.invert: List[bool] = []
+        self.sources: list[int] = []
+        self.invert: list[bool] = []
         self.add_input(input_source, invert)
 
     def add_input(
@@ -271,7 +269,9 @@ class LogicGateConfiguration:
 
     def __str__(self) -> str:
         input_strings = []
-        for input, (source, invert) in enumerate(zip(self.sources, self.invert)):
+        for input, (source, invert) in enumerate(
+            zip(self.sources, self.invert, strict=False)
+        ):
             input_strings.append(f"INP{input+1}={'!' if invert else ''}{source}")
 
         return ", ".join(input_strings)

dodal/devices/zebra_controlled_shutter.py

@@ -29,10 +29,10 @@ class ZebraShutter(StandardReadable, Movable):
         super().__init__(name=name)
 
     @AsyncStatus.wrap
-    async def set(self, desired_position: ZebraShutterState):
-        await self.position_setpoint.set(desired_position)
+    async def set(self, value: ZebraShutterState):
+        await self.position_setpoint.set(value)
         return await wait_for_value(
             signal=self.position_readback,
-            match=desired_position,
+            match=value,
             timeout=DEFAULT_TIMEOUT,
         )

dodal/devices/zocalo/zocalo_interaction.py

@@ -1,5 +1,6 @@
 import dataclasses
 import getpass
+import os
 import socket
 from dataclasses import dataclass
 
@@ -37,6 +38,12 @@ class ZocaloStartInfo:
     message_index: int
 
 
+def _get_zocalo_headers() -> tuple[str, str]:
+    user = os.environ.get("ZOCALO_GO_USER", getpass.getuser())
+    hostname = os.environ.get("ZOCALO_GO_HOSTNAME", socket.gethostname())
+    return user, hostname
+
+
 class ZocaloTrigger:
     """This class just sends 'run_start' and 'run_end' messages to zocalo, it is
     intended to be used in bluesky callback classes. To get results from zocalo back
@@ -55,9 +62,10 @@ class ZocaloTrigger:
                 "recipes": ["mimas"],
                 "parameters": parameters,
             }
+            user, hostname = _get_zocalo_headers()
             header = {
-                "zocalo.go.user": getpass.getuser(),
-                "zocalo.go.host": socket.gethostname(),
+                "zocalo.go.user": user,
+                "zocalo.go.host": hostname,
             }
             transport.send("processing_recipe", message, headers=header)
         finally:

dodal/devices/zocalo/zocalo_results.py

@@ -1,8 +1,9 @@
 import asyncio
 from collections import OrderedDict
+from collections.abc import Generator, Sequence
 from enum import Enum
 from queue import Empty, Queue
-from typing import Any, Generator, Sequence, Tuple, TypedDict
+from typing import Any, TypedDict
 
 import bluesky.plan_stubs as bps
 import numpy as np
@@ -10,7 +11,7 @@ import workflows.recipe
 import workflows.transport
 from bluesky.protocols import Descriptor, Triggerable
 from numpy.typing import NDArray
-from ophyd_async.core import StandardReadable, soft_signal_r_and_setter
+from ophyd_async.core import HintedSignal, StandardReadable, soft_signal_r_and_setter
 from ophyd_async.core.async_status import AsyncStatus
 from workflows.transport.common_transport import CommonTransport
 
@@ -79,34 +80,41 @@ class ZocaloResults(StandardReadable, Triggerable):
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
 
-        self.results, _ = soft_signal_r_and_setter(list[XrcResult], name="results")
-        self.centres_of_mass, _ = soft_signal_r_and_setter(
+        self.results, self._results_setter = soft_signal_r_and_setter(
+            list[XrcResult], name="results"
+        )
+        self.centres_of_mass, self._com_setter = soft_signal_r_and_setter(
             NDArray[np.uint64], name="centres_of_mass"
         )
-        self.bbox_sizes, _ = soft_signal_r_and_setter(
+        self.bbox_sizes, self._bbox_setter = soft_signal_r_and_setter(
             NDArray[np.uint64], "bbox_sizes", self.name
         )
-        self.ispyb_dcid, _ = soft_signal_r_and_setter(int, name="ispyb_dcid")
-        self.ispyb_dcgid, _ = soft_signal_r_and_setter(int, name="ispyb_dcgid")
-        self.set_readable_signals(
-            read=[
+        self.ispyb_dcid, self._ispyb_dcid_setter = soft_signal_r_and_setter(
+            int, name="ispyb_dcid"
+        )
+        self.ispyb_dcgid, self._ispyb_dcgid_setter = soft_signal_r_and_setter(
+            int, name="ispyb_dcgid"
+        )
+        self.add_readables(
+            [
                 self.results,
                 self.centres_of_mass,
                 self.bbox_sizes,
                 self.ispyb_dcid,
                 self.ispyb_dcgid,
-            ]
+            ],
+            wrapper=HintedSignal,
         )
         super().__init__(name)
 
     async def _put_results(self, results: Sequence[XrcResult], ispyb_ids):
-        await self.results._backend.put(list(results))
+        self._results_setter(list(results))
         centres_of_mass = np.array([r["centre_of_mass"] for r in results])
         bbox_sizes = np.array([bbox_size(r) for r in results])
-        await self.centres_of_mass._backend.put(centres_of_mass)
-        await self.bbox_sizes._backend.put(bbox_sizes)
-        await self.ispyb_dcid._backend.put(ispyb_ids["dcid"])
-        await self.ispyb_dcgid._backend.put(ispyb_ids["dcgid"])
+        self._com_setter(centres_of_mass)
+        self._bbox_setter(bbox_sizes)
+        self._ispyb_dcid_setter(ispyb_ids["dcid"])
+        self._ispyb_dcgid_setter(ispyb_ids["dcgid"])
 
     def _clear_old_results(self):
         LOGGER.info("Clearing queue")
@@ -120,7 +128,12 @@ class ZocaloResults(StandardReadable, Triggerable):
         before triggering processing for the experiment"""
 
         LOGGER.info("Subscribing to results queue")
-        self._subscribe_to_results()
+        try:
+            self._subscribe_to_results()
+        except Exception as e:
+            print(f"GOT {e}")
+            raise
+
         await asyncio.sleep(CLEAR_QUEUE_WAIT_S)
         self._clear_old_results()
 
@@ -152,7 +165,7 @@ class ZocaloResults(StandardReadable, Triggerable):
             )
 
             raw_results = self._raw_results_received.get(timeout=self.timeout_s)
-            LOGGER.info(f"Zocalo: found {len(raw_results)} crystals.")
+            LOGGER.info(f"Zocalo: found {len(raw_results['results'])} crystals.")
             # Sort from strongest to weakest in case of multiple crystals
             await self._put_results(
                 sorted(
@@ -242,7 +255,7 @@ class ZocaloResults(StandardReadable, Triggerable):
 
 def get_processing_result(
     zocalo: ZocaloResults,
-) -> Generator[Any, Any, Tuple[np.ndarray, np.ndarray] | Tuple[None, None]]:
+) -> Generator[Any, Any, tuple[np.ndarray, np.ndarray] | tuple[None, None]]:
     """A minimal plan which will extract the top ranked xray centre and crystal bounding
     box size from the zocalo results. Returns (None, None) if no crystals were found."""
 

dodal/log.py

@@ -6,7 +6,7 @@ from logging import Logger, StreamHandler
 from logging.handlers import TimedRotatingFileHandler
 from os import environ
 from pathlib import Path
-from typing import Deque, Tuple, TypedDict
+from typing import TypedDict
 
 from bluesky.log import logger as bluesky_logger
 from graypy import GELFTCPHandler
@@ -37,11 +37,14 @@ class CircularMemoryHandler(logging.Handler):
     that always contains the last {capacity} number of messages, this is only flushed
     when a log of specific {flushLevel} comes in. On flush this buffer is then passed to
     the {target} handler.
+
+    The CircularMemoryHandler becomes the owner of the target handler which will be closed
+    on close of this handler.
     """
 
     def __init__(self, capacity, flushLevel=logging.ERROR, target=None):
         logging.Handler.__init__(self)
-        self.buffer: Deque[logging.LogRecord] = deque(maxlen=capacity)
+        self.buffer: deque[logging.LogRecord] = deque(maxlen=capacity)
         self.flushLevel = flushLevel
         self.target = target
 
@@ -66,6 +69,12 @@ class CircularMemoryHandler(logging.Handler):
         self.acquire()
         try:
             self.buffer.clear()
+            if self.target:
+                self.target.acquire()
+                try:
+                    self.target.close()
+                finally:
+                    self.target.release()
             self.target = None
             logging.Handler.close(self)
         finally:
@@ -121,7 +130,7 @@ def set_up_graylog_handler(logger: Logger, host: str, port: int):
 def set_up_INFO_file_handler(logger, path: Path, filename: str):
     """Set up a file handler for the logger, at INFO level, which will keep 30 days
     of logs, rotating once per day. Creates the directory if necessary."""
-    print(f"Logging to {path/filename}")
+    print(f"Logging to INFO file handler {path/filename}")
     path.mkdir(parents=True, exist_ok=True)
     file_handler = TimedRotatingFileHandler(
         filename=path / filename, when="MIDNIGHT", backupCount=INFO_LOG_DAYS
@@ -137,8 +146,8 @@ def set_up_DEBUG_memory_handler(
     """Set up a Memory handler which holds 200k lines, and writes them to an hourly
     log file when it sees a message of severity ERROR. Creates the directory if
     necessary"""
-    print(f"Logging to {path/filename}")
     debug_path = path / "debug"
+    print(f"Logging to DEBUG handler {debug_path/filename}")
     debug_path.mkdir(parents=True, exist_ok=True)
     file_handler = TimedRotatingFileHandler(
         filename=debug_path / filename, when="H", backupCount=DEBUG_LOG_FILES_TO_KEEP
@@ -240,7 +249,7 @@ def get_logging_file_path() -> Path:
 
 def get_graylog_configuration(
     dev_mode: bool, graylog_port: int | None = None
-) -> Tuple[str, int]:
+) -> tuple[str, int]:
     """Get the host and port for the graylog handler.
 
     If running in dev mode, this switches to localhost. Otherwise it publishes to the

dodal/plans/data_session_metadata.py

@@ -37,6 +37,7 @@ def attach_data_session_metadata_wrapper(
     directory_info: DirectoryInfo = provider()
     # https://github.com/DiamondLightSource/dodal/issues/452
     # As part of 452, write each dataCollection into their own folder, then can use resource_dir directly
+    assert directory_info.prefix is not None
     data_session = directory_info.prefix.removesuffix("-")
     yield from bpp.inject_md_wrapper(plan, md={DATA_SESSION: data_session})
 

dodal/plans/motor_util_plans.py

@@ -0,0 +1,117 @@
+import uuid
+from collections.abc import Generator
+from typing import Any, TypeVar
+
+from bluesky import plan_stubs as bps
+from bluesky.preprocessors import finalize_wrapper, pchain
+from bluesky.utils import Msg, make_decorator
+from ophyd_async.core import Device
+from ophyd_async.epics.motion import Motor
+
+from dodal.common import MsgGenerator
+
+AnyDevice = TypeVar("AnyDevice", bound=Device)
+
+
+class MoveTooLarge(Exception):
+    def __init__(
+        self, axis: Device, maximum_move: float, position: float, *args: object
+    ) -> None:
+        self.axis = axis
+        self.maximum_move = maximum_move
+        self.position = position
+        super().__init__(*args)
+
+
+def _check_and_cache_values(
+    devices_and_positions: dict[AnyDevice, float],
+    smallest_move: float,
+    maximum_move: float,
+) -> Generator[Msg, Any, dict[AnyDevice, float]]:
+    """Caches the positions of all Motors on specified device if they are within
+    smallest_move of home_position. Throws MoveTooLarge if they are outside maximum_move
+    of the home_position
+    """
+    positions = {}
+    for axis, new_position in devices_and_positions.items():
+        position = yield from bps.rd(axis)
+        if abs(position - new_position) > maximum_move:
+            raise MoveTooLarge(axis, maximum_move, position)
+        if abs(position - new_position) > smallest_move:
+            positions[axis] = position
+    return positions
+
+
+def home_and_reset_wrapper(
+    plan: MsgGenerator,
+    device: Device,
+    smallest_move: float,
+    maximum_move: float,
+    group: str | None = None,
+    wait_for_all: bool = True,
+) -> MsgGenerator:
+    home_positions = {
+        axis: 0.0 for _, axis in device.children() if isinstance(axis, Motor)
+    }
+    return move_and_reset_wrapper(
+        plan, home_positions, smallest_move, maximum_move, group, wait_for_all
+    )
+
+
+def move_and_reset_wrapper(
+    plan: MsgGenerator,
+    device_and_positions: dict[AnyDevice, float],
+    smallest_move: float,
+    maximum_move: float,
+    group: str | None = None,
+    wait_for_all: bool = True,
+) -> MsgGenerator:
+    """Wrapper that does the following:
+       1. Caches the positions of all Motors on device
+       2. Throws a MoveTooLarge exception if any positions are maximum_move away from home_position
+       2. Moves any motor that is more than smallest_move away from the home_position to home_position
+       3. Runs the specified plan
+       4. Moves all motors back to their cached positions
+
+    Args:
+        plan (Callable[[], MsgGenerator]): The plan to move between homing and returning to the cache
+        device (Device): The device to move. All Motors in the device will be cached and moved
+        smallest_move (float): The smallest move that we care about doing the home and cache for.
+                               Useful for not wearing out motors if you have large tolerances
+        maximum_move (float): If any Motor starts this far from the home an exception is raised
+                              and no moves occur
+        home_position (float): The position to move every motor to after caching
+        group (str, optional): If set the home move will be done using the home-{group}
+                               group and the reset to cache done using reset-{group}
+        wait_for_all (bool, optional): If true the home and reset to cache will be waited
+                                       on. If false it is left up to the caller to wait on
+                                       them. Defaults to True.
+    """
+    initial_positions = yield from _check_and_cache_values(
+        device_and_positions, smallest_move, maximum_move
+    )
+
+    def move_to_home():
+        home_group = f"home-{group if group else str(uuid.uuid4())[:6]}"
+        for axis, position in device_and_positions.items():
+            if axis in initial_positions.keys():
+                yield from bps.abs_set(axis, position, group=home_group)
+        if wait_for_all:
+            yield from bps.wait(home_group)
+
+    def return_to_initial_position():
+        reset_group = f"reset-{group if group else str(uuid.uuid4())[:6]}"
+        for axis, position in initial_positions.items():
+            yield from bps.abs_set(axis, position, group=reset_group)
+        if wait_for_all:
+            yield from bps.wait(reset_group)
+
+    return (
+        yield from finalize_wrapper(
+            pchain(move_to_home(), plan),
+            return_to_initial_position(),
+        )
+    )
+
+
+home_and_reset_decorator = make_decorator(home_and_reset_wrapper)