ophyd-async 0.10.0a2__py3-none-any.whl → 0.10.0a4__py3-none-any.whl

ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.10.0a2'
-__version_tuple__ = version_tuple = (0, 10, 0)
+__version__ = version = '0.10.0a4'
+__version_tuple__ = version_tuple = (0, 10, 0, 'a4')

ophyd_async/core/__init__.py

@@ -26,7 +26,6 @@ from ._providers import (
     AutoIncrementingPathProvider,
     DatasetDescriber,
     FilenameProvider,
-    NameProvider,
     PathInfo,
     PathProvider,
     StaticFilenameProvider,
@@ -76,11 +75,13 @@ from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     Callback,
+    EnumTypes,
     LazyMock,
     NotConnected,
     Reference,
     StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     WatcherUpdate,
     gather_dict,
     get_dtype,
@@ -123,6 +124,8 @@ __all__ = [
     "Array1D",
     "StrictEnum",
     "SubsetEnum",
+    "SupersetEnum",
+    "EnumTypes",
     "Table",
     "SignalMetadata",
     # Soft signal
@@ -160,7 +163,6 @@ __all__ = [
     "AutoIncrementFilenameProvider",
     "UUIDFilenameProvider",
     # Datatset
-    "NameProvider",
     "DatasetDescriber",
     "HDFDatasetDescription",
     "HDFDocumentComposer",

ophyd_async/core/_derived_signal.py

@@ -1,5 +1,7 @@
 from collections.abc import Awaitable, Callable
-from typing import Any, Generic, get_type_hints
+from typing import Any, Generic, get_args, get_origin, get_type_hints, is_typeddict
+
+from bluesky.protocols import Locatable
 
 from ._derived_signal_backend import (
     DerivedSignalBackend,
@@ -8,7 +10,7 @@ from ._derived_signal_backend import (
     TransformT,
 )
 from ._device import Device
-from ._signal import SignalR, SignalRW, SignalT, SignalW
+from ._signal import Signal, SignalR, SignalRW, SignalT, SignalW
 from ._signal_backend import SignalDatatypeT
 
 
@@ -35,24 +37,36 @@ class DerivedSignalFactory(Generic[TransformT]):
         self._set_derived = set_derived
         # Check the raw and transform devices match the input arguments of the Transform
         if transform_cls is not Transform:
-            expected = list(transform_cls.model_fields) + [
-                x
-                for x in get_type_hints(transform_cls.raw_to_derived)
-                if x not in ["self", "return"]
-            ]
-            if set(expected) != set(raw_and_transform_devices):
+            # Populate expected parameters and types
+            expected = {
+                **{k: f.annotation for k, f in transform_cls.model_fields.items()},
+                **{
+                    k: v
+                    for k, v in get_type_hints(transform_cls.raw_to_derived).items()
+                    if k not in {"self", "return"}
+                },
+            }
+
+            # Populate received parameters and types
+            # Use Signal datatype, or Locatable datatype, or set type as None
+            received = {
+                k: v.datatype if isinstance(v, Signal) else get_locatable_type(v)
+                for k, v in raw_and_transform_devices.items()
+            }
+
+            if expected != received:
                 msg = (
-                    f"Expected devices to be passed as keyword arguments {expected}, "
-                    f"got {list(raw_and_transform_devices)}"
+                    f"Expected devices to be passed as keyword arguments "
+                    f"{expected}, got {received}"
                 )
                 raise TypeError(msg)
-        set_derived_datatype = (
-            _get_first_arg_datatype(set_derived) if set_derived else None
+        self._set_derived_takes_dict = (
+            is_typeddict(_get_first_arg_datatype(set_derived)) if set_derived else False
         )
         self._transformer = SignalTransformer(
             transform_cls,
             set_derived,
-            set_derived_datatype,
+            self._set_derived_takes_dict,
             **raw_and_transform_devices,
         )
 
@@ -75,7 +89,7 @@ class DerivedSignalFactory(Generic[TransformT]):
                 f"{signal_cls.__name__}s"
             )
             raise ValueError(msg)
-        if issubclass(signal_cls, SignalRW):
+        if issubclass(signal_cls, SignalRW) and self._set_derived_takes_dict:
             self._transformer.raw_locatables  # noqa: B018
         backend = DerivedSignalBackend(
             datatype, name, self._transformer, units, precision
@@ -269,3 +283,17 @@ def derived_signal_w(
         units=derived_units,
         precision=derived_precision,
     )
+
+
+def get_locatable_type(obj: object) -> type | None:
+    """Extract datatype from Locatable parent class.
+
+    :param obj: Object with possible Locatable inheritance
+    :return: Type hint associated with Locatable, or None if not found.
+    """
+    for base in getattr(obj.__class__, "__orig_bases__", []):
+        if get_origin(base) is Locatable:
+            args = get_args(base)
+            if args:
+                return args[0]
+    return None

ophyd_async/core/_derived_signal_backend.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Awaitable, Callable, Mapping
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, is_typeddict
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
 from bluesky.protocols import Location, Reading, Subscribable
 from event_model import DataKey
@@ -76,12 +76,12 @@ class SignalTransformer(Generic[TransformT]):
         self,
         transform_cls: type[TransformT],
         set_derived: Callable[..., Awaitable[None]] | None,
-        set_derived_datatype: type | None,
+        set_derived_takes_dict: bool,
         **raw_and_transform_devices,
     ):
         self._transform_cls = transform_cls
         self._set_derived = set_derived
-        self._need_dict = is_typeddict(set_derived_datatype)
+        self._set_derived_takes_dict = set_derived_takes_dict
         self._transform_devices = {
             k: raw_and_transform_devices.pop(k) for k in transform_cls.model_fields
         }
@@ -229,7 +229,7 @@ class SignalTransformer(Generic[TransformT]):
         if self._set_derived is None:
             msg = "Cannot put as no set_derived method given"
             raise RuntimeError(msg)
-        if self._need_dict:
+        if self._set_derived_takes_dict:
             # Need to get the other derived values and update the one that's changing
             derived = await self.get_locations()
             setpoints = {k: v["setpoint"] for k, v in derived.items()}

ophyd_async/core/_detector.py

@@ -23,7 +23,7 @@ from bluesky.protocols import (
     WritesStreamAssets,
 )
 from event_model import DataKey
-from pydantic import BaseModel, Field, NonNegativeInt, computed_field
+from pydantic import BaseModel, Field, NonNegativeInt, PositiveInt, computed_field
 
 from ._device import Device, DeviceConnector
 from ._protocol import AsyncConfigurable, AsyncReadable
@@ -51,49 +51,52 @@ class DetectorTrigger(Enum):
 class TriggerInfo(BaseModel):
     """Minimal set of information required to setup triggering on a detector."""
 
-    number_of_triggers: NonNegativeInt | list[NonNegativeInt] = Field(default=1)
-    """Number of triggers that will be sent, (0 means infinite).
+    number_of_events: NonNegativeInt | list[NonNegativeInt] = Field(default=1)
+    """Number of events that will be processed, (0 means infinite).
 
     Can be:
     - A single integer or
-    - A list of integers for multiple triggers
+    - A list of integers for multiple events
 
-    Example for tomography: ``TriggerInfo(number=[2,3,100,3])``.
-    This would trigger:
+    Example for tomography: ``TriggerInfo(number_of_events=[2,3,100,3])``.
+    This would process:
 
-    - 2 times for dark field images
-    - 3 times for initial flat field images
-    - 100 times for projections
-    - 3 times for final flat field images
+    - 2 events for dark field images
+    - 3 events for initial flat field images
+    - 100 events for projections
+    - 3 events for final flat field images
     """
 
     trigger: DetectorTrigger = Field(default=DetectorTrigger.INTERNAL)
     """Sort of triggers that will be sent"""
 
     deadtime: float = Field(default=0.0, ge=0)
-    """What is the minimum deadtime between triggers"""
+    """What is the minimum deadtime between exposures"""
 
     livetime: float | None = Field(default=None, ge=0)
-    """What is the maximum high time of the triggers"""
-
-    frame_timeout: float | None = Field(default=None, gt=0)
-    """What is the maximum timeout on waiting for a frame"""
-
-    multiplier: int = 1
-    """How many triggers make up a single StreamDatum index, to allow multiple frames
-    from a faster detector to be zipped with a single frame from a slow detector
-    e.g. if num=10 and multiplier=5 then the detector will take 10 frames,
-    but publish 2 indices, and describe() will show a shape of (5, h, w)
+    """What is the maximum high time of the exposures"""
+
+    exposure_timeout: float | None = Field(default=None, gt=0)
+    """What is the maximum timeout on waiting for an exposure"""
+
+    exposures_per_event: PositiveInt = 1
+    """The number of exposures that are grouped into a single StreamDatum index.
+    A exposures_per_event > 1 can be useful to have exposures from a faster detector
+    able to be zipped with a single exposure from a slower detector. E.g. if
+    number_of_events=10 and exposures_per_event=5 then the detector will take
+    10 exposures, but publish 2 StreamDatum indices, and describe() will show a
+    shape of (5, h, w) for each.
+    Default is 1.
     """
 
     @computed_field
     @cached_property
-    def total_number_of_triggers(self) -> int:
+    def total_number_of_exposures(self) -> int:
         return (
-            sum(self.number_of_triggers)
-            if isinstance(self.number_of_triggers, list)
-            else self.number_of_triggers
-        )
+            sum(self.number_of_events)
+            if isinstance(self.number_of_events, list)
+            else self.number_of_events
+        ) * self.exposures_per_event
 
 
 class DetectorController(ABC):
@@ -127,16 +130,17 @@ class DetectorWriter(ABC):
     """Logic for making detector write data to somewhere persistent (e.g. HDF5 file)."""
 
     @abstractmethod
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+    async def open(
+        self, name: str, exposures_per_event: PositiveInt = 1
+    ) -> dict[str, DataKey]:
         """Open writer and wait for it to be ready for data.
 
-        :param multiplier:
+        :param exposures_per_event:
             Each StreamDatum index corresponds to this many written exposures
         :return: Output for ``describe()``
         """
 
-    @property
-    def hints(self) -> Hints:
+    def get_hints(self, name: str) -> Hints:
         """The hints to be used for the detector."""
         return {}
 
@@ -153,7 +157,9 @@ class DetectorWriter(ABC):
         """Yield the index of each frame (or equivalent data point) as it is written."""
 
     @abstractmethod
-    def collect_stream_docs(self, indices_written: int) -> AsyncIterator[StreamAsset]:
+    def collect_stream_docs(
+        self, name: str, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
         """Create Stream docs up to given number written."""
 
     @abstractmethod
@@ -215,11 +221,11 @@ class StandardDetector(
         self._watchers: list[Callable] = []
         self._fly_status: WatchableAsyncStatus | None = None
         self._fly_start: float | None = None
-        self._frames_to_complete: int = 0
-        # Represents the total number of frames that will have been completed at the
+        self._events_to_complete: int = 0
+        # Represents the total number of exposures that will have been completed at the
         # end of the next `complete`.
-        self._completable_frames: int = 0
-        self._number_of_triggers_iter: Iterator[int] | None = None
+        self._completable_exposures: int = 0
+        self._number_of_events_iter: Iterator[int] | None = None
         self._initial_frame: int = 0
         super().__init__(name, connector=connector)
 
@@ -269,15 +275,19 @@ class StandardDetector(
         if self._trigger_info is None:
             await self.prepare(
                 TriggerInfo(
-                    number_of_triggers=1,
+                    number_of_events=1,
                     trigger=DetectorTrigger.INTERNAL,
                 )
             )
-
         trigger_info = _ensure_trigger_info_exists(self._trigger_info)
         if trigger_info.trigger is not DetectorTrigger.INTERNAL:
             msg = "The trigger method can only be called with INTERNAL triggering"
             raise ValueError(msg)
+        if trigger_info.number_of_events != 1:
+            raise ValueError(
+                "Triggering is not supported for multiple events, the detector was "
+                f"prepared with number_of_events={trigger_info.number_of_events}."
+            )
 
         # Arm the detector and wait for it to finish.
         indices_written = await self._writer.get_indices_written()
@@ -312,14 +322,16 @@ class StandardDetector(
             raise ValueError(msg)
         elif not value.deadtime:
             value.deadtime = self._controller.get_deadtime(value.livetime)
-        self._number_of_triggers_iter = iter(
-            value.number_of_triggers
-            if isinstance(value.number_of_triggers, list)
-            else [value.number_of_triggers]
-        )
-        self._describe, _ = await asyncio.gather(
-            self._writer.open(value.multiplier), self._controller.prepare(value)
+        self._trigger_info = value
+        self._number_of_events_iter = iter(
+            value.number_of_events
+            if isinstance(value.number_of_events, list)
+            else [value.number_of_events]
         )
+
+        await self._controller.prepare(value)
+        self._describe = await self._writer.open(self.name, value.exposures_per_event)
+
         self._initial_frame = await self._writer.get_indices_written()
         if value.trigger != DetectorTrigger.INTERNAL:
             await self._controller.arm()
@@ -327,25 +339,27 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def kickoff(self):
-        if self._trigger_info is None or self._number_of_triggers_iter is None:
+        if self._trigger_info is None or self._number_of_events_iter is None:
             raise RuntimeError("Prepare must be called before kickoff!")
         if self._trigger_info.trigger == DetectorTrigger.INTERNAL:
             await self._controller.arm()
         self._fly_start = time.monotonic()
         try:
-            self._frames_to_complete = next(self._number_of_triggers_iter)
-            self._completable_frames += self._frames_to_complete
+            self._events_to_complete = next(self._number_of_events_iter)
+            self._completable_exposures += (
+                self._events_to_complete * self._trigger_info.exposures_per_event
+            )
         except StopIteration as err:
             raise RuntimeError(
                 f"Kickoff called more than the configured number of "
-                f"{self._trigger_info.total_number_of_triggers} iteration(s)!"
+                f"{self._trigger_info.total_number_of_exposures} iteration(s)!"
             ) from err
 
     @WatchableAsyncStatus.wrap
     async def complete(self):
         trigger_info = _ensure_trigger_info_exists(self._trigger_info)
         indices_written = self._writer.observe_indices_written(
-            trigger_info.frame_timeout
+            trigger_info.exposure_timeout
             or (
                 DEFAULT_TIMEOUT
                 + (trigger_info.livetime or 0)
@@ -358,21 +372,21 @@ class StandardDetector(
                     name=self.name,
                     current=index,
                     initial=self._initial_frame,
-                    target=self._frames_to_complete,
+                    target=self._events_to_complete,
                     unit="",
                     precision=0,
                     time_elapsed=time.monotonic() - self._fly_start
                     if self._fly_start
                     else None,
                 )
-                if index >= self._frames_to_complete:
+                if index >= self._events_to_complete:
                     break
         finally:
             await indices_written.aclose()
-            if self._completable_frames >= trigger_info.total_number_of_triggers:
-                self._completable_frames = 0
-                self._frames_to_complete = 0
-                self._number_of_triggers_iter = None
+            if self._completable_exposures >= trigger_info.total_number_of_exposures:
+                self._completable_exposures = 0
+                self._events_to_complete = 0
+                self._number_of_events_iter = None
                 await self._controller.wait_for_idle()
 
     async def describe_collect(self) -> dict[str, DataKey]:
@@ -386,7 +400,7 @@ class StandardDetector(
         # retrieved for step scans.
         if index is None:
             index = await self._writer.get_indices_written()
-        async for doc in self._writer.collect_stream_docs(index):
+        async for doc in self._writer.collect_stream_docs(self.name, index):
             yield doc
 
     async def get_index(self) -> int:
@@ -394,4 +408,4 @@ class StandardDetector(
 
     @property
     def hints(self) -> Hints:
-        return self._writer.hints
+        return self._writer.get_hints(self.name)

ophyd_async/core/_device.py

@@ -346,10 +346,10 @@ class DeviceProcessor:
 
 
 def init_devices(
-    set_name=True,
+    set_name: bool = True,
     child_name_separator: str = "-",
-    connect=True,
-    mock=False,
+    connect: bool = True,
+    mock: bool = False,
     timeout: float = 10.0,
 ):
     """Auto initialize top level Device instances: to be used as a context manager.

ophyd_async/core/_hdf_dataset.py

@@ -2,7 +2,7 @@ from collections.abc import Iterator
 from pathlib import Path
 from urllib.parse import urlunparse
 
-from event_model import (
+from event_model import (  # type: ignore
     ComposeStreamResource,
     ComposeStreamResourceBundle,
     StreamDatum,
@@ -34,9 +34,6 @@ class HDFDatasetDescription(BaseModel):
     chunk_shape: tuple[int, ...]
     """The explicit chunk size written to disk"""
 
-    multiplier: int = 1
-    """Won't be used soon."""
-
 
 SLICE_NAME = "AD_HDF5_SWMR_SLICE"
 
@@ -74,7 +71,6 @@ class HDFDocumentComposer:
                 data_key=ds.data_key,
                 parameters={
                     "dataset": ds.dataset,
-                    "multiplier": ds.multiplier,
                     "chunk_shape": ds.chunk_shape,
                 },
                 uid=None,

ophyd_async/core/_providers.py

@@ -220,14 +220,6 @@ class YMDPathProvider(PathProvider):
         )
 
 
-class NameProvider(Protocol):
-    """Base class for callable classes providing data keys."""
-
-    @abstractmethod
-    def __call__(self) -> str:
-        """Get the name to be used as a data_key in the descriptor document."""
-
-
 class DatasetDescriber(Protocol):
     """For describing datasets in file writing."""
 

ophyd_async/core/_readable.py

@@ -179,8 +179,20 @@ class StandardReadable(
 
         yield
 
-        # Set symmetric difference operator gives all newly added keys
+        # Set symmetric difference operator gives all newly added keys.
         new_dict = dict(self.children())
+        for key, value in new_dict.items():
+            # Check if key already exists in dict_copy and if the value has changed.
+            if key in dict_copy and value != dict_copy[key]:
+                error_msg = (
+                    f"Duplicate readable device found: '{key}' in {value.parent}. "
+                    "Derived class must not redefine a readable. "
+                    "See: https://github.com/bluesky/ophyd-async/issues/848. "
+                    "If this functionality is required, please raise an issue: "
+                    "https://github.com/bluesky/ophyd-async"
+                )
+                raise KeyError(error_msg)
+
         new_keys = dict_copy.keys() ^ new_dict.keys()
         new_values = [new_dict[key] for key in new_keys]
 

ophyd_async/core/_signal.py

@@ -100,6 +100,11 @@ class Signal(Device, Generic[SignalDatatypeT]):
         """
         return self._connector.backend.source(self.name, read=True)
 
+    @property
+    def datatype(self) -> type[SignalDatatypeT] | None:
+        """Returns the datatype of the signal."""
+        return self._connector.backend.datatype
+
 
 SignalT = TypeVar("SignalT", bound=Signal)
 
@@ -431,8 +436,8 @@ async def observe_signals_value(
         Call subscribe_value on all the signals at the start, and clear_sub on
         it at the end.
     :param timeout:
-        If given, how long to wait for each updated value in seconds. If an
-        update is not produced in this time then raise asyncio.TimeoutError.
+        If given, how long to wait for ANY updated value from shared queue in seconds.
+        If an update is not produced in this time then raise asyncio.TimeoutError.
     :param done_status:
         If this status is complete, stop observing and make the iterator return.
         If it raises an exception then this exception will be raised by the
@@ -454,8 +459,10 @@ async def observe_signals_value(
     q: asyncio.Queue[tuple[SignalR[SignalDatatypeT], SignalDatatypeT] | Status] = (
         asyncio.Queue()
     )
-
+    # dict to store signal subscription to remove it later
     cbs: dict[SignalR, Callback] = {}
+
+    # subscribe signal to update queue and fill cbs dict
     for signal in signals:
 
         def queue_value(value: SignalDatatypeT, signal=signal):
@@ -468,6 +475,7 @@ async def observe_signals_value(
         done_status.add_callback(q.put_nowait)
     overall_deadline = time.monotonic() + done_timeout if done_timeout else None
     try:
+        last_item = ()
         while True:
             if overall_deadline and time.monotonic() >= overall_deadline:
                 raise asyncio.TimeoutError(
@@ -476,14 +484,22 @@ async def observe_signals_value(
                     f"timeout {done_timeout}s"
                 )
             iteration_timeout = _get_iteration_timeout(timeout, overall_deadline)
-            item = await asyncio.wait_for(q.get(), iteration_timeout)
+            try:
+                item = await asyncio.wait_for(q.get(), iteration_timeout)
+            except asyncio.TimeoutError as exc:
+                raise asyncio.TimeoutError(
+                    f"Timeout Error while waiting {iteration_timeout}s to update "
+                    f"{[signal.source for signal in signals]}. "
+                    f"Last observed signal and value were {last_item}"
+                ) from exc
             if done_status and item is done_status:
                 if exc := done_status.exception():
                     raise exc
                 else:
                     break
             else:
-                yield cast(tuple[SignalR[SignalDatatypeT], SignalDatatypeT], item)
+                last_item = cast(tuple[SignalR[SignalDatatypeT], SignalDatatypeT], item)
+                yield last_item
     finally:
         for signal, cb in cbs.items():
             signal.clear_sub(cb)

ophyd_async/core/_signal_backend.py

@@ -6,8 +6,16 @@ import numpy as np
 from bluesky.protocols import Reading
 from event_model import DataKey, Dtype, Limits
 
+from ophyd_async.core._utils import (
+    Callback,
+    EnumTypes,
+    StrictEnum,
+    SubsetEnum,
+    SupersetEnum,
+    get_enum_cls,
+)
+
 from ._table import Table
-from ._utils import Callback, StrictEnum, get_enum_cls
 
 DTypeScalar_co = TypeVar("DTypeScalar_co", covariant=True, bound=np.generic)
 """A numpy dtype like [](#numpy.float64)."""
@@ -24,7 +32,7 @@ E.g. `Array1D[np.float64]` is a 1D numpy array of 64-bit floats."""
 Primitive = bool | int | float | str
 SignalDatatype = (
     Primitive
-    | StrictEnum
+    | EnumTypes
     | Array1D[np.bool_]
     | Array1D[np.int8]
     | Array1D[np.uint8]
@@ -39,16 +47,18 @@ SignalDatatype = (
     | np.ndarray
     | Sequence[str]
     | Sequence[StrictEnum]
+    | Sequence[SubsetEnum]
+    | Sequence[SupersetEnum]
     | Table
 )
 """The supported [](#Signal) datatypes:
 
 - A python primitive [](#bool), [](#int), [](#float), [](#str)
-- A [](#StrictEnum) or [](#SubsetEnum) subclass
+- An [](#EnumTypes) subclass
 - A fixed datatype [](#Array1D) of numpy bool, signed and unsigned integers or float
 - A [](#numpy.ndarray) which can change dimensions and datatype at runtime
 - A sequence of [](#str)
-- A sequence of [](#StrictEnum) or [](#SubsetEnum) subclass
+- A sequence of [](#EnumTypes) subclasses
 - A [](#Table) subclass
 """
 # TODO: These typevars will not be needed when we drop python 3.11
@@ -58,7 +68,7 @@ PrimitiveT = TypeVar("PrimitiveT", bound=Primitive)
 SignalDatatypeT = TypeVar("SignalDatatypeT", bound=SignalDatatype)
 """A typevar for a [](#SignalDatatype)."""
 SignalDatatypeV = TypeVar("SignalDatatypeV", bound=SignalDatatype)
-EnumT = TypeVar("EnumT", bound=StrictEnum)
+EnumT = TypeVar("EnumT", bound=EnumTypes)
 TableT = TypeVar("TableT", bound=Table)
 
 
@@ -136,7 +146,7 @@ def _datakey_dtype(datatype: type[SignalDatatype]) -> Dtype:
         or issubclass(datatype, Table)
     ):
         return "array"
-    elif issubclass(datatype, StrictEnum):
+    elif issubclass(datatype, EnumTypes):
         return "string"
     elif issubclass(datatype, Primitive):
         return _primitive_dtype[datatype]
@@ -153,7 +163,7 @@ def _datakey_dtype_numpy(
     elif (
         get_origin(datatype) is Sequence
         or datatype is str
-        or issubclass(datatype, StrictEnum)
+        or issubclass(datatype, EnumTypes)
     ):
         # TODO: use np.dtypes.StringDType when we can use in structured arrays
         # https://github.com/numpy/numpy/issues/25693
@@ -167,7 +177,7 @@ def _datakey_dtype_numpy(
 
 
 def _datakey_shape(value: SignalDatatype) -> list[int]:
-    if type(value) in _primitive_dtype or isinstance(value, StrictEnum):
+    if type(value) in _primitive_dtype or isinstance(value, EnumTypes):
         return []
     elif isinstance(value, np.ndarray):
         return list(value.shape)