mx-bluesky 1.5.15__py3-none-any.whl → 1.5.16__py3-none-any.whl

mx_bluesky/hyperion/in_process_runner.py

@@ -0,0 +1,132 @@
+from collections.abc import Callable, Sequence
+from functools import partial
+from typing import Any
+
+from blueapi.core import BlueskyContext
+from bluesky import plan_stubs as bps
+from bluesky.utils import MsgGenerator, RequestAbort
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.detector.detector_motion import DetectorMotion
+from dodal.devices.motors import XYZStage
+from dodal.devices.robot import BartRobot
+from dodal.devices.smargon import Smargon
+
+from mx_bluesky.common.parameters.components import MxBlueskyParameters
+from mx_bluesky.common.parameters.constants import Status
+from mx_bluesky.common.utils.context import (
+    device_composite_from_context,
+    find_device_in_context,
+)
+from mx_bluesky.common.utils.exceptions import WarningError
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.blueapi_plans import clean_up_udc, move_to_udc_default_state
+from mx_bluesky.hyperion.experiment_plans import load_centre_collect_full
+from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
+    create_devices,
+)
+from mx_bluesky.hyperion.experiment_plans.udc_default_state import UDCDefaultDevices
+from mx_bluesky.hyperion.parameters.components import UDCCleanup, UDCDefaultState, Wait
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.plan_runner import PlanError, PlanRunner
+
+
+class InProcessRunner(PlanRunner):
+    """Runner that executes experiments from inside a running Bluesky plan"""
+
+    def __init__(self, context: BlueskyContext, dev_mode: bool) -> None:
+        super().__init__(context, dev_mode)
+        self._current_status: Status = Status.IDLE
+
+    def decode_and_execute(
+        self, current_visit: str | None, parameter_list: Sequence[MxBlueskyParameters]
+    ) -> MsgGenerator:
+        for parameters in parameter_list:
+            LOGGER.info(
+                f"Executing plan with parameters: {parameters.model_dump_json(indent=2)}"
+            )
+            match parameters:
+                case LoadCentreCollect():
+                    current_visit = parameters.visit
+                    devices: Any = create_devices(self.context)
+                    yield from self.execute_plan(
+                        partial(load_centre_collect_full, devices, parameters)
+                    )
+                case Wait():
+                    yield from self.execute_plan(partial(_runner_sleep, parameters))
+                case UDCDefaultState():
+                    udc_default_devices: UDCDefaultDevices = (
+                        device_composite_from_context(self.context, UDCDefaultDevices)
+                    )
+                    yield from move_to_udc_default_state(udc_default_devices)
+                case UDCCleanup():
+                    yield from _clean_up_udc(self.context, current_visit)
+                case _:
+                    raise AssertionError(
+                        f"Unsupported instruction decoded from agamemnon {type(parameters)}"
+                    )
+        return current_visit
+
+    def execute_plan(
+        self,
+        experiment: Callable[[], MsgGenerator],
+    ) -> MsgGenerator:
+        """Execute the specified experiment plan.
+        Args:
+            experiment: The experiment to run
+        Raises:
+            PlanError: If the plan raised an exception
+            RequestAbort: If the RunEngine aborted during execution"""
+
+        self._current_status = Status.BUSY
+
+        try:
+            yield from self.check_external_callbacks_are_alive()
+            yield from experiment()
+            self._current_status = Status.IDLE
+        except WarningError as e:
+            LOGGER.warning("Plan failed with warning", exc_info=e)
+            self._current_status = Status.FAILED
+        except RequestAbort:
+            # This will occur when the run engine processes an abort when we shut down
+            LOGGER.info("UDC Runner aborting")
+            raise
+        except Exception as e:
+            LOGGER.error("Plan failed with exception", exc_info=e)
+            self._current_status = Status.FAILED
+            raise PlanError("Exception thrown in plan execution") from e
+
+    def shutdown(self):
+        """Performs a prompt shutdown. Aborts the run engine and terminates the loop
+        waiting for messages."""
+
+        LOGGER.info("Shutting down: Stopping the run engine gracefully")
+        if self.current_status != Status.ABORTING:
+            self._current_status = Status.ABORTING
+            self.request_run_engine_abort()
+            return
+
+    @property
+    def current_status(self) -> Status:
+        return self._current_status
+
+
+def _runner_sleep(parameters: Wait) -> MsgGenerator:
+    yield from bps.sleep(parameters.duration_s)
+
+
+def _clean_up_udc(context: BlueskyContext, visit: str) -> MsgGenerator:
+    robot = find_device_in_context(context, "robot", BartRobot)
+    smargon = find_device_in_context(context, "smargon", Smargon)
+    aperture_scatterguard = find_device_in_context(
+        context, "aperture_scatterguard", ApertureScatterguard
+    )
+    lower_gonio = find_device_in_context(context, "lower_gonio", XYZStage)
+    detector_motion = find_device_in_context(context, "detector_motion", DetectorMotion)
+    yield from clean_up_udc(
+        visit,
+        robot=robot,
+        smargon=smargon,
+        aperture_scatterguard=aperture_scatterguard,
+        lower_gonio=lower_gonio,
+        detector_motion=detector_motion,
+    )

mx_bluesky/hyperion/parameters/cli.py

@@ -1,20 +1,32 @@
 import argparse
 from enum import StrEnum
+from pathlib import Path
 
 from pydantic.dataclasses import dataclass
 
 from mx_bluesky._version import version
+from mx_bluesky.hyperion.parameters.constants import HyperionConstants
 
 
 class HyperionMode(StrEnum):
     GDA = "gda"
     UDC = "udc"
+    SUPERVISOR = "supervisor"
 
 
 @dataclass
 class HyperionArgs:
     mode: HyperionMode
     dev_mode: bool = False
+    client_config: str | None = None
+    supervisor_config: str | None = None
+
+
+@dataclass
+class CallbackArgs:
+    dev_mode: bool = False
+    watchdog_port: int = HyperionConstants.HYPERION_PORT
+    stomp_config: Path | None = None
 
 
 def _add_callback_relevant_args(parser: argparse.ArgumentParser) -> None:
@@ -26,12 +38,27 @@ def _add_callback_relevant_args(parser: argparse.ArgumentParser) -> None:
     )
 
 
-def parse_callback_dev_mode_arg() -> bool:
-    """Returns the bool representing the 'dev_mode' argument."""
+def parse_callback_args() -> CallbackArgs:
+    """Parse the CLI arguments for the watchdog port and dev mode into a CallbackArgs instance."""
     parser = argparse.ArgumentParser()
     _add_callback_relevant_args(parser)
+    parser.add_argument(
+        "--watchdog-port",
+        type=int,
+        help="Liveness port for callbacks to ping regularly",
+    )
+    parser.add_argument(
+        "--stomp-config",
+        type=Path,
+        default=None,
+        help="Specify config yaml for the STOMP backend (default is 0MQ)",
+    )
     args = parser.parse_args()
-    return args.dev
+    return CallbackArgs(
+        dev_mode=args.dev,
+        watchdog_port=args.watchdog_port,
+        stomp_config=args.stomp_config,
+    )
 
 
 def parse_cli_args() -> HyperionArgs:
@@ -53,5 +80,17 @@ def parse_cli_args() -> HyperionArgs:
         type=HyperionMode,
         choices=HyperionMode.__members__.values(),
     )
+    parser.add_argument(
+        "--client-config", help="Specify the blueapi client configuration file."
+    )
+    parser.add_argument(
+        "--supervisor-config",
+        help="Specify the supervisor bluesky context configuration file.",
+    )
     args = parser.parse_args()
-    return HyperionArgs(dev_mode=args.dev or False, mode=args.mode)
+    return HyperionArgs(
+        dev_mode=args.dev or False,
+        mode=args.mode,
+        supervisor_config=args.supervisor_config,
+        client_config=args.client_config,
+    )

mx_bluesky/hyperion/parameters/components.py

@@ -8,3 +8,16 @@ class Wait(MxBlueskyParameters):
     """
 
     duration_s: float
+
+
+class UDCDefaultState(MxBlueskyParameters):
+    """Represents an instruction to execute the UDC default state plan."""
+
+    pass
+
+
+class UDCCleanup(MxBlueskyParameters):
+    """Represents an instruction to perform UDC Cleanup,
+    in which the detector shutter is closed and a robot unload is performed."""
+
+    pass

mx_bluesky/hyperion/parameters/constants.py

@@ -7,7 +7,6 @@ from mx_bluesky.common.parameters.constants import (
     DeviceSettingsConstants,
     DocDescriptorNames,
     EnvironmentConstants,
-    ExperimentParamConstants,
     FeatureSettings,
     FeatureSettingSources,
     HardwareConstants,
@@ -27,7 +26,6 @@ class I03Constants:
     OAV_CENTRING_FILE = OavConstants.OAV_CONFIG_JSON
     SHUTTER_TIME_S = 0.06
     USE_GPU_RESULTS = True
-    OMEGA_FLIP = True
     ALTERNATE_ROTATION_DIRECTION = True
 
 
@@ -59,22 +57,17 @@ class HyperionFeatureSettings(FeatureSettings):
 class HyperionConstants:
     ZOCALO_ENV = EnvironmentConstants.ZOCALO_ENV
     HARDWARE = HardwareConstants()
-    I03 = I03Constants()
-    PARAM = ExperimentParamConstants()
     PLAN = PlanNameConstants()
     WAIT = PlanGroupCheckpointConstants()
     HYPERION_PORT = 5005
+    SUPERVISOR_PORT = 5006
     CALLBACK_0MQ_PROXY_PORTS = (5577, 5578)
     DESCRIPTORS = DocDescriptorNames()
-    CONFIG_SERVER_URL = (
-        "http://fake-url-not-real"
-        if TEST_MODE
-        else "https://daq-config.diamond.ac.uk/api"
-    )
     GRAYLOG_PORT = 12232  # Hyperion stream
     GRAYLOG_STREAM_ID = "66264f5519ccca6d1c9e4e03"
     PARAMETER_SCHEMA_DIRECTORY = "src/hyperion/parameters/schemas/"
     LOG_FILE_NAME = "hyperion.log"
+    SUPERVISOR_LOG_FILE_NAME = "hyperion-supervisor.log"
     DEVICE_SETTINGS_CONSTANTS = DeviceSettingsConstants()
 
 

mx_bluesky/hyperion/parameters/load_centre_collect.py

@@ -8,10 +8,12 @@ from mx_bluesky.common.parameters.components import (
     WithSample,
     WithVisit,
 )
+from mx_bluesky.common.parameters.rotation import (
+    RotationScan,
+)
 from mx_bluesky.hyperion.parameters.robot_load import (
     RobotLoadThenCentre,
 )
-from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
 T = TypeVar("T", bound=BaseModel)
 

mx_bluesky/hyperion/plan_runner.py

@@ -1,13 +1,14 @@
 import threading
 import time
-from collections.abc import Callable
+from abc import abstractmethod
+from collections.abc import Sequence
 
 from blueapi.core import BlueskyContext
 from bluesky import plan_stubs as bps
-from bluesky.utils import MsgGenerator, RequestAbort
+from bluesky.utils import MsgGenerator
 
+from mx_bluesky.common.parameters.components import MxBlueskyParameters
 from mx_bluesky.common.parameters.constants import Status
-from mx_bluesky.common.utils.exceptions import WarningError
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.runner import BaseRunner
 
@@ -19,63 +20,52 @@ class PlanError(Exception):
 
 
 class PlanRunner(BaseRunner):
-    """Runner that executes experiments from inside a running Bluesky plan"""
-
-    EXTERNAL_CALLBACK_WATCHDOG_TIMER_S = 60
     EXTERNAL_CALLBACK_POLL_INTERVAL_S = 1
+    EXTERNAL_CALLBACK_WATCHDOG_TIMER_S = 60
 
-    def __init__(self, context: BlueskyContext, dev_mode: bool) -> None:
+    def __init__(self, context: BlueskyContext, dev_mode: bool):
         super().__init__(context)
-        self.current_status: Status = Status.IDLE
-        self.is_dev_mode = dev_mode
         self._callbacks_started = False
         self._callback_watchdog_expiry = time.monotonic()
+        self.is_dev_mode = dev_mode
 
-    def execute_plan(
-        self,
-        experiment: Callable[[], MsgGenerator],
+    @abstractmethod
+    def decode_and_execute(
+        self, current_visit: str | None, parameter_list: Sequence[MxBlueskyParameters]
     ) -> MsgGenerator:
-        """Execute the specified experiment plan.
-        Args:
-            experiment: The experiment to run
-        Raises:
-            PlanError: If the plan raised an exception
-            RequestAbort: If the RunEngine aborted during execution"""
-
-        self.current_status = Status.BUSY
-
-        try:
-            callback_expiry = time.monotonic() + self.EXTERNAL_CALLBACK_WATCHDOG_TIMER_S
-            while time.monotonic() < callback_expiry:
-                if self._callbacks_started:
-                    break
-                # If on first launch the external callbacks aren't started yet, wait until they are
-                LOGGER.info("Waiting for external callbacks to start")
-                yield from bps.sleep(self.EXTERNAL_CALLBACK_POLL_INTERVAL_S)
-            else:
-                raise RuntimeError("External callbacks not running - try restarting")
-
-            if not self._external_callbacks_are_alive():
-                raise RuntimeError(
-                    "External callback watchdog timer expired, check external callbacks are running."
-                )
-            yield from experiment()
-            self.current_status = Status.IDLE
-        except WarningError as e:
-            LOGGER.warning("Plan failed with warning", exc_info=e)
-            self.current_status = Status.FAILED
-        except RequestAbort:
-            # This will occur when the run engine processes an abort when we shut down
-            LOGGER.info("UDC Runner aborting")
-            raise
-        except Exception as e:
-            LOGGER.error("Plan failed with exception", exc_info=e)
-            self.current_status = Status.FAILED
-            raise PlanError("Exception thrown in plan execution") from e
-
-    def shutdown(self):
-        """Performs a prompt shutdown. Aborts the run engine and terminates the loop
-        waiting for messages."""
+        pass
+
+    def reset_callback_watchdog_timer(self):
+        """Called periodically to reset the watchdog timer when the external callbacks ping us."""
+        self._callbacks_started = True
+        self._callback_watchdog_expiry = (
+            time.monotonic() + self.EXTERNAL_CALLBACK_WATCHDOG_TIMER_S
+        )
+
+    @property
+    @abstractmethod
+    def current_status(self) -> Status:
+        pass
+
+    def check_external_callbacks_are_alive(self):
+        callback_expiry = time.monotonic() + self.EXTERNAL_CALLBACK_WATCHDOG_TIMER_S
+        while time.monotonic() < callback_expiry:
+            if self._callbacks_started:
+                break
+            # If on first launch the external callbacks aren't started yet, wait until they are
+            LOGGER.info("Waiting for external callbacks to start")
+            yield from bps.sleep(self.EXTERNAL_CALLBACK_POLL_INTERVAL_S)
+        else:
+            raise RuntimeError("External callbacks not running - try restarting")
+
+        if not self._external_callbacks_are_alive():
+            raise RuntimeError(
+                "External callback watchdog timer expired, check external callbacks are running."
+            )
+
+    def request_run_engine_abort(self):
+        """Asynchronously request an abort from the run engine. This cannot be done from
+        inside the main thread."""
 
         def issue_abort():
             try:
@@ -89,19 +79,8 @@ class PlanRunner(BaseRunner):
                     exc_info=e,
                 )
 
-        LOGGER.info("Shutting down: Stopping the run engine gracefully")
-        if self.current_status != Status.ABORTING:
-            self.current_status = Status.ABORTING
-            stopping_thread = threading.Thread(target=issue_abort)
-            stopping_thread.start()
-            return
-
-    def reset_callback_watchdog_timer(self):
-        """Called periodically to reset the watchdog timer when the external callbacks ping us."""
-        self._callbacks_started = True
-        self._callback_watchdog_expiry = (
-            time.monotonic() + self.EXTERNAL_CALLBACK_WATCHDOG_TIMER_S
-        )
+        stopping_thread = threading.Thread(target=issue_abort)
+        stopping_thread.start()
 
     def _external_callbacks_are_alive(self) -> bool:
         return time.monotonic() < self._callback_watchdog_expiry

mx_bluesky/hyperion/plan_runner_api.py

@@ -4,23 +4,22 @@ from flask import Flask
 from flask_restful import Api, Resource
 
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.parameters.constants import HyperionConstants
 from mx_bluesky.hyperion.plan_runner import PlanRunner
 
 
 # Ignore this function for code coverage as there is no way to shut down
 # a server once it is started.
-def create_server_for_udc(runner: PlanRunner) -> Thread:  # pragma: no cover
+def create_server_for_udc(runner: PlanRunner, port: int) -> Thread:  # pragma: no cover
     """Create a minimal API for Hyperion UDC mode"""
     app = create_app_for_udc(runner)
 
     flask_thread = Thread(
         target=app.run,
-        kwargs={"host": "0.0.0.0", "port": HyperionConstants.HYPERION_PORT},
+        kwargs={"host": "0.0.0.0", "port": port},
         daemon=True,
     )
     flask_thread.start()
-    LOGGER.info(f"Hyperion now listening on {HyperionConstants.HYPERION_PORT}")
+    LOGGER.info(f"Hyperion now listening on {port}")
     return flask_thread
 
 

mx_bluesky/hyperion/supervisor/__init__.py

@@ -0,0 +1,3 @@
+from mx_bluesky.hyperion.supervisor._supervisor import SupervisorRunner
+
+__all__ = ["SupervisorRunner"]

mx_bluesky/hyperion/supervisor/_supervisor.py

@@ -0,0 +1,116 @@
+from collections.abc import Sequence
+
+from blueapi.client.client import BlueapiClient
+from blueapi.client.event_bus import BlueskyStreamingError
+from blueapi.config import ApplicationConfig
+from blueapi.core import BlueskyContext
+from blueapi.service.model import TaskRequest
+from bluesky import plan_stubs as bps
+from bluesky.utils import MsgGenerator
+
+from mx_bluesky.common.parameters.components import MxBlueskyParameters
+from mx_bluesky.common.parameters.constants import Status
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.parameters.components import UDCCleanup, UDCDefaultState, Wait
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.plan_runner import PlanError, PlanRunner
+
+
+class SupervisorRunner(PlanRunner):
+    """Runner that executes plans by delegating to a remote blueapi instance"""
+
+    def __init__(
+        self,
+        bluesky_context: BlueskyContext,
+        client_config: ApplicationConfig,
+        dev_mode: bool,
+    ):
+        super().__init__(bluesky_context, dev_mode)
+        self.blueapi_client = BlueapiClient.from_config(client_config)
+        self._current_status = Status.IDLE
+
+    def decode_and_execute(
+        self, current_visit: str | None, parameter_list: Sequence[MxBlueskyParameters]
+    ) -> MsgGenerator:
+        try:
+            yield from self.check_external_callbacks_are_alive()
+        except Exception as e:
+            raise PlanError(f"Exception raised during plan execution: {e}") from e
+        instrument_session = current_visit or "NO_VISIT"
+        try:
+            if self._current_status == Status.ABORTING:
+                raise PlanError("Plan execution cancelled, supervisor is shutting down")
+            self._current_status = Status.BUSY
+            for parameters in parameter_list:
+                LOGGER.info(
+                    f"Executing plan with parameters: {parameters.model_dump_json(indent=2)}"
+                )
+                match parameters:
+                    case LoadCentreCollect():
+                        task_request = TaskRequest(
+                            name="load_centre_collect",
+                            params={"parameters": parameters},
+                            instrument_session=instrument_session,
+                        )
+                        self._run_task_remotely(task_request)
+                    case Wait():
+                        yield from bps.sleep(parameters.duration_s)
+                    case UDCDefaultState():
+                        task_request = TaskRequest(
+                            name="move_to_udc_default_state",
+                            params={},
+                            instrument_session=instrument_session,
+                        )
+                        self._run_task_remotely(task_request)
+                    case UDCCleanup():
+                        task_request = TaskRequest(
+                            name="clean_up_udc",
+                            params={"visit": current_visit},
+                            instrument_session=instrument_session,
+                        )
+                        self._run_task_remotely(task_request)
+                    case _:
+                        raise AssertionError(
+                            f"Unsupported instruction decoded from agamemnon {type(parameters)}"
+                        )
+        except:
+            self._current_status = Status.FAILED
+            raise
+        else:
+            self._current_status = Status.IDLE
+        return current_visit
+
+    @property
+    def current_status(self) -> Status:
+        return self._current_status
+
+    def is_connected(self) -> bool:
+        try:
+            self.blueapi_client.get_state()
+        except Exception as e:
+            LOGGER.debug(f"Failed to get worker state: {e}")
+            return False
+        return True
+
+    def shutdown(self):
+        LOGGER.info(
+            "Hyperion supervisor received shutdown request, signalling abort to BlueAPI server..."
+        )
+        if self.current_status != Status.BUSY:
+            self.request_run_engine_abort()
+        else:
+            self._current_status = Status.ABORTING
+            self.blueapi_client.abort()
+
+    def _run_task_remotely(self, task_request: TaskRequest):
+        try:
+            self.blueapi_client.run_task(task_request)
+        except BlueskyStreamingError as e:
+            # We will receive a BlueskyStreamingError if the remote server
+            # processed an abort during plan execution, but this is not
+            # the only possible cause.
+            if self.current_status == Status.ABORTING:
+                LOGGER.info("Aborting local runner...")
+                self.request_run_engine_abort()
+            else:
+                raise PlanError(f"Exception raised during plan execution: {e}") from e

mx_bluesky/hyperion/supervisor/client_config.yaml

@@ -0,0 +1,6 @@
+# Configuration for the BlueAPI client running in the hyperion supervisor
+api:
+  url: http://localhost:5005
+stomp:
+  enabled: true
+  url: tcp://localhost:61613

mx_bluesky/hyperion/supervisor/supervisor_config.yaml

@@ -0,0 +1,10 @@
+# Configuration for the supervisor BlueAPI context
+# to access the beamline baton device
+env:
+  sources:
+    - kind: deviceManager
+      module: dodal.beamlines.i03_supervisor
+logging:
+  graylog:
+    url: "tcp://graylog-log-target.diamond.ac.uk:12232"
+    enabled: true

mx_bluesky/hyperion/supervisor/supervisor_dev_config.yaml

@@ -0,0 +1,9 @@
+# Configuration for the supervisor BlueAPI context
+# to access the beamline baton device
+env:
+  sources:
+    - kind: deviceManager
+      module: dodal.beamlines.i03_supervisor
+      mock: true
+  events:
+    broadcast_status_events: false

{mx_bluesky-1.5.15.dist-info → mx_bluesky-1.5.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mx-bluesky
-Version: 1.5.15
+Version: 1.5.16
 Summary: Bluesky tools for MX Beamlines at DLS
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License
@@ -236,41 +236,13 @@ Requires-Dist: semver
 Requires-Dist: deepdiff
 Requires-Dist: matplotlib
 Requires-Dist: cachetools
+Requires-Dist: bluesky-stomp>=0.2.0
 Requires-Dist: daq-config-server>=v1.0.0-rc.2
 Requires-Dist: blueapi>=1.8.0
 Requires-Dist: ophyd>=1.10.5
 Requires-Dist: ophyd-async>=0.14.0
 Requires-Dist: bluesky>=1.14.6
-Requires-Dist: dls-dodal==1.68.0
-Provides-Extra: dev
-Requires-Dist: black; extra == "dev"
-Requires-Dist: build; extra == "dev"
-Requires-Dist: diff-cover; extra == "dev"
-Requires-Dist: GitPython; extra == "dev"
-Requires-Dist: import-linter; extra == "dev"
-Requires-Dist: ispyb; extra == "dev"
-Requires-Dist: ipython; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: myst-parser; extra == "dev"
-Requires-Dist: pipdeptree; extra == "dev"
-Requires-Dist: plantweb; extra == "dev"
-Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: pydata-sphinx-theme>=0.12; extra == "dev"
-Requires-Dist: pyright==1.1.406; extra == "dev"
-Requires-Dist: pytest-asyncio; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: pytest-random-order; extra == "dev"
-Requires-Dist: pytest-timeout; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: responses; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
-Requires-Dist: sphinx-autobuild; extra == "dev"
-Requires-Dist: sphinx-copybutton; extra == "dev"
-Requires-Dist: sphinx-design; extra == "dev"
-Requires-Dist: tox-direct; extra == "dev"
-Requires-Dist: tox; extra == "dev"
-Requires-Dist: types-mock; extra == "dev"
-Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: dls-dodal==1.69.0
 Dynamic: license-file
 
 mx-bluesky