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

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/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.apple2_undulator 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/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/util/lookup_tables_apple2.py

@@ -1,390 +0,0 @@
-"""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": {
-    "energies": {
-      "<min_energy>": {
-        "low": <float>,
-        "high": <float>,
-        "poly": <numpy.poly1d>
-      },
-      ...
-    },
-    "limit": {
-      "minimum": <float>,
-      "maximum": <float>
-    }
-  },
-}
-
-"""
-
-import csv
-import io
-from collections.abc import Generator
-from pathlib import Path
-
-import numpy as np
-from daq_config_server.client import ConfigServer
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    RootModel,
-    field_serializer,
-    field_validator,
-)
-
-from dodal.devices.apple2_undulator import Pol
-from dodal.log import LOGGER
-
-DEFAULT_GAP_FILE = "IDEnergy2GapCalibrations.csv"
-DEFAULT_PHASE_FILE = "IDEnergy2PhaseCalibrations.csv"
-
-
-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"}
-
-
-class LookupTableConfig(BaseModel):
-    source: tuple[str, str] | None = None
-    mode: str = "Mode"
-    min_energy: str = "MinEnergy"
-    max_energy: str = "MaxEnergy"
-    poly_deg: list[str] = Field(default_factory=lambda: DEFAULT_POLY_DEG)
-    mode_name_convert: dict[str, str] = Field(default_factory=lambda: MODE_NAME_CONVERT)
-
-
-class EnergyMinMax(BaseModel):
-    minimum: float
-    maximum: float
-
-
-class EnergyCoverageEntry(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)  # So np.poly1d can be used.
-    low: float
-    high: float
-    poly: np.poly1d
-
-    @field_validator("poly", mode="before")
-    @classmethod
-    def validate_and_convert_poly(cls, value):
-        """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(RootModel[dict[float, EnergyCoverageEntry]]):
-    pass
-
-
-class LookupTableEntries(BaseModel):
-    energies: EnergyCoverage
-    limit: EnergyMinMax
-
-
-class LookupTable(RootModel[dict[Pol, LookupTableEntries]]):
-    # Allow to auto specify a dict if one not provided
-    def __init__(self, root: dict[Pol, LookupTableEntries] | None = None):
-        super().__init__(root=root or {})
-
-
-class GapPhaseLookupTables(BaseModel):
-    gap: LookupTable = Field(default_factory=lambda: LookupTable())
-    phase: LookupTable = Field(default_factory=lambda: LookupTable())
-
-
-def convert_csv_to_lookup(
-    file_contents: str,
-    lut_config: LookupTableConfig,
-    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
-    """
-
-    def process_row(row: dict, lut: LookupTable):
-        """Process a single row from the CSV file and update the lookup table."""
-        mode_value = str(row[lut_config.mode]).lower()
-        if mode_value in lut_config.mode_name_convert:
-            mode_value = lut_config.mode_name_convert[f"{mode_value}"]
-        mode_value = Pol(mode_value)
-
-        # Create polynomial object for energy-to-gap/phase conversion
-        coefficients = [float(row[coef]) for coef in lut_config.poly_deg]
-        if mode_value not in lut.root:
-            lut.root[mode_value] = generate_lookup_table_entry(
-                min_energy=float(row[lut_config.min_energy]),
-                max_energy=float(row[lut_config.max_energy]),
-                poly1d_param=coefficients,
-            )
-
-        else:
-            lut.root[mode_value].energies.root[float(row[lut_config.min_energy])] = (
-                EnergyCoverageEntry(
-                    low=float(row[lut_config.min_energy]),
-                    high=float(row[lut_config.max_energy]),
-                    poly=np.poly1d(coefficients),
-                )
-            )
-
-        # Update energy limits
-        lut.root[mode_value].limit.minimum = min(
-            lut.root[mode_value].limit.minimum,
-            float(row[lut_config.min_energy]),
-        )
-        lut.root[mode_value].limit.maximum = max(
-            lut.root[mode_value].limit.maximum,
-            float(row[lut_config.max_energy]),
-        )
-        return lut
-
-    reader = csv.DictReader(read_file_and_skip(file_contents, skip_line_start_with))
-    lut = LookupTable()
-
-    for row in reader:
-        # If there are multiple source only convert requested.
-        if lut_config.source is not None:
-            if row[lut_config.source[0]] == lut_config.source[1]:
-                process_row(row=row, lut=lut)
-        else:
-            process_row(row=row, lut=lut)
-
-    # Check if our LookupTable is empty after processing, raise error if it is.
-    if not lut.root:
-        raise RuntimeError(
-            "LookupTable content is empty, failed to convert the file contents to "
-            "a LookupTable!"
-        )
-    return lut
-
-
-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
-
-
-def get_poly(
-    energy: float,
-    pol: Pol,
-    lookup_table: LookupTable,
-) -> 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 (eV).
-    pol:
-        Polarisation mode (Pol enum).
-    lookup_table:
-        The converted lookup table dictionary for either 'gap' or 'phase'.
-    """
-    if (
-        energy < lookup_table.root[pol].limit.minimum
-        or energy > lookup_table.root[pol].limit.maximum
-    ):
-        raise ValueError(
-            "Demanding energy must lie between"
-            + f" {lookup_table.root[pol].limit.minimum}"
-            + f" and {lookup_table.root[pol].limit.maximum} eV!"
-        )
-    else:
-        for energy_range in lookup_table.root[pol].energies.root.values():
-            if energy >= energy_range.low and energy < energy_range.high:
-                return energy_range.poly
-
-    raise ValueError(
-        "Cannot find polynomial coefficients for your requested energy."
-        + " There might be gap in the calibration lookup table."
-    )
-
-
-def generate_lookup_table_entry(
-    min_energy: float, max_energy: float, poly1d_param: list[float]
-) -> LookupTableEntries:
-    return LookupTableEntries(
-        energies=EnergyCoverage(
-            {
-                min_energy: EnergyCoverageEntry(
-                    low=min_energy,
-                    high=max_energy,
-                    poly=np.poly1d(poly1d_param),
-                )
-            }
-        ),
-        limit=EnergyMinMax(
-            minimum=float(min_energy),
-            maximum=float(max_energy),
-        ),
-    )
-
-
-def generate_lookup_table(
-    pol: Pol, min_energy: float, max_energy: float, poly1d_param: list[float]
-) -> LookupTable:
-    return LookupTable(
-        {pol: generate_lookup_table_entry(min_energy, max_energy, poly1d_param)}
-    )
-
-
-def make_phase_tables(
-    pols: list[Pol],
-    min_energies: list[float],
-    max_energies: list[float],
-    poly1d_params: list[list[float]],
-) -> LookupTable:
-    """Generate a dictionary containing multiple lookuptable entries
-    for provided polarisations."""
-    lookuptable_phase = LookupTable()
-    for i in range(len(pols)):
-        lookuptable_phase.root[pols[i]] = generate_lookup_table_entry(
-            min_energy=min_energies[i],
-            max_energy=max_energies[i],
-            poly1d_param=poly1d_params[i],
-        )
-
-    return lookuptable_phase
-
-
-class EnergyMotorLookup:
-    """
-    Handles lookup tables for Apple2 ID, converting energy and polarisation to gap
-    and phase. Fetches and parses lookup tables from a config server, supports dynamic
-    updates, and validates input. If custom logic is required for lookup tables, sub
-    classes should override the _update_gap_lut and _update_phase_lut methods.
-
-    After update_lookuptable() has populated the 'gap' and 'phase' tables,
-    `get_motor_from_energy()` can be used to compute (gap, phase) for a requested
-    (energy, pol) pair.
-    """
-
-    def __init__(
-        self,
-        config_client: ConfigServer,
-        lut_config: LookupTableConfig,
-        gap_path: Path,
-        phase_path: Path,
-    ):
-        """Initialise the EnergyMotorLookup class with lookup table headers provided.
-
-        Parameters:
-        -----------
-        config_client:
-            The config server client to fetch the look up table data.
-        lut_config:
-            Configuration that defines how to process file contents into a LookupTable
-        gap_path:
-            File path to the gap lookup table.
-        phase_path:
-            File path to the phase lookup table.
-        """
-        self.lookup_tables = GapPhaseLookupTables()
-        self.config_client = config_client
-        self.lut_config = lut_config
-        self.gap_path = gap_path
-        self.phase_path = phase_path
-        self._available_pol = []
-
-    @property
-    def available_pol(self) -> list[Pol]:
-        return self._available_pol
-
-    @available_pol.setter
-    def available_pol(self, value: list[Pol]) -> None:
-        self._available_pol = value
-
-    def _update_gap_lut(self) -> None:
-        file_contents = self.config_client.get_file_contents(
-            self.gap_path, reset_cached_result=True
-        )
-        self.lookup_tables.gap = convert_csv_to_lookup(
-            file_contents, lut_config=self.lut_config
-        )
-        self.available_pol = list(self.lookup_tables.gap.root.keys())
-
-    def _update_phase_lut(self) -> None:
-        file_contents = self.config_client.get_file_contents(
-            self.phase_path, reset_cached_result=True
-        )
-        self.lookup_tables.phase = convert_csv_to_lookup(
-            file_contents, lut_config=self.lut_config
-        )
-
-    def update_lookuptables(self):
-        """
-        Update lookup tables from files and validate their format.
-        """
-        LOGGER.info("Updating lookup table from file for gap.")
-        self._update_gap_lut()
-        LOGGER.info("Updating lookup table from file for phase.")
-        self._update_phase_lut()
-
-    def get_motor_from_energy(self, energy: float, pol: Pol) -> tuple[float, float]:
-        """
-        Convert energy and polarisation to gap and phase motor positions.
-
-        Parameters:
-        -----------
-        energy : float
-            Desired energy in eV.
-        pol : Pol
-            Polarisation mode.
-
-        Returns:
-        ----------
-        tuple[float, float]
-            (gap, phase) motor positions.
-        """
-        if self.available_pol == []:
-            self.update_lookuptables()
-
-        gap_poly = get_poly(lookup_table=self.lookup_tables.gap, energy=energy, pol=pol)
-        phase_poly = get_poly(
-            lookup_table=self.lookup_tables.phase,
-            energy=energy,
-            pol=pol,
-        )
-        return gap_poly(energy), phase_poly(energy)