dls-dodal 1.66.0__py3-none-any.whl → 1.68.0__py3-none-any.whl

dodal/devices/insertion_device/lookup_table_models.py

@@ -0,0 +1,317 @@
+"""Apple2 lookup table utilities and CSV converter.
+
+This module provides helpers to read, validate and convert Apple2 insertion-device
+lookup tables (energy -> gap/phase polynomials) from CSV sources into an
+in-memory dictionary format used by the Apple2 controllers.
+
+Data format produced
+The lookup-table dictionary created by convert_csv_to_lookup() follows this
+structure:
+
+{
+  "POL_MODE": {
+    "energy_entries": [
+        {
+            "low": <float>,
+            "high": <float>,
+            "poly": <numpy.poly1d>
+        },
+      ...
+    ]
+  },
+  ...
+}
+"""
+
+import csv
+import io
+from collections.abc import Generator
+from typing import Annotated as A
+from typing import Any, NamedTuple, Self
+
+import numpy as np
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    RootModel,
+    field_serializer,
+    field_validator,
+)
+
+from dodal.devices.insertion_device.id_enum import Pol
+
+DEFAULT_POLY_DEG = [
+    "7th-order",
+    "6th-order",
+    "5th-order",
+    "4th-order",
+    "3rd-order",
+    "2nd-order",
+    "1st-order",
+    "b",
+]
+
+MODE_NAME_CONVERT = {"cr": "pc", "cl": "nc"}
+DEFAULT_GAP_FILE = "IDEnergy2GapCalibrations.csv"
+DEFAULT_PHASE_FILE = "IDEnergy2PhaseCalibrations.csv"
+
+ROW_PHASE_MOTOR_TOLERANCE = 0.004
+ROW_PHASE_CIRCULAR = 15
+MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
+MAXIMUM_GAP_MOTOR_POSITION = 100
+
+DEFAULT_POLY1D_PARAMETERS = {
+    Pol.LH: [0],
+    Pol.LV: [MAXIMUM_ROW_PHASE_MOTOR_POSITION],
+    Pol.PC: [ROW_PHASE_CIRCULAR],
+    Pol.NC: [-ROW_PHASE_CIRCULAR],
+    Pol.LH3: [0],
+}
+
+
+class Source(NamedTuple):
+    column: str
+    value: str
+
+
+class LookupTableColumnConfig(BaseModel):
+    """Configuration on how to process a csv file columns into a LookupTable data model."""
+
+    source: A[
+        Source | None,
+        Field(
+            description="If not None, only process the row if the source column name match the value."
+        ),
+    ] = None
+    mode: A[str, Field(description="Polarisation mode column name.")] = "Mode"
+    min_energy: A[str, Field(description="Minimum energy column name.")] = "MinEnergy"
+    max_energy: A[str, Field(description="Maximum energy column name.")] = "MaxEnergy"
+    poly_deg: list[str] = Field(
+        description="Polynomial column names.", default_factory=lambda: DEFAULT_POLY_DEG
+    )
+    mode_name_convert: dict[str, str] = Field(
+        description="When processing polarisation mode values, map their alias values to a real value.",
+        default_factory=lambda: MODE_NAME_CONVERT,
+    )
+    grating: A[
+        str | None, Field(description="Optional column name for entry grating.")
+    ] = None
+
+
+class EnergyCoverageEntry(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, frozen=True
+    )  # arbitrary_types_allowed is True so np.poly1d can be used.
+    min_energy: float
+    max_energy: float
+    poly: np.poly1d
+    grating: float | None = None
+
+    @field_validator("poly", mode="before")
+    @classmethod
+    def validate_and_convert_poly(
+        cls: type[Self], value: np.poly1d | list
+    ) -> np.poly1d:
+        """If reading from serialized data, it will be using a list. Convert to np.poly1d"""
+        if isinstance(value, list):
+            return np.poly1d(value)
+        return value
+
+    @field_serializer("poly", mode="plain")
+    def serialize_poly(self, value: np.poly1d) -> list:
+        """Allow np.poly1d to work when serializing."""
+        return value.coefficients.tolist()
+
+
+class EnergyCoverage(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    energy_entries: tuple[EnergyCoverageEntry, ...]
+
+    @field_validator("energy_entries", mode="after")
+    @classmethod
+    def _prepare_energy_entries(
+        cls, value: tuple[EnergyCoverageEntry, ...]
+    ) -> tuple[EnergyCoverageEntry, ...]:
+        """Convert incoming energy_entries to a sorted, immutable tuple."""
+        return tuple(sorted(value, key=lambda e: e.min_energy))
+
+    @classmethod
+    def generate(
+        cls: type[Self],
+        min_energies: list[float],
+        max_energies: list[float],
+        poly1d_params: list[list[float]],
+    ) -> Self:
+        energy_entries = tuple(
+            EnergyCoverageEntry(
+                min_energy=min_energy,
+                max_energy=max_energy,
+                poly=np.poly1d(poly_params),
+            )
+            for min_energy, max_energy, poly_params in zip(
+                min_energies, max_energies, poly1d_params, strict=True
+            )
+        )
+        return cls(energy_entries=energy_entries)
+
+    @property
+    def min_energy(self) -> float:
+        return self.energy_entries[0].min_energy
+
+    @property
+    def max_energy(self) -> float:
+        return self.energy_entries[-1].max_energy
+
+    def get_poly(self, energy: float) -> np.poly1d:
+        """
+        Return the numpy.poly1d polynomial applicable for the given energy.
+
+        Parameters:
+        -----------
+        energy:
+            Energy value in the same units used to create the lookup table.
+        """
+
+        if not self.min_energy <= energy <= self.max_energy:
+            raise ValueError(
+                f"Demanding energy must lie between {self.min_energy} and {self.max_energy}!"
+            )
+
+        poly_index = self.get_energy_index(energy)
+        if poly_index is not None:
+            return self.energy_entries[poly_index].poly
+        raise ValueError(
+            "Cannot find polynomial coefficients for your requested energy."
+            + " There might be gap in the calibration lookup table."
+        )
+
+    def get_energy_index(self, energy: float) -> int | None:
+        """Binary search assumes self.energy_entries is sorted by min_energy.
+        Return index or None if not found."""
+        max_index = len(self.energy_entries) - 1
+        min_index = 0
+        while min_index <= max_index:
+            mid_index = (min_index + max_index) // 2
+            en_try = self.energy_entries[mid_index]
+            if en_try.min_energy <= energy <= en_try.max_energy:
+                return mid_index
+            elif energy < en_try.min_energy:
+                max_index = mid_index - 1
+            else:
+                min_index = mid_index + 1
+        return None
+
+
+class LookupTable(RootModel[dict[Pol, EnergyCoverage]]):
+    """
+    Specialised lookup table for insertion devices to relate the energy and polarisation
+    values to Apple2 motor positions.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    # Allow to auto specify a dict if one not provided
+    def __init__(self, root: dict[Pol, EnergyCoverage] | None = None):
+        super().__init__(root=root or {})
+
+    @classmethod
+    def generate(
+        cls: type[Self],
+        pols: list[Pol],
+        energy_coverage: list[EnergyCoverage],
+    ) -> Self:
+        """Generate a LookupTable containing multiple EnergyCoverage
+        for provided polarisations."""
+        root_data = dict(zip(pols, energy_coverage, strict=False))
+        return cls(root=root_data)
+
+    def get_poly(
+        self,
+        energy: float,
+        pol: Pol,
+    ) -> np.poly1d:
+        """
+        Return the numpy.poly1d polynomial applicable for the given energy and polarisation.
+
+        Parameters:
+        -----------
+        energy:
+            Energy value in the same units used to create the lookup table.
+        pol:
+            Polarisation mode (Pol enum).
+        """
+        return self.root[pol].get_poly(energy)
+
+
+def convert_csv_to_lookup(
+    file_contents: str,
+    lut_config: LookupTableColumnConfig,
+    skip_line_start_with: str = "#",
+) -> LookupTable:
+    """
+    Convert CSV content into the Apple2 lookup-table dictionary.
+
+    Parameters:
+    -----------
+    file_contents:
+        The CSV file contents as string.
+    lut_config:
+        The configuration that how to process the file_contents into a LookupTable.
+    skip_line_start_with
+        Lines beginning with this prefix are skipped (default "#").
+
+    Returns:
+    -----------
+    LookupTable
+    """
+    temp_mode_entries: dict[Pol, list[EnergyCoverageEntry]] = {}
+
+    def process_row(row: dict[str, Any]) -> None:
+        """Process a single row from the CSV file and update the temporary entry list."""
+        raw_mode_value = str(row[lut_config.mode]).lower()
+        mode_value = Pol(
+            lut_config.mode_name_convert.get(raw_mode_value, raw_mode_value)
+        )
+
+        coefficients = np.poly1d([float(row[coef]) for coef in lut_config.poly_deg])
+
+        energy_entry = EnergyCoverageEntry(
+            min_energy=float(row[lut_config.min_energy]),
+            max_energy=float(row[lut_config.max_energy]),
+            poly=coefficients,
+        )
+
+        if mode_value not in temp_mode_entries:
+            temp_mode_entries[mode_value] = []
+
+        temp_mode_entries[mode_value].append(energy_entry)
+
+    reader = csv.DictReader(read_file_and_skip(file_contents, skip_line_start_with))
+
+    for row in reader:
+        source = lut_config.source
+        # If there are multiple source only convert requested.
+        if source is None or row[source.column] == source.value:
+            process_row(row=row)
+    # Check if our LookupTable is empty after processing, raise error if it is.
+    if not temp_mode_entries:
+        raise RuntimeError(
+            "LookupTable content is empty, failed to convert the file contents to "
+            "a LookupTable!"
+        )
+
+    final_lut_root: dict[Pol, EnergyCoverage] = {}
+    for pol, entries in temp_mode_entries.items():
+        final_lut_root[pol] = EnergyCoverage.model_validate({"energy_entries": entries})
+
+    return LookupTable(root=final_lut_root)
+
+
+def read_file_and_skip(file: str, skip_line_start_with: str = "#") -> Generator[str]:
+    """Yield non-comment lines from the CSV content string."""
+    for line in io.StringIO(file):
+        if line.startswith(skip_line_start_with):
+            continue
+        else:
+            yield line

dodal/devices/motors.py

@@ -122,6 +122,20 @@ class XYPitchStage(XYStage):
         super().__init__(prefix, name, x_infix, y_infix)
 
 
+class XYRollStage(XYStage):
+    def __init__(
+        self,
+        prefix: str,
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        roll_infix: str = "ROLL",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.roll = Motor(prefix + roll_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
+
+
 class XYZPitchYawStage(XYZStage):
     def __init__(
         self,

dodal/devices/robot.py

@@ -71,6 +71,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
     LOAD_TIMEOUT = 60
 
     # Error codes that we do special things on
+    NO_ERROR = 0
     NO_PIN_ERROR_CODE = 25
     LIGHT_CURTAIN_TRIPPED = 40
 
@@ -115,21 +116,25 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
         )
         super().__init__(name=name)
 
-    async def pin_mounted_or_no_pin_found(self):
-        """This co-routine will finish when either a pin is detected or the robot gives
-        an error saying no pin was found (whichever happens first). In the case where no
-        pin was found a RobotLoadError error is raised.
+    async def pin_state_or_error(self, expected_state=PinMounted.PIN_MOUNTED):
+        """This co-routine will finish when either the pin sensor reaches the specified
+        state or the robot gives an error (whichever happens first). In the case where
+        there is an error a RobotLoadError error is raised.
         """
 
-        async def raise_if_no_pin():
-            await wait_for_value(self.prog_error.code, self.NO_PIN_ERROR_CODE, None)
-            raise RobotLoadError(self.NO_PIN_ERROR_CODE, "Pin was not detected")
+        async def raise_if_error():
+            await wait_for_value(
+                self.prog_error.code, lambda value: value != self.NO_ERROR, None
+            )
+            error_code = await self.prog_error.code.get_value()
+            error_msg = await self.prog_error.str.get_value()
+            raise RobotLoadError(error_code, error_msg)
 
         async def wfv():
-            await wait_for_value(self.gonio_pin_sensor, PinMounted.PIN_MOUNTED, None)
+            await wait_for_value(self.gonio_pin_sensor, expected_state, None)
 
         tasks = [
-            (Task(raise_if_no_pin())),
+            (Task(raise_if_error())),
             (Task(wfv())),
         ]
         try:
@@ -168,10 +173,10 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
         await self.load.trigger()
         if await self.gonio_pin_sensor.get_value() == PinMounted.PIN_MOUNTED:
             LOGGER.info(WAIT_FOR_OLD_PIN_MSG)
-            await wait_for_value(self.gonio_pin_sensor, PinMounted.NO_PIN_MOUNTED, None)
+            await self.pin_state_or_error(PinMounted.NO_PIN_MOUNTED)
         LOGGER.info(WAIT_FOR_NEW_PIN_MSG)
 
-        await self.pin_mounted_or_no_pin_found()
+        await self.pin_state_or_error()
 
     @AsyncStatus.wrap
     async def set(self, value: SampleLocation | None):

dodal/plans/__init__.py

@@ -1,4 +1,4 @@
-from .scanspec import spec_scan
+from .spec_path import spec_scan
 from .wrapped import count
 
 __all__ = ["count", "spec_scan"]

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -12,7 +12,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.fastcs.eiger import EigerDetector
 
-from dodal.beamlines.i03 import fastcs_eiger, set_path_provider
+from dodal.beamlines.i03 import fastcs_eiger
 from dodal.devices.detector import DetectorParams
 from dodal.log import LOGGER, do_default_logging_setup
 
@@ -163,9 +163,7 @@ if __name__ == "__main__":
         PurePath("/dls/i03/data/2025/cm40607-2/test_new_eiger/"),
     )
 
-    set_path_provider(path_provider)
-
-    eiger = fastcs_eiger(connect_immediately=True)
+    eiger = fastcs_eiger.build(connect_immediately=True, path_provider=path_provider)
     run_engine(
         configure_arm_trigger_and_disarm_detector(
             eiger=eiger,

dodal/testing/electron_analyser/device_factory.py

@@ -1,16 +1,16 @@
 from typing import Any, get_args, get_origin
 
-from dodal.devices.electron_analyser.abstract import (
+from dodal.devices.electron_analyser.base.base_detector import TElectronAnalyserDetector
+from dodal.devices.electron_analyser.base.base_driver_io import (
     TAbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.detector import TElectronAnalyserDetector
 from dodal.devices.electron_analyser.vgscienta import (
     VGScientaAnalyserDriverIO,
     VGScientaDetector,
 )
 
 
-async def create_driver(
+def create_driver(
     driver_class: type[TAbstractAnalyserDriverIO],
     **kwargs: Any,
 ) -> TAbstractAnalyserDriverIO:
@@ -34,7 +34,7 @@ async def create_driver(
     return driver_class(**(parameters | kwargs))
 
 
-async def create_detector(
+def create_detector(
     detector_class: type[TElectronAnalyserDetector],
     **kwargs: Any,
 ) -> TElectronAnalyserDetector:

dodal/testing/fixtures/devices/apple2.py

@@ -0,0 +1,78 @@
+from unittest.mock import MagicMock
+
+import pytest
+from daq_config_server.client import ConfigServer
+from ophyd_async.core import (
+    init_devices,
+    set_mock_value,
+)
+
+from dodal.devices.insertion_device import (
+    EnabledDisabledUpper,
+    UndulatorGap,
+    UndulatorGateStatus,
+    UndulatorJawPhase,
+    UndulatorPhaseAxes,
+)
+
+
+@pytest.fixture
+def mock_config_client() -> ConfigServer:
+    mock_config_client = ConfigServer()
+
+    mock_config_client.get_file_contents = MagicMock(spec=["get_file_contents"])
+
+    def my_side_effect(file_path, reset_cached_result) -> str:
+        assert reset_cached_result is True
+        with open(file_path) as f:
+            return f.read()
+
+    mock_config_client.get_file_contents.side_effect = my_side_effect
+    return mock_config_client
+
+
+@pytest.fixture
+async def mock_id_gap(prefix: str = "BLXX-EA-DET-007:") -> UndulatorGap:
+    async with init_devices(mock=True):
+        mock_id_gap = UndulatorGap(prefix, "mock_id_gap")
+    assert mock_id_gap.name == "mock_id_gap"
+    set_mock_value(mock_id_gap.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_id_gap.velocity, 1)
+    set_mock_value(mock_id_gap.user_readback, 1)
+    set_mock_value(mock_id_gap.user_setpoint, "1")
+    set_mock_value(mock_id_gap.status, EnabledDisabledUpper.ENABLED)
+    return mock_id_gap
+
+
+@pytest.fixture
+async def mock_phase_axes(prefix: str = "BLXX-EA-DET-007:") -> UndulatorPhaseAxes:
+    async with init_devices(mock=True):
+        mock_phase_axes = UndulatorPhaseAxes(
+            prefix=prefix,
+            top_outer="RPQ1",
+            top_inner="RPQ2",
+            btm_outer="RPQ3",
+            btm_inner="RPQ4",
+        )
+    assert mock_phase_axes.name == "mock_phase_axes"
+    set_mock_value(mock_phase_axes.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_phase_axes.top_outer.velocity, 2)
+    set_mock_value(mock_phase_axes.top_inner.velocity, 2)
+    set_mock_value(mock_phase_axes.btm_outer.velocity, 2)
+    set_mock_value(mock_phase_axes.btm_inner.velocity, 2)
+    set_mock_value(mock_phase_axes.status, EnabledDisabledUpper.ENABLED)
+    return mock_phase_axes
+
+
+@pytest.fixture
+async def mock_jaw_phase(prefix: str = "BLXX-EA-DET-007:") -> UndulatorJawPhase:
+    async with init_devices(mock=True):
+        mock_jaw_phase = UndulatorJawPhase(
+            prefix=prefix, move_pv="RPQ1", jaw_phase="JAW"
+        )
+    set_mock_value(mock_jaw_phase.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_jaw_phase.jaw_phase.velocity, 2)
+    set_mock_value(mock_jaw_phase.jaw_phase.user_readback, 0)
+    set_mock_value(mock_jaw_phase.jaw_phase.user_setpoint_readback, 0)
+    set_mock_value(mock_jaw_phase.status, EnabledDisabledUpper.ENABLED)
+    return mock_jaw_phase

dodal/testing/fixtures/run_engine.py

@@ -3,6 +3,7 @@ Allow external repos to reuse these fixtures so defined in single place.
 """
 
 import asyncio
+import copy
 import os
 import threading
 import time
@@ -34,10 +35,13 @@ async def _ensure_running_bluesky_event_loop(_global_run_engine):
 
 @pytest.fixture()
 async def run_engine(_global_run_engine: RunEngine) -> AsyncGenerator[RunEngine, None]:
+    initial_md = copy.deepcopy(_global_run_engine.md)
     try:
         yield _global_run_engine
     finally:
+        # Clear subscriptions, cache, and reset metadata
         _global_run_engine.reset()
+        _global_run_engine.md = initial_md
 
 
 @pytest_asyncio.fixture(scope="session", loop_scope="session")

dodal/utils.py

@@ -11,7 +11,7 @@ from functools import update_wrapper, wraps
 from importlib import import_module
 from inspect import signature
 from os import environ
-from types import ModuleType
+from types import FunctionType, ModuleType
 from typing import (
     Any,
     Generic,
@@ -240,7 +240,8 @@ def make_device(
 def make_all_devices(
     module: str | ModuleType | None = None, include_skipped: bool = False, **kwargs
 ) -> tuple[dict[str, AnyDevice], dict[str, Exception]]:
-    """Makes all devices in the given beamline module.
+    """Makes all devices in the given beamline module, for those modules using device factories
+    as opposed to the DeviceManager.
 
     In cases of device interdependencies it ensures a device is created before any which
     depend on it.
@@ -413,7 +414,9 @@ def is_v2_device_factory(func: Callable) -> TypeGuard[V2DeviceFactory]:
 
 
 def is_any_device_factory(func: Callable) -> TypeGuard[AnyDeviceFactory]:
-    return is_v1_device_factory(func) or is_v2_device_factory(func)
+    return isinstance(func, FunctionType | DeviceInitializationController) and (
+        is_v1_device_factory(func) or is_v2_device_factory(func)
+    )
 
 
 def is_v2_device_type(obj: type[Any]) -> bool:

dodal/devices/electron_analyser/abstract/__init__.py

@@ -1,25 +0,0 @@
-from .base_detector import (
-    BaseElectronAnalyserDetector,
-)
-from .base_driver_io import AbstractAnalyserDriverIO, TAbstractAnalyserDriverIO
-from .base_region import (
-    AbstractBaseRegion,
-    AbstractBaseSequence,
-    TAbstractBaseRegion,
-    TAbstractBaseSequence,
-    TAcquisitionMode,
-    TLensMode,
-)
-
-__all__ = [
-    "AbstractBaseRegion",
-    "AbstractBaseSequence",
-    "TAbstractBaseRegion",
-    "TAbstractBaseSequence",
-    "TAcquisitionMode",
-    "TLensMode",
-    "AbstractAnalyserDriverIO",
-    "BaseElectronAnalyserDetector",
-    "AbstractAnalyserDriverIO",
-    "TAbstractAnalyserDriverIO",
-]

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -1,63 +0,0 @@
-from typing import Generic
-
-from bluesky.protocols import Reading, Triggerable
-from event_model import DataKey
-from ophyd_async.core import (
-    AsyncConfigurable,
-    AsyncReadable,
-    AsyncStatus,
-    Device,
-)
-from ophyd_async.epics.adcore import ADBaseController
-
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
-    TAbstractAnalyserDriverIO,
-)
-
-
-class BaseElectronAnalyserDetector(
-    Device,
-    Triggerable,
-    AsyncReadable,
-    AsyncConfigurable,
-    Generic[TAbstractAnalyserDriverIO],
-):
-    """
-    Detector for data acquisition of electron analyser. Can only acquire using settings
-    already configured for the device.
-
-    If possible, this should be changed to inherit from a StandardDetector. Currently,
-    StandardDetector forces you to use a file writer which doesn't apply here.
-    See issue https://github.com/bluesky/ophyd-async/issues/888
-    """
-
-    def __init__(
-        self,
-        controller: ADBaseController[TAbstractAnalyserDriverIO],
-        name: str = "",
-    ):
-        self._controller = controller
-        super().__init__(name)
-
-    @AsyncStatus.wrap
-    async def trigger(self) -> None:
-        await self._controller.arm()
-        await self._controller.wait_for_idle()
-
-    async def read(self) -> dict[str, Reading]:
-        return await self._controller.driver.read()
-
-    async def describe(self) -> dict[str, DataKey]:
-        data = await self._controller.driver.describe()
-        # Correct the shape for image
-        prefix = self._controller.driver.name + "-"
-        energy_size = len(await self._controller.driver.energy_axis.get_value())
-        angle_size = len(await self._controller.driver.angle_axis.get_value())
-        data[prefix + "image"]["shape"] = [angle_size, energy_size]
-        return data
-
-    async def read_configuration(self) -> dict[str, Reading]:
-        return await self._controller.driver.read_configuration()
-
-    async def describe_configuration(self) -> dict[str, DataKey]:
-        return await self._controller.driver.describe_configuration()

dodal/devices/electron_analyser/abstract/types.py

@@ -1,12 +0,0 @@
-from typing import TypeVar
-
-from ophyd_async.core import StrictEnum, SupersetEnum
-
-TAcquisitionMode = TypeVar("TAcquisitionMode", bound=StrictEnum)
-# Allow SupersetEnum. Specs analysers can connect to Lens and Psu mode separately to the
-# analyser which leaves the enum to either be "Not connected" OR the available enums
-# when connected.
-TLensMode = TypeVar("TLensMode", bound=SupersetEnum | StrictEnum)
-TPsuMode = TypeVar("TPsuMode", bound=SupersetEnum | StrictEnum)
-TPassEnergy = TypeVar("TPassEnergy", bound=StrictEnum | float)
-TPassEnergyEnum = TypeVar("TPassEnergyEnum", bound=StrictEnum)