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

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 BartRobot(StandardReadable, Movable):
+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[SampleLocation]):
     """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/thawer.py

@@ -1,6 +1,6 @@
 from asyncio import Task, create_task, sleep
 
-from bluesky.protocols import Stoppable
+from bluesky.protocols import Movable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -21,18 +21,18 @@ class ThawerStates(StrictEnum):
     ON = "On"
 
 
-class ThawingTimer(Device, Stoppable):
+class ThawingTimer(Device, Stoppable, Movable[float]):
     def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
         self._control_signal_ref = Reference(control_signal)
         self._thawing_task: Task | None = None
         super().__init__("thaw_for_time_s")
 
     @AsyncStatus.wrap
-    async def set(self, time_to_thaw_for: float):
+    async def set(self, value: float):
         await self._control_signal_ref().set(ThawerStates.ON)
         if self._thawing_task and not self._thawing_task.done():
             raise ThawingException("Thawing task already in progress")
-        self._thawing_task = create_task(sleep(time_to_thaw_for))
+        self._thawing_task = create_task(sleep(value))
         try:
             await self._thawing_task
         finally:

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/undulator.py

@@ -46,7 +46,7 @@ def _get_closest_gap_for_energy(
     return table[1][idx]
 
 
-class Undulator(StandardReadable, Movable):
+class Undulator(StandardReadable, Movable[float]):
     """
     An Undulator-type insertion device, used to control photon emission at a given
     beam energy.

dodal/devices/undulator_dcm.py

@@ -12,7 +12,7 @@ from .undulator import Undulator
 ENERGY_TIMEOUT_S: float = 30.0
 
 
-class UndulatorDCM(StandardReadable, Movable):
+class UndulatorDCM(StandardReadable, Movable[float]):
     """
     Composite device to handle changing beamline energies, wraps the Undulator and the
     DCM. The DCM has a motor which controls the beam energy, when it moves, the

dodal/devices/util/epics_util.py

@@ -114,7 +114,7 @@ def call_func(func: Callable[[], StatusBase]) -> StatusBase:
     return func()
 
 
-class SetWhenEnabled(OphydAsyncDevice, Movable):
+class SetWhenEnabled(OphydAsyncDevice, Movable[int]):
     """A device that sets the proc field of a PV when it becomes enabled."""
 
     def __init__(self, name: str = "", prefix: str = ""):

dodal/devices/zebra/zebra.py

@@ -4,6 +4,7 @@ import asyncio
 from enum import Enum
 from functools import partialmethod
 
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     DeviceVector,
@@ -74,7 +75,7 @@ class SoftInState(StrictEnum):
     NO = "No"
 
 
-class ArmingDevice(StandardReadable):
+class ArmingDevice(StandardReadable, Movable[ArmDemand]):
     """A useful device that can abstract some of the logic of arming.
     Allows a user to just call arm.set(ArmDemand.ARM)"""
 
@@ -94,8 +95,8 @@ class ArmingDevice(StandardReadable):
                 return
 
     @AsyncStatus.wrap
-    async def set(self, demand: ArmDemand):
-        await asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
+    async def set(self, value: ArmDemand):
+        await asyncio.wait_for(self._set_armed(value), timeout=self.TIMEOUT)
 
 
 class PositionCompare(StandardReadable):

dodal/devices/zebra/zebra_controlled_shutter.py

@@ -19,7 +19,7 @@ class ZebraShutterControl(StrictEnum):
     AUTO = "Auto"
 
 
-class ZebraShutter(StandardReadable, Movable):
+class ZebraShutter(StandardReadable, Movable[ZebraShutterState]):
     """The shutter on most MX beamlines is controlled by the zebra.
 
     Internally in the zebra there are two AND gates, one for manual control and one for

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/plan_stubs/wrapped.py

@@ -1,6 +1,6 @@
 import itertools
 from collections.abc import Mapping
-from typing import Annotated, Any
+from typing import Annotated, TypeVar
 
 import bluesky.plan_stubs as bps
 from bluesky.protocols import Movable
@@ -12,17 +12,17 @@ Wrappers for Bluesky built-in plan stubs with type hinting
 
 Group = Annotated[str, "String identifier used by 'wait' or stubs that await"]
 
+T = TypeVar("T")
+
 
-# After bluesky 1.14, bounds for stubs that move can be narrowed
-# https://github.com/bluesky/bluesky/issues/1821
 def set_absolute(
-    movable: Movable, value: Any, group: Group | None = None, wait: bool = False
+    movable: Movable[T], value: T, group: Group | None = None, wait: bool = False
 ) -> MsgGenerator:
     """
     Set a device, wrapper for `bp.abs_set`.
 
     Args:
-        movable (Movable): The device to set
+        movable (Movable[T]): The device to set
         value (T): The new value
         group (Group | None, optional): The message group to associate with the
                                            setting, for sequencing. Defaults to None.
@@ -39,7 +39,7 @@ def set_absolute(
 
 
 def set_relative(
-    movable: Movable, value: Any, group: Group | None = None, wait: bool = False
+    movable: Movable[T], value: T, group: Group | None = None, wait: bool = False
 ) -> MsgGenerator:
     """
     Change a device, wrapper for `bp.rel_set`.
@@ -62,7 +62,7 @@ def set_relative(
     return (yield from bps.rel_set(movable, value, group=group, wait=wait))
 
 
-def move(moves: Mapping[Movable, Any], group: Group | None = None) -> MsgGenerator:
+def move(moves: Mapping[Movable[T], T], group: Group | None = None) -> MsgGenerator:
     """
     Move a device, wrapper for `bp.mv`.
 
@@ -79,13 +79,12 @@ def move(moves: Mapping[Movable, Any], group: Group | None = None) -> MsgGenerat
     """
 
     return (
-        # type ignore until https://github.com/bluesky/bluesky/issues/1809
-        yield from bps.mv(*itertools.chain.from_iterable(moves.items()), group=group)  # type: ignore
+        yield from bps.mv(*itertools.chain.from_iterable(moves.items()), group=group)
     )
 
 
 def move_relative(
-    moves: Mapping[Movable, Any], group: Group | None = None
+    moves: Mapping[Movable[T], T], group: Group | None = None
 ) -> MsgGenerator:
     """
     Move a device relative to its current position, wrapper for `bp.mvr`.
@@ -103,8 +102,7 @@ def move_relative(
     """
 
     return (
-        # type ignore until https://github.com/bluesky/bluesky/issues/1809
-        yield from bps.mvr(*itertools.chain.from_iterable(moves.items()), group=group)  # type: ignore
+        yield from bps.mvr(*itertools.chain.from_iterable(moves.items()), group=group)
     )
 
 

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

@@ -16,6 +16,7 @@ from typing import (
     Any,
     Generic,
     Protocol,
+    TypeAlias,
     TypeGuard,
     TypeVar,
     runtime_checkable,
@@ -43,12 +44,6 @@ from ophyd_async.core import Device as OphydV2Device
 
 import dodal.log
 
-try:
-    from typing import TypeAlias
-except ImportError:
-    from typing import TypeAlias
-
-
 #: Protocols defining interface to hardware
 BLUESKY_PROTOCOLS = [
     Checkable,
@@ -102,7 +97,7 @@ class BeamlinePrefix:
 
 
 T = TypeVar("T", bound=AnyDevice)
-D = TypeVar("D", bound=OphydV2Device)
+
 SkipType = bool | Callable[[], bool]
 
 
@@ -119,16 +114,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 +148,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 +179,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 +424,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: