dls-dodal 1.46.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

dodal/log.py

@@ -201,6 +201,7 @@ def set_up_all_logging_handlers(
     dev_mode: bool,
     error_log_buffer_lines: int,
     graylog_port: int | None = None,
+    debug_logging_path: Path | None = None,
 ) -> DodalLogHandlers:
     """Set up the default logging environment.
     Args:
@@ -213,10 +214,10 @@ def set_up_all_logging_handlers(
                                 buffer and write to file when encountering an error message.
         graylog_port:           The port to send graylog messages to, if None uses the
                                 default dodal port
+        debug_logging_path:     The location to store debug log files, if None uses `logging_path`
     Returns:
         A DodaLogHandlers TypedDict with the created handlers.
     """
-
     handlers: DodalLogHandlers = {
         "stream_handler": set_up_stream_handler(logger),
         "graylog_handler": set_up_graylog_handler(
@@ -224,7 +225,7 @@ def set_up_all_logging_handlers(
         ),
         "info_file_handler": set_up_INFO_file_handler(logger, logging_path, filename),
         "debug_memory_handler": set_up_DEBUG_memory_handler(
-            logger, logging_path, filename, error_log_buffer_lines
+            logger, debug_logging_path or logging_path, filename, error_log_buffer_lines
         ),
     }
 
@@ -238,35 +239,39 @@ def integrate_bluesky_and_ophyd_logging(parent_logger: logging.Logger):
 
 
 def do_default_logging_setup(dev_mode=False, graylog_port: int | None = None):
+    logging_path, debug_logging_path = get_logging_file_paths()
     set_up_all_logging_handlers(
         LOGGER,
-        get_logging_file_path(),
+        logging_path,
         "dodal.log",
         dev_mode,
         ERROR_LOG_BUFFER_LINES,
         graylog_port,
+        debug_logging_path,
     )
     integrate_bluesky_and_ophyd_logging(LOGGER)
 
 
-def get_logging_file_path() -> Path:
-    """Get the directory to write log files to.
+def get_logging_file_paths() -> tuple[Path, Path]:
+    """Get the directories to write log files to.
 
     If on a beamline, this will return '/dls_sw/$BEAMLINE/logs/bluesky' based on the
-    BEAMLINE envrionment variable. If no envrionment variable is found it will default
+    BEAMLINE environment variable. If no environment variable is found it will default
     to the tmp/dev directory.
 
     Returns:
-        logging_path (Path): Path to the log directory for the file handlers to write to.
+        tuple[Path, Path]: Paths to the standard log file and to the debug log file,
+                           for the file handlers to write to
     """
     beamline: str | None = environ.get("BEAMLINE")
-    logging_path: Path
 
     if beamline:
         logging_path = Path("/dls_sw/" + beamline + "/logs/bluesky/")
+        debug_logging_path = Path("/dls/tmp/" + beamline + "/logs/bluesky/")
     else:
         logging_path = Path("./tmp/dev/")
-    return logging_path
+        debug_logging_path = Path("./tmp/dev/")
+    return logging_path, debug_logging_path
 
 
 def get_graylog_configuration(
@@ -284,8 +289,3 @@ def get_graylog_configuration(
         return "localhost", 5555
     else:
         return "graylog-log-target.diamond.ac.uk", graylog_port or DEFAULT_GRAYLOG_PORT
-
-
-class _NoOpFileHandler:
-    def write(*args, **kwargs):
-        pass

dodal/plan_stubs/electron_analyser/__init__.py

@@ -0,0 +1,3 @@
+from .configure_driver import configure_analyser, configure_specs, configure_vgscienta
+
+__all__ = ["configure_analyser", "configure_specs", "configure_vgscienta"]

dodal/plan_stubs/electron_analyser/{configure_controller.py → configure_driver.py}

@@ -1,37 +1,44 @@
 from bluesky import plan_stubs as bps
+from bluesky.utils import MsgGenerator, plan
+from ophyd_async.epics.adcore import ADImageMode
 
-from dodal.devices.electron_analyser.abstract_analyser_io import (
+from dodal.common.types import MsgGenerator
+from dodal.devices.electron_analyser.abstract import (
     AbstractAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.abstract_region import (
     AbstractBaseRegion,
 )
-from dodal.devices.electron_analyser.specs_analyser_io import (
-    SpecsAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.specs_region import SpecsRegion
-from dodal.devices.electron_analyser.vgscienta_analyser_io import (
+from dodal.devices.electron_analyser.specs import SpecsAnalyserDriverIO, SpecsRegion
+from dodal.devices.electron_analyser.util import to_kinetic_energy
+from dodal.devices.electron_analyser.vgscienta import (
     VGScientaAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.vgscienta_region import (
     VGScientaRegion,
 )
 from dodal.log import LOGGER
 
 
+@plan
 def configure_analyser(
     analyser: AbstractAnalyserDriverIO,
     region: AbstractBaseRegion,
     excitation_energy: float,
-):
+) -> MsgGenerator:
     LOGGER.info(f'Configuring analyser with region "{region.name}"')
-    low_energy = region.to_kinetic_energy(region.low_energy, excitation_energy)
-    high_energy = region.to_kinetic_energy(region.high_energy, excitation_energy)
+
+    low_energy = to_kinetic_energy(
+        region.low_energy, region.energy_mode, excitation_energy
+    )
+    high_energy = to_kinetic_energy(
+        region.high_energy, region.energy_mode, excitation_energy
+    )
     pass_energy_type = analyser.pass_energy_type
     pass_energy = pass_energy_type(region.pass_energy)
+
     # Set detector settings, wait for them all to have completed
     # fmt: off
     yield from bps.mv(
+        analyser.region_name, region.name,
+        analyser.energy_mode, region.energy_mode,
+        analyser.excitation_energy, excitation_energy,
         analyser.low_energy, low_energy,
         analyser.high_energy, high_energy,
         analyser.slices, region.slices,
@@ -43,13 +50,14 @@ def configure_analyser(
     # fmt: on
 
 
+@plan
 def configure_specs(
     analyser: SpecsAnalyserDriverIO, region: SpecsRegion, excitation_energy: float
-):
+) -> MsgGenerator:
     yield from configure_analyser(analyser, region, excitation_energy)
     # fmt: off
     yield from bps.mv(
-        analyser.values, region.values,
+        analyser.snapshot_values, region.values,
         analyser.psu_mode, region.psu_mode,
     )
     # fmt: on
@@ -60,11 +68,14 @@ def configure_specs(
         yield from bps.mv(analyser.energy_step, region.energy_step)
 
 
+@plan
 def configure_vgscienta(
     analyser: VGScientaAnalyserDriverIO, region: VGScientaRegion, excitation_energy
-):
+) -> MsgGenerator:
     yield from configure_analyser(analyser, region, excitation_energy)
-    centre_energy = region.to_kinetic_energy(region.fix_energy, excitation_energy)
+    centre_energy = to_kinetic_energy(
+        region.fix_energy, region.energy_mode, excitation_energy
+    )
 
     # fmt: off
     yield from bps.mv(
@@ -75,6 +86,7 @@ def configure_vgscienta(
         analyser.x_channel_size, region.x_channel_size(),
         analyser.y_channel_size, region.y_channel_size(),
         analyser.detector_mode, region.detector_mode,
-        analyser.image_mode, "Single",
+        analyser.excitation_energy_source, region.excitation_energy_source,
+        analyser.image_mode, ADImageMode.SINGLE,
     )
     # fmt: on

dodal/common/signal_utils.py

@@ -1,88 +0,0 @@
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from bluesky.protocols import Reading
-from ophyd_async.core import SignalDatatypeT, SignalR, SignalRW, SoftSignalBackend
-
-SetHardwareType = Callable[[SignalDatatypeT], Coroutine[Any, Any, None]]
-
-
-class HardwareBackedSoftSignalBackend(SoftSignalBackend[SignalDatatypeT]):
-    def __init__(
-        self,
-        get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
-        set_to_hardware_func: SetHardwareType | None = None,
-        *args,
-        **kwargs,
-    ) -> None:
-        self.get_from_hardware_func = get_from_hardware_func
-        self.set_to_hardware_func = set_to_hardware_func
-        super().__init__(*args, **kwargs)
-
-    async def _update_value(self):
-        new_value = await self.get_from_hardware_func()
-        self.set_value(new_value)
-
-    async def get_reading(self) -> Reading:
-        await self._update_value()
-        return await super().get_reading()
-
-    async def get_value(self) -> SignalDatatypeT:
-        await self._update_value()
-        return await super().get_value()
-
-    async def put(self, value: SignalDatatypeT | None, wait: bool) -> None:
-        if self.set_to_hardware_func:
-            write_value = self.initial_value if value is None else value
-            await self.set_to_hardware_func(write_value)
-
-
-def create_rw_hardware_backed_soft_signal(
-    datatype: type[SignalDatatypeT],
-    get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
-    set_to_hardware_func: SetHardwareType,
-    units: str | None = None,
-    precision: int | None = None,
-):
-    """Creates a soft signal that, when read will call the function passed into
-    `get_from_hardware_func` and return this. When set it will call `set_to_hardware_func`
-    and send something to the hardware.
-
-    This will allow you to make soft signals derived from arbitrary hardware signals.
-    However, calling subscribe on this signal does not give you a sensible value. See https://github.com/bluesky/ophyd-async/issues/525
-    for a more full solution.
-    """
-    return SignalRW(
-        backend=HardwareBackedSoftSignalBackend(
-            get_from_hardware_func,
-            set_to_hardware_func,
-            datatype,
-            units=units,
-            precision=precision,
-        )
-    )
-
-
-def create_r_hardware_backed_soft_signal(
-    datatype: type[SignalDatatypeT],
-    get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
-    units: str | None = None,
-    precision: int | None = None,
-):
-    """Creates a soft signal that, when read will call the function passed into
-    `get_from_hardware_func` and return this.
-
-    This will allow you to make soft signals derived from arbitrary hardware signals.
-    However, calling subscribe on this signal does not give you a sensible value and
-    the signal is currently read only. See https://github.com/bluesky/ophyd-async/issues/525
-    for a more full solution.
-    """
-    return SignalR(
-        backend=HardwareBackedSoftSignalBackend(
-            get_from_hardware_func,
-            None,
-            datatype,
-            units=units,
-            precision=precision,
-        )
-    )

dodal/devices/electron_analyser/abstract_analyser_io.py

@@ -1,47 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import TypeVar
-
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.core import epics_signal_rw
-
-from dodal.devices.electron_analyser.abstract_region import EnergyMode
-
-
-class AbstractAnalyserDriverIO(ABC, StandardReadable):
-    """
-    Generic device to configure electron analyser with new region settings.
-    Electron analysers should inherit from this class for further specialisation.
-    """
-
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
-            self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
-            self.slices = epics_signal_rw(int, prefix + "SLICES")
-            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
-            self.pass_energy = epics_signal_rw(
-                self.pass_energy_type, prefix + "PASS_ENERGY"
-            )
-            self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
-            self.iterations = epics_signal_rw(int, prefix + "NumExposures")
-            self.acquisition_mode = epics_signal_rw(str, prefix + "ACQ_MODE")
-
-        super().__init__(name)
-
-    def to_kinetic_energy(
-        self, value: float, excitation_energy: float, mode: EnergyMode
-    ) -> float:
-        return excitation_energy - value if mode == EnergyMode.BINDING else value
-
-    @property
-    @abstractmethod
-    def pass_energy_type(self) -> type:
-        """
-        Return the type the pass_energy should be. Each one is unfortunately different
-        for the underlying analyser software and cannot be changed on epics side.
-        """
-
-
-TAbstractAnalyserDriverIO = TypeVar(
-    "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
-)

dodal/devices/electron_analyser/specs_analyser_io.py

@@ -1,19 +0,0 @@
-from ophyd_async.epics.core import epics_signal_rw
-
-from dodal.devices.electron_analyser.abstract_analyser_io import (
-    AbstractAnalyserDriverIO,
-)
-
-
-class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
-            self.values = epics_signal_rw(int, prefix + "VALUES")
-            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
-
-        super().__init__(prefix, name)
-
-    @property
-    def pass_energy_type(self) -> type:
-        return float

dodal/devices/electron_analyser/vgscienta_analyser_io.py

@@ -1,26 +0,0 @@
-from ophyd_async.epics.core import epics_signal_rw
-
-from dodal.devices.electron_analyser.abstract_analyser_io import (
-    AbstractAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.vgscienta_region import (
-    DetectorMode,
-)
-
-
-class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
-            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
-            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
-            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
-            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
-            self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
-            self.image_mode = epics_signal_rw(str, prefix + "ImageMode")
-
-        super().__init__(prefix, name)
-
-    @property
-    def pass_energy_type(self) -> type:
-        return str

dodal/devices/logging_ophyd_device.py

@@ -1,17 +0,0 @@
-from ophyd import Device
-from ophyd.log import logger as ophyd_logger
-
-
-class InfoLoggingDevice(Device):
-    def wait_for_connection(self, all_signals=False, timeout=2.0):
-        class_name = self.__class__.__name__
-        ophyd_logger.info(
-            f"{class_name} waiting for connection, {'not' if all_signals else ''} waiting for all signals, timeout = {timeout}s.",
-        )
-        try:
-            super().wait_for_connection(all_signals, timeout)
-        except TimeoutError as e:
-            ophyd_logger.error(f"{class_name} failed to connect.", exc_info=True)
-            raise e
-        else:
-            ophyd_logger.info(f"{class_name} connected.")