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

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: