dls-dodal 1.39.0__py3-none-any.whl → 1.40.0__py3-none-any.whl

dodal/devices/i22/nxsas.py

@@ -103,7 +103,7 @@ class NXSasPilatus(PilatusDetector):
         prefix: str,
         path_provider: PathProvider,
         drv_suffix: str,
-        hdf_suffix: str,
+        fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
     ):
@@ -116,7 +116,7 @@ class NXSasPilatus(PilatusDetector):
             prefix,
             path_provider,
             drv_suffix=drv_suffix,
-            hdf_suffix=hdf_suffix,
+            fileio_suffix=fileio_suffix,
             name=name,
         )
         self._metadata_holder = metadata_holder
@@ -146,7 +146,7 @@ class NXSasOAV(AravisDetector):
         prefix: str,
         path_provider: PathProvider,
         drv_suffix: str,
-        hdf_suffix: str,
+        fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
         gpio_number: AravisController.GPIO_NUMBER = 1,
@@ -160,7 +160,7 @@ class NXSasOAV(AravisDetector):
             prefix,
             path_provider,
             drv_suffix=drv_suffix,
-            hdf_suffix=hdf_suffix,
+            fileio_suffix=fileio_suffix,
             name=name,
             gpio_number=gpio_number,
         )

dodal/devices/motors.py

@@ -19,10 +19,10 @@ class XYZPositioner(StandardReadable):
     Notes
     -----
     Example usage::
-        async with DeviceCollector():
+        async with init_devices():
             xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:")
     Or::
-        with DeviceCollector():
+        with init_devices():
             xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", infix = ("A", "B", "C"))
 
     """

dodal/devices/oav/oav_detector.py

@@ -1,6 +1,12 @@
 from enum import IntEnum
 
-from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, LazyMock, StandardReadable
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    LazyMock,
+    StandardReadable,
+)
 from ophyd_async.epics.core import epics_signal_rw
 
 from dodal.common.signal_utils import create_hardware_backed_soft_signal
@@ -8,12 +14,6 @@ from dodal.devices.areadetector.plugins.CAM import Cam
 from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
 from dodal.devices.oav.snapshots.snapshot_with_beam_centre import SnapshotWithBeamCentre
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
-from dodal.log import LOGGER
-
-
-class ZoomLevelNotFoundError(Exception):
-    def __init__(self, errmsg):
-        LOGGER.error(errmsg)
 
 
 class Coords(IntEnum):
@@ -29,7 +29,7 @@ def _get_correct_zoom_string(zoom: str) -> str:
     return zoom
 
 
-class ZoomController(StandardReadable):
+class ZoomController(StandardReadable, Movable):
     """
     Device to control the zoom level. This should be set like
         o = OAV(name="oav")
@@ -46,18 +46,9 @@ class ZoomController(StandardReadable):
         self.level = epics_signal_rw(str, f"{prefix}MP:SELECT")
         super().__init__(name=name)
 
-    async def _get_allowed_zoom_levels(self) -> list:
-        zoom_levels = await self.level.describe()
-        return zoom_levels[self.level.name]["choices"]  # type: ignore
-
     @AsyncStatus.wrap
-    async def set(self, level_to_set: str):
-        allowed_zoom_levels = await self._get_allowed_zoom_levels()
-        if level_to_set not in allowed_zoom_levels:
-            raise ZoomLevelNotFoundError(
-                f"{level_to_set} not found, expected one of {allowed_zoom_levels}"
-            )
-        await self.level.set(level_to_set, wait=True)
+    async def set(self, value: str):
+        await self.level.set(value, wait=True)
 
 
 class OAV(StandardReadable):

dodal/devices/pressure_jump_cell.py

@@ -151,11 +151,11 @@ class AllValvesControl(StandardReadable, Movable):
         )
 
 
-class ValveControl(StandardReadable):
+class ValveControl(StandardReadable, Movable):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.close = epics_signal_rw(ValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(ValveOpenSeqRequest, prefix + ":OPENSEQ")
+            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
 
         super().__init__(name)
 
@@ -165,16 +165,16 @@ class ValveControl(StandardReadable):
         if isinstance(value, ValveControlRequest):
             set_status = self.close.set(value)
         elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value)
+            set_status = self.open.set(value.value)
 
         return set_status
 
 
-class FastValveControl(StandardReadable):
+class FastValveControl(StandardReadable, Movable):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.close = epics_signal_rw(FastValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(ValveOpenSeqRequest, prefix + ":OPENSEQ")
+            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
 
         super().__init__(name)
 
@@ -184,7 +184,7 @@ class FastValveControl(StandardReadable):
         if isinstance(value, FastValveControlRequest):
             set_status = self.close.set(value)
         elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value)
+            set_status = self.open.set(value.value)
 
         return set_status
 
@@ -219,21 +219,24 @@ class PressureTransducer(StandardReadable):
         self,
         prefix: str,
         cell_prefix: str,
-        number: int,
+        transducer_number: int,
+        ethercat_channel_number: int,
         name: str = "",
         full_different_prefix_adc: str = "",
     ) -> None:
         final_prefix = f"{prefix}{cell_prefix}"
         with self.add_children_as_readables():
             self.omron_pressure = epics_signal_r(
-                float, f"{final_prefix}PP{number}:PRES"
+                float, f"{final_prefix}PP{transducer_number}:PRES"
+            )
+            self.omron_voltage = epics_signal_r(
+                float, f"{final_prefix}PP{transducer_number}:RAW"
             )
-            self.omron_voltage = epics_signal_r(float, f"{final_prefix}PP{number}:RAW")
             self.beckhoff_pressure = epics_signal_r(
-                float, f"{final_prefix}STATP{number}:MeanValue_RBV"
+                float, f"{final_prefix}STATP{transducer_number}:MeanValue_RBV"
             )
             self.slow_beckhoff_voltage_readout = epics_signal_r(
-                float, f"{full_different_prefix_adc}CH1"
+                float, f"{full_different_prefix_adc}CH{ethercat_channel_number}"
             )
 
         super().__init__(name)
@@ -284,13 +287,27 @@ class PressureJumpCell(StandardReadable):
         with self.add_children_as_readables():
             self.pressure_transducers: DeviceVector[PressureTransducer] = DeviceVector(
                 {
-                    i: PressureTransducer(
+                    1: PressureTransducer(
+                        prefix=prefix,
+                        cell_prefix=cell_prefix,
+                        transducer_number=1,
+                        full_different_prefix_adc=f"{prefix}{adc_prefix}-02:",
+                        ethercat_channel_number=1,
+                    ),
+                    2: PressureTransducer(
+                        prefix=prefix,
+                        cell_prefix=cell_prefix,
+                        transducer_number=2,
+                        full_different_prefix_adc=f"{prefix}{adc_prefix}-01:",
+                        ethercat_channel_number=2,
+                    ),
+                    3: PressureTransducer(
                         prefix=prefix,
-                        number=i,
                         cell_prefix=cell_prefix,
-                        full_different_prefix_adc=f"{prefix}{adc_prefix}-0{i}:",
-                    )
-                    for i in [1, 2, 3]
+                        transducer_number=3,
+                        full_different_prefix_adc=f"{prefix}{adc_prefix}-01:",
+                        ethercat_channel_number=1,
+                    ),
                 }
             )
 

dodal/devices/robot.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
+    Device,
     StandardReadable,
     StrictEnum,
     set_and_wait_for_value,
@@ -38,23 +39,36 @@ class PinMounted(StrictEnum):
     PIN_MOUNTED = "Pin Mounted"
 
 
+class ErrorStatus(Device):
+    def __init__(self, prefix: str) -> None:
+        self.str = epics_signal_r(str, prefix + "_ERR_MSG")
+        self.code = epics_signal_r(int, prefix + "_ERR_CODE")
+        super().__init__()
+
+    async def raise_if_error(self, raise_from: Exception):
+        error_code = await self.code.get_value()
+        if error_code:
+            error_string = await self.str.get_value()
+            raise RobotLoadFailed(int(error_code), error_string) from raise_from
+
+
 class BartRobot(StandardReadable, Movable):
     """The sample changing robot."""
 
     # How long to wait for the robot if it is busy soaking/drying
     NOT_BUSY_TIMEOUT = 5 * 60
+
     # How long to wait for the actual load to happen
     LOAD_TIMEOUT = 60
+
+    # Error codes that we do special things on
     NO_PIN_ERROR_CODE = 25
+    LIGHT_CURTAIN_TRIPPED = 40
 
     # How far the gonio position can be out before loading will fail
     LOAD_TOLERANCE_MM = 0.02
 
-    def __init__(
-        self,
-        name: str,
-        prefix: str,
-    ) -> None:
+    def __init__(self, name: str, prefix: str) -> None:
         self.barcode = epics_signal_r(str, prefix + "BARCODE")
         self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
 
@@ -69,8 +83,10 @@ class BartRobot(StandardReadable, Movable):
         self.load = epics_signal_x(prefix + "LOAD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
-        self.error_str = epics_signal_r(str, prefix + "PRG_ERR_MSG")
-        self.error_code = epics_signal_r(int, prefix + "PRG_ERR_CODE")
+
+        self.prog_error = ErrorStatus(prefix + "PRG")
+        self.controller_error = ErrorStatus(prefix + "CNTL")
+
         self.reset = epics_signal_x(prefix + "RESET.PROC")
         super().__init__(name=name)
 
@@ -81,7 +97,7 @@ class BartRobot(StandardReadable, Movable):
         """
 
         async def raise_if_no_pin():
-            await wait_for_value(self.error_code, self.NO_PIN_ERROR_CODE, None)
+            await wait_for_value(self.prog_error.code, self.NO_PIN_ERROR_CODE, None)
             raise RobotLoadFailed(self.NO_PIN_ERROR_CODE, "Pin was not detected")
 
         async def wfv():
@@ -108,6 +124,9 @@ class BartRobot(StandardReadable, Movable):
             raise
 
     async def _load_pin_and_puck(self, sample_location: SampleLocation):
+        if await self.controller_error.code.get_value() == self.LIGHT_CURTAIN_TRIPPED:
+            LOGGER.info("Light curtain tripped, trying again")
+            await self.reset.trigger()
         LOGGER.info(f"Loading pin {sample_location}")
         if await self.program_running.get_value():
             LOGGER.info(
@@ -137,6 +156,6 @@ class BartRobot(StandardReadable, Movable):
             )
         except (asyncio.TimeoutError, TimeoutError) as e:
             # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
-            error_code = await self.error_code.get_value()
-            error_string = await self.error_str.get_value()
-            raise RobotLoadFailed(int(error_code), error_string) from e
+            await self.prog_error.raise_if_error(e)
+            await self.controller_error.raise_if_error(e)
+            raise RobotLoadFailed(0, "Robot timed out") from e

dodal/devices/tetramm.py

@@ -13,7 +13,12 @@ from ophyd_async.core import (
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.adcore import ADHDFWriter, NDFileHDFIO, stop_busy_record
+from ophyd_async.epics.adcore import (
+    ADHDFWriter,
+    NDFileHDFIO,
+    NDPluginBaseIO,
+    stop_busy_record,
+)
 from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
@@ -221,7 +226,7 @@ class TetrammDetector(StandardDetector):
         path_provider: PathProvider,
         name: str = "",
         type: str | None = None,
-        **scalar_sigs: str,
+        plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         self.drv = TetrammDriver(prefix + "DRV:")
         self.hdf = NDFileHDFIO(prefix + "HDF5:")
@@ -243,7 +248,7 @@ class TetrammDetector(StandardDetector):
                 path_provider,
                 lambda: self.name,
                 TetrammDatasetDescriber(controller),
-                **scalar_sigs,
+                plugins=plugins,
             ),
             config_signals,
             name,

dodal/devices/turbo_slit.py

@@ -1,8 +1,8 @@
-from ophyd_async.core import Device
+from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
 
-class TurboSlit(Device):
+class TurboSlit(StandardReadable):
     """
     This collection of motors coordinates time resolved XAS experiments.
     It selects a beam out of the polychromatic fan.
@@ -17,8 +17,9 @@ class TurboSlit(Device):
         - xfine selects the energy as part of the high frequency scan
     """
 
-    def __init__(self, prefix: str, name: str):
-        self.gap = Motor(prefix=prefix + "GAP")
-        self.arc = Motor(prefix=prefix + "ARC")
-        self.xfine = Motor(prefix=prefix + "XFINE")
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.gap = Motor(prefix=prefix + "GAP")
+            self.arc = Motor(prefix=prefix + "ARC")
+            self.xfine = Motor(prefix=prefix + "XFINE")
         super().__init__(name=name)

dodal/devices/zocalo/zocalo_results.py

@@ -129,7 +129,12 @@ class ZocaloResults(StandardReadable, Triggerable):
 
         prefix (str): EPICS PV prefix for the device
 
-        use_cpu_and_gpu (bool): When True, ZocaloResults will wait for results from the CPU and the GPU, compare them, and provide a warning if the results differ. When False, ZocaloResults will only use results from the CPU
+        use_cpu_and_gpu (bool): When True, ZocaloResults will wait for results from the
+        CPU and the GPU, compare them, and provide a warning if the results differ. When
+        False, ZocaloResults will only use results from the CPU
+
+        use_gpu (bool): When True, ZocaloResults will take the first set of
+        results that it receives (which are likely the GPU results)
 
     """
 
@@ -142,6 +147,7 @@ class ZocaloResults(StandardReadable, Triggerable):
         timeout_s: float = DEFAULT_TIMEOUT,
         prefix: str = "",
         use_cpu_and_gpu: bool = False,
+        use_gpu: bool = False,
     ) -> None:
         self.zocalo_environment = zocalo_environment
         self.sort_key = SortKeys[sort_key]
@@ -151,6 +157,7 @@ class ZocaloResults(StandardReadable, Triggerable):
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
         self.use_cpu_and_gpu = use_cpu_and_gpu
+        self.use_gpu = use_gpu
 
         self.centre_of_mass, self._com_setter = soft_signal_r_and_setter(
             Array1D[np.float64], name="centre_of_mass"
@@ -213,6 +220,11 @@ class ZocaloResults(StandardReadable, Triggerable):
         clearing the queue. Plans using this device should wait on ZOCALO_STAGE_GROUP
         before triggering processing for the experiment"""
 
+        if self.use_cpu_and_gpu and self.use_gpu:
+            raise ValueError(
+                "Cannot compare GPU and CPU results and use GPU results at the same time."
+            )
+
         LOGGER.info("Subscribing to results queue")
         try:
             self._subscribe_to_results()
@@ -253,8 +265,13 @@ class ZocaloResults(StandardReadable, Triggerable):
             raw_results = self._raw_results_received.get(timeout=self.timeout_s)
             source_of_first_results = source_from_results(raw_results)
 
-            # Wait for results from CPU and GPU, warn and continue if only GPU times out. Error if CPU times out
+            if self.use_gpu and source_of_first_results == ZocaloSource.CPU:
+                LOGGER.warning(
+                    "Configured to use GPU results but CPU came first, using CPU results."
+                )
+
             if self.use_cpu_and_gpu:
+                # Wait for results from CPU and GPU, warn and continue if only GPU times out. Error if CPU times out
                 if source_of_first_results == ZocaloSource.CPU:
                     LOGGER.warning("Received zocalo results from CPU before GPU")
                 raw_results_two_sources = [raw_results]
@@ -303,7 +320,7 @@ class ZocaloResults(StandardReadable, Triggerable):
                         raise err
 
             LOGGER.info(
-                f"Zocalo results from {ZocaloSource.CPU.value} processing: found {len(raw_results['results'])} crystals."
+                f"Zocalo results from {source_from_results(raw_results)} processing: found {len(raw_results['results'])} crystals."
             )
             # Sort from strongest to weakest in case of multiple crystals
             await self._put_results(
@@ -335,7 +352,7 @@ class ZocaloResults(StandardReadable, Triggerable):
 
             results = message.get("results", [])
 
-            if self.use_cpu_and_gpu:
+            if self.use_cpu_and_gpu or self.use_gpu:
                 self._raw_results_received.put(
                     {"results": results, "recipe_parameters": recipe_parameters}
                 )

dodal/plans/save_panda.py

@@ -6,8 +6,10 @@ 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.fastcs.panda import phase_sorter
+from ophyd_async.core import Device, YamlSettingsProvider
+from ophyd_async.plan_stubs import (
+    store_settings,
+)
 
 from dodal.beamlines import module_name_for_beamline
 from dodal.utils import make_device
@@ -17,20 +19,24 @@ 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"
+        "--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"',
+        help='Name of the device. The default is "panda"',
         default="panda",
     )
+    parser.add_argument(
+        "--output-file",
+        help="Path to output file, including filename, eg '/scratch/panda_settings'. '.yaml' is appended to the file name automatically",
+        required=True,
+    )
     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:])
@@ -40,6 +46,9 @@ def main(argv: list[str]):
     output_file = args.output_file
     force = args.force
 
+    p = Path(output_file)
+    output_directory, file_name = str(p.parent), str(p.name)
+
     if beamline:
         os.environ["BEAMLINE"] = beamline
     else:
@@ -49,36 +58,43 @@ def main(argv: list[str]):
         sys.stderr.write("BEAMLINE not set and --beamline not specified\n")
         return 1
 
-    if Path(output_file).exists() and not force:
+    if Path(f"{output_directory}/{file_name}").exists() and not force:
         sys.stderr.write(
-            f"Output file {output_file} already exists and --force not specified."
+            f"Output file {output_directory}/{file_name} already exists and --force not specified."
         )
         return 1
 
-    _save_panda(beamline, device_name, output_file)
+    _save_panda(beamline, device_name, output_directory, file_name)
 
     print("Done.")
     return 0
 
 
-def _save_panda(beamline, device_name, output_file):
+def _save_panda(beamline, device_name, output_directory, file_name):
     RE = RunEngine()
     print("Creating devices...")
     module_name = module_name_for_beamline(beamline)
     try:
-        devices = make_device(f"dodal.beamlines.{module_name}", device_name)
+        devices = make_device(
+            f"dodal.beamlines.{module_name}", device_name, connect_immediately=True
+        )
     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)
+    print(
+        f"Saving to {output_directory}/{file_name} from {device_name} on {beamline}..."
+    )
+    _save_panda_to_yaml(RE, cast(Device, panda), file_name, output_directory)
 
 
-def _save_panda_to_file(RE: RunEngine, panda: Device, path: str):
+def _save_panda_to_yaml(
+    RE: RunEngine, panda: Device, file_name: str, output_directory: str
+):
     def save_to_file():
-        yield from save_device(panda, path, sorter=phase_sorter)
+        provider = YamlSettingsProvider(output_directory)
+        yield from store_settings(provider, file_name, panda)
 
     RE(save_to_file())
 

dodal/utils.py

@@ -102,7 +102,7 @@ class BeamlinePrefix:
 
 
 T = TypeVar("T", bound=AnyDevice)
-D = TypeVar("D", bound=OphydV2Device)
+
 SkipType = bool | Callable[[], bool]
 
 
@@ -119,16 +119,16 @@ def skip_device(precondition=lambda: True):
     return decorator
 
 
-class DeviceInitializationController(Generic[D]):
+class DeviceInitializationController(Generic[T]):
     def __init__(
         self,
-        factory: Callable[[], D],
+        factory: Callable[[], T],
         use_factory_name: bool,
         timeout: float,
         mock: bool,
         skip: SkipType,
     ):
-        self._factory: Callable[[], D] = functools.cache(factory)
+        self._factory: Callable[..., T] = functools.cache(factory)
         self._use_factory_name = use_factory_name
         self._timeout = timeout
         self._mock = mock
@@ -153,13 +153,15 @@ class DeviceInitializationController(Generic[D]):
         name: str | None = None,
         connection_timeout: float | None = None,
         mock: bool | None = None,
-    ) -> D:
+        **kwargs,
+    ) -> T:
         """Returns an instance of the Device the wrapped factory produces: the same
         instance will be returned if this method is called multiple times, and arguments
         may be passed to override this Controller's configuration.
         Once the device is connected, the value of mock must be consistent, or connect
         must be False.
 
+        Additional keyword arguments will be passed through to the wrapped factory function.
 
         Args:
             connect_immediately (bool, default False): whether to call connect on the
@@ -182,19 +184,36 @@ class DeviceInitializationController(Generic[D]):
               connect is called on the Device.
 
         Returns:
-            D: a singleton instance of the Device class returned by the wrapped factory.
+            T: a singleton instance of the Device class returned by the wrapped factory.
+
+        Raises:
+            RuntimeError:   If the device factory was invoked again with different
+             keyword arguments, without previously invoking cache_clear()
         """
-        device = self._factory()
+        is_v2_device = is_v2_device_factory(self._factory)
+        is_mock = mock if mock is not None else self._mock
+        if is_v2_device:
+            device: T = self._factory(**kwargs)
+        else:
+            device: T = self._factory(mock=is_mock, **kwargs)
+
+        if self._factory.cache_info().currsize > 1:  # type: ignore
+            raise RuntimeError(
+                f"Device factory method called multiple times with different parameters: "
+                f"{self.__name__}"  # type: ignore
+            )
 
         if connect_immediately:
-            call_in_bluesky_event_loop(
-                device.connect(
-                    timeout=connection_timeout
-                    if connection_timeout is not None
-                    else self._timeout,
-                    mock=mock if mock is not None else self._mock,
-                )
+            timeout = (
+                connection_timeout if connection_timeout is not None else self._timeout
             )
+            if is_v2_device:
+                call_in_bluesky_event_loop(
+                    device.connect(timeout=timeout, mock=is_mock)
+                )
+            else:
+                assert is_v1_device_type(type(device))
+                device.wait_for_connection(timeout=timeout)  # type: ignore
 
         if name:
             device.set_name(name)
@@ -410,7 +429,27 @@ def is_any_device_factory(func: Callable) -> TypeGuard[AnyDeviceFactory]:
 
 
 def is_v2_device_type(obj: type[Any]) -> bool:
-    return inspect.isclass(obj) and isinstance(obj, OphydV2Device)
+    non_parameterized_class = None
+    if obj != inspect.Signature.empty:
+        if inspect.isclass(obj):
+            non_parameterized_class = obj
+        elif hasattr(obj, "__origin__"):
+            # typing._GenericAlias is the same as types.GenericAlias, maybe?
+            # This is all very badly documented and possibly prone to change in future versions of Python
+            non_parameterized_class = obj.__origin__
+        if non_parameterized_class:
+            try:
+                return non_parameterized_class and issubclass(
+                    non_parameterized_class, OphydV2Device
+                )
+            except TypeError:
+                # Python 3.10 will return inspect.isclass(t) == True but then
+                # raise TypeError: issubclass() arg 1 must be a class
+                # when inspecting device_factory decorator function itself
+                # Later versions of Python seem not to be affected
+                pass
+
+    return False
 
 
 def is_v1_device_type(obj: type[Any]) -> bool: