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

dodal/device_manager.py

@@ -4,7 +4,7 @@ import typing
 from collections import UserDict
 from collections.abc import Callable, Iterable, Mapping, MutableMapping
 from functools import cached_property, wraps
-from inspect import Parameter
+from inspect import Parameter, cleandoc
 from types import NoneType
 from typing import (
     Annotated,
@@ -17,14 +17,10 @@ from typing import (
     TypeVar,
 )
 
-from bluesky.run_engine import (
-    get_bluesky_event_loop,
-)
+from bluesky.run_engine import get_bluesky_event_loop
 from ophyd.sim import make_fake_device
 
-from dodal.common.beamlines.beamline_utils import (
-    wait_for_connection,
-)
+from dodal.common.beamlines.beamline_utils import wait_for_connection
 from dodal.utils import (
     AnyDevice,
     OphydV1Device,
@@ -33,6 +29,7 @@ from dodal.utils import (
 )
 
 DEFAULT_TIMEOUT = 30
+NO_DOCS = "No documentation available."
 
 T = TypeVar("T")
 Args = ParamSpec("Args")
@@ -44,12 +41,11 @@ DeviceFactoryDecorator = Callable[[Callable[Args, V2]], "DeviceFactory[Args, V2]
 OphydInitialiser = Callable[Concatenate[V1, Args], V1 | None]
 
 _EMPTY = object()
-"""Sentinel value to distinguish between missing values and present but null values"""
+"""Sentinel value to distinguish between missing values and present but null values."""
 
 
 class LazyFixtures(UserDict[str, Any]):
-    """
-    Wrapper around fixtures and fixture generators
+    """Wrapper around fixtures and fixture generators.
 
     If a fixture is provided at runtime, the generator function does not have to be called.
     """
@@ -71,11 +67,9 @@ class LazyFixtures(UserDict[str, Any]):
 
 
 class DeviceFactory(Generic[Args, V2]):
-    """
-    Wrapper around a device factory (any function returning a device) that holds
+    """Wrapper around a device factory (any function returning a device) that holds
     a reference to a device manager that can provide dependencies, along with
-    default connection information for how the created device should be
-    connected.
+    default connection information for how the created device should be connected.
     """
 
     def __init__(
@@ -103,14 +97,17 @@ class DeviceFactory(Generic[Args, V2]):
         self._manager = manager
         wraps(factory)(self)
 
+        return_type = inspect.get_annotations(factory).get("return")
+        self.__doc__ = _format_doc(self, return_type)
+
     @property
     def name(self) -> str:
-        """Name of the underlying factory function"""
+        """Name of the underlying factory function."""
         return self.factory.__name__
 
     @cached_property
     def dependencies(self) -> set[str]:
-        """Names of all parameters"""
+        """Names of all parameters."""
         sig = inspect.signature(self.factory)
         return {
             para.name
@@ -120,7 +117,7 @@ class DeviceFactory(Generic[Args, V2]):
 
     @cached_property
     def optional_dependencies(self) -> set[str]:
-        """Names of optional dependencies"""
+        """Names of optional dependencies."""
         sig = inspect.signature(self.factory)
         return {
             para.name
@@ -131,9 +128,8 @@ class DeviceFactory(Generic[Args, V2]):
 
     @property
     def skip(self) -> bool:
-        """
-        Whether this device should be skipped as part of build_all - it will
-        still be built if a required device depends on it
+        """Whether this device should be skipped as part of build_all - it will
+        still be built if a required device depends on it.
         """
         return self._skip() if callable(self._skip) else self._skip
 
@@ -145,7 +141,7 @@ class DeviceFactory(Generic[Args, V2]):
         timeout: float | None = None,
         **fixtures,
     ) -> V2:
-        """Build this device, building any dependencies first"""
+        """Build this device, building any dependencies first."""
         devices = self._manager.build_devices(
             self,
             fixtures=fixtures,
@@ -175,8 +171,7 @@ class DeviceFactory(Generic[Args, V2]):
 
 # TODO: Remove when ophyd v1 support is no longer required - see #1718
 class V1DeviceFactory(Generic[Args, V1]):
-    """
-    Wrapper around an ophyd v1 device that holds a reference to a device
+    """Wrapper around an ophyd v1 device that holds a reference to a device
     manager that can provide dependencies, along with default connection
     information for how the created device should be connected.
     """
@@ -202,15 +197,16 @@ class V1DeviceFactory(Generic[Args, V1]):
         self.post_create = init or (lambda x: x)
         self._manager = manager
         wraps(init)(self)
+        self.__doc__ = _format_doc(self, factory)
 
     @property
     def name(self) -> str:
-        """Name of the underlying factory function"""
+        """Name of the underlying factory function."""
         return self.post_create.__name__
 
     @cached_property
     def dependencies(self) -> set[str]:
-        """Names of all parameters"""
+        """Names of all parameters."""
         sig = inspect.signature(self.post_create)
         # first parameter should be the device we've just built
         _, *params = sig.parameters.values()
@@ -218,16 +214,15 @@ class V1DeviceFactory(Generic[Args, V1]):
 
     @cached_property
     def optional_dependencies(self) -> set[str]:
-        """Names of optional dependencies"""
+        """Names of optional dependencies."""
         sig = inspect.signature(self.post_create)
         _, *params = sig.parameters.values()
         return {para.name for para in params if para.default is not Parameter.empty}
 
     @property
     def skip(self) -> bool:
-        """
-        Whether this device should be skipped as part of build_all - it will
-        still be built if a required device depends on it
+        """Whether this device should be skipped as part of build_all - it will
+        still be built if a required device depends on it.
         """
         return self._skip() if callable(self._skip) else self._skip
 
@@ -248,7 +243,7 @@ class V1DeviceFactory(Generic[Args, V1]):
         )
 
     def __call__(self, dev: V1, *args: Args.args, **kwargs: Args.kwargs):
-        """Call the wrapped function to make decorator transparent"""
+        """Call the wrapped function to make decorator transparent."""
         return self.post_create(dev, *args, **kwargs)
 
     def create(self, *args: Args.args, **kwargs: Args.kwargs) -> V1:
@@ -259,7 +254,7 @@ class V1DeviceFactory(Generic[Args, V1]):
         return device
 
     def build(self, mock: bool = False, fixtures: dict[str, Any] | None = None) -> V1:
-        """Build this device, building any dependencies first"""
+        """Build this device, building any dependencies first."""
         devices = self._manager.build_devices(
             self,
             fixtures=fixtures,
@@ -274,21 +269,21 @@ class V1DeviceFactory(Generic[Args, V1]):
 
 
 class ConnectionSpec(NamedTuple):
-    """The options used to configure a device"""
+    """The options used to configure a device."""
 
     mock: bool
     timeout: float
 
 
 class ConnectionResult(NamedTuple):
-    """Wrapper around results of building and connecting devices"""
+    """Wrapper around results of building and connecting devices."""
 
     devices: dict[str, AnyDevice]
     build_errors: dict[str, Exception]
     connection_errors: dict[str, Exception]
 
     def or_raise(self) -> dict[str, Any]:
-        """Re-raise any errors from build or connect stage or return devices"""
+        """Re-raise any errors from build or connect stage or return devices."""
         if self.build_errors or self.connection_errors:
             all_exc = []
             for name, exc in (self.build_errors | self.connection_errors).items():
@@ -299,14 +294,14 @@ class ConnectionResult(NamedTuple):
 
 
 class DeviceBuildResult(NamedTuple):
-    """Wrapper around the results of building devices"""
+    """Wrapper around the results of building devices."""
 
     devices: dict[str, AnyDevice]
     errors: dict[str, Exception]
     connection_specs: dict[str, ConnectionSpec]
 
     def connect(self, timeout: float | None = None) -> ConnectionResult:
-        """Connect all devices that didn't fail to build"""
+        """Connect all devices that didn't fail to build."""
         connections = {}
         connected = {}
         loop: asyncio.EventLoop = get_bluesky_event_loop()  # type: ignore
@@ -335,7 +330,7 @@ class DeviceBuildResult(NamedTuple):
         return ConnectionResult(connected, self.errors, connection_errors)
 
     def or_raise(self) -> Self:
-        """Re-raise any build errors"""
+        """Re-raise any build errors."""
         if self.errors:
             for name, exc in self.errors.items():
                 exc.add_note(name)
@@ -344,7 +339,7 @@ class DeviceBuildResult(NamedTuple):
 
 
 class DeviceManager:
-    """Manager to handle building and connecting interdependent devices"""
+    """Manager to handle building and connecting interdependent devices."""
 
     _factories: dict[str, DeviceFactory]
     _fixtures: dict[str, Callable[[], Any]]
@@ -355,11 +350,44 @@ class DeviceManager:
         self._v1_factories = {}
         self._fixtures = {}
 
+    def get_all_factories(self) -> dict[str, V1DeviceFactory | DeviceFactory]:
+        return self._factories | self._v1_factories
+
     def fixture(self, func: Callable[[], T]) -> Callable[[], T]:
-        """Add a function that can provide fixtures required by the factories"""
+        """Add a function that can provide fixtures required by the factories."""
         self._fixtures[func.__name__] = func
         return func
 
+    def include(self, other: "DeviceManager"):
+        """Merge an external DeviceManager into this one.
+
+        Registered devices from the included DeviceManager will be included
+        when all devices are built and will be available as dependencies when
+        building specific devices from this manager. Names of devices still
+        need to be unique and an error will be raised if an included device
+        shares a name with any existing device.
+
+        Fixtures are also included and will override any previously defined
+        fixtures in this manager. Fixtures defined after including the other
+        manager will take precedence over included ones.
+        """
+        # Bug in pyright means type checking doesn't recognise 'DeviceManager'
+        # as this class and fails with private member access
+        common = self._factories.keys() & other._factories  # noqa SLF001
+        common |= self._v1_factories.keys() & other._v1_factories  # noqa SLF001
+        common |= self._factories.keys() & other._v1_factories  # noqa SLF001
+        common |= self._v1_factories.keys() & other._factories  # noqa SLF001
+        if common:
+            raise ValueError(
+                f"Duplicate factories in included device manager: {common}"
+            )
+
+        self._factories.update(other._factories)  # noqa SLF001
+        self._v1_factories.update(other._v1_factories)  # noqa SLF001
+
+        # duplicate fixtures are not checked as fixtures can be overridden
+        self._fixtures.update(other._fixtures)  # noqa SLF001
+
     def v1_init(
         self,
         factory: type[V1],
@@ -369,8 +397,7 @@ class DeviceManager:
         wait: bool = True,
         timeout: int = DEFAULT_TIMEOUT,
     ):
-        """
-        Register an ophyd v1 device
+        """Register an ophyd v1 device.
 
         The function this decorates is an initialiser that takes a built device
         and is not used to create the device.
@@ -429,6 +456,7 @@ class DeviceManager:
             if func.__name__ in self:
                 raise ValueError(f"Duplicate factory name: {func.__name__}")
             factory = DeviceFactory(func, use_factory_name, timeout, mock, skip, self)
+
             self._factories[func.__name__] = factory
             return factory
 
@@ -456,7 +484,7 @@ class DeviceManager:
         return self.build_devices(
             *(
                 f
-                for f in (self._factories | self._v1_factories).values()
+                for f in (self.get_all_factories()).values()
                 # allow overriding skip but still allow fixtures to override devices
                 if (include_skipped or not f.skip)
             ),
@@ -470,11 +498,9 @@ class DeviceManager:
         fixtures: Mapping[str, Any] | None = None,
         mock: bool = False,
     ) -> DeviceBuildResult:
-        """
-        Build the devices from the given factories, ensuring that any
+        """Build the devices from the given factories, ensuring that any
         dependencies are built first and passed to later factories as required.
         """
-
         fixtures = LazyFixtures(provided=fixtures, factories=self._fixtures)
         if common := fixtures.keys() & {f.name for f in factories}:
             factories = tuple(f for f in factories if f.name not in common)
@@ -529,15 +555,14 @@ class DeviceManager:
         factories: Iterable[DeviceFactory[..., V2] | V1DeviceFactory[..., V1]],
         available_fixtures: Mapping[str, Any],
     ) -> set[str]:
-        """
-        Determine full list of devices that are required to build the given devices.
+        """Determine full list of devices that are required to build the given devices.
         If a dependency is available via the fixtures, a matching device factory
         will not be included unless explicitly requested allowing for devices to
         be overridden.
 
-        Errors:
-            If a required dependency is not available as either a device
-            factory or a fixture, a ValueError is raised
+        Raises:
+            If a required dependency is not available as either a device factory or a
+                fixture, a ValueError is raised
         """
         dependencies = set()
         factories = set(factories)
@@ -561,14 +586,12 @@ class DeviceManager:
         factories: dict[str, DeviceFactory[..., V2] | V1DeviceFactory[..., V1]],
         fixtures: Mapping[str, Any],
     ) -> list[str]:
-        """
-        Determine the order devices in which devices should be build to ensure
-        that dependencies are built before the things that depend on them
+        """Determine the order devices in which devices should be build to ensure
+        that dependencies are built before the things that depend on them.
 
         Assumes that all required devices and fixtures are included in the
         given factory list.
         """
-
         # This is not an efficient way of doing this, however, for realistic use
         # cases, it is fast enough for now
         order = []
@@ -602,3 +625,20 @@ class DeviceManager:
 
     def __repr__(self) -> str:
         return f"<DeviceManager: {len(self)} devices>"
+
+
+def _format_doc(
+    factory: DeviceFactory | V1DeviceFactory, return_type: type[V1 | V2] | None
+) -> str | None:
+    """Helper function to combine the doc strings of our factory instance and the
+    return type of the function we wrap.
+    """
+    if not return_type:
+        return factory.__doc__
+    if existing := factory.__doc__:
+        return f"{existing}\n\n{_type_docs(return_type)}"
+    return _type_docs(return_type)
+
+
+def _type_docs(target: type[V1 | V2]) -> str:
+    return f"{target.__name__}:\n\n{cleandoc(target.__doc__ or NO_DOCS)}"

dodal/devices/aperturescatterguard.py

@@ -24,7 +24,7 @@ class InvalidApertureMoveError(Exception):
 
 
 class _GDAParamApertureValue(StrictEnum):
-    """Maps from a short usable name to the value name in the GDA Beamline parameters"""
+    """Maps from a short usable name to the value name in the GDA Beamline parameters."""
 
     ROBOT_LOAD = "ROBOT_LOAD"
     SMALL = "SMALL_APERTURE"
@@ -34,16 +34,16 @@ class _GDAParamApertureValue(StrictEnum):
 
 
 class AperturePosition(BaseModel):
-    """
-    Represents one of the available positions for the Aperture-Scatterguard.
+    """Represents one of the available positions for the Aperture-Scatterguard.
+
     Attributes:
-        aperture_x: The x position of the aperture component in mm
-        aperture_y: The y position of the aperture component in mm
-        aperture_z: The z position of the aperture component in mm
-        scatterguard_x: The x position of the scatterguard component in mm
-        scatterguard_y: The y position of the scatterguard component in mm
-        radius: Radius of the selected aperture. When in the Robot Load position, the
-            radius is defined to be 0
+        aperture_x (float): The x position of the aperture component in mm.
+        aperture_y (float): The y position of the aperture component in mm.
+        aperture_z (float): The z position of the aperture component in mm.
+        scatterguard_x (float): The x position of the scatterguard component in mm.
+        scatterguard_y (float): The y position of the scatterguard component in mm.
+        diameter (float, optional): Diameter of the selected aperture. When in the Robot
+            Load position, the diameter is defined to be 0.
     """
 
     aperture_x: float
@@ -51,7 +51,7 @@ class AperturePosition(BaseModel):
     aperture_z: float
     scatterguard_x: float
     scatterguard_y: float
-    radius: float = Field(json_schema_extra={"units": "µm"}, default=0.0)
+    diameter: float = Field(json_schema_extra={"units": "µm"}, default=0.0)
 
     @property
     def values(self) -> tuple[float, float, float, float, float]:
@@ -78,7 +78,7 @@ class AperturePosition(BaseModel):
     @staticmethod
     def from_gda_params(
         name: _GDAParamApertureValue,
-        radius: float,
+        diameter: float,
         params: GDABeamlineParameters,
     ) -> AperturePosition:
         return AperturePosition(
@@ -87,7 +87,7 @@ class AperturePosition(BaseModel):
             aperture_z=params[f"miniap_z_{name.value}"],
             scatterguard_x=params[f"sg_x_{name.value}"],
             scatterguard_y=params[f"sg_y_{name.value}"],
-            radius=radius,
+            diameter=diameter,
         )
 
 
@@ -95,7 +95,7 @@ class ApertureValue(StrictEnum):
     """The possible apertures that can be selected.
 
     Changing these means changing the external parameter model of Hyperion.
-    See https://github.com/DiamondLightSource/mx-bluesky/issues/760
+    See https://github.com/DiamondLightSource/mx-bluesky/issues/760.
     """
 
     SMALL = "SMALL_APERTURE"
@@ -139,8 +139,8 @@ class ApertureScatterguard(StandardReadable, Preparable):
 
             await aperture_scatterguard.selected_aperture.set(ApertureValue.LARGE)
 
-        This will move the assembly so that the large aperture is in the beam, regardless
-        of where the assembly currently is.
+        This will move the assembly so that the large aperture is in the beam,
+        regardless of where the assembly currently is.
 
         We may also want to move the assembly out of the beam with::
 
@@ -149,8 +149,8 @@ class ApertureScatterguard(StandardReadable, Preparable):
         Note, to make sure we do this as quickly as possible, the scatterguard will stay
         in the same position relative to the aperture.
 
-        We may then want to keep the assembly out of the beam whilst asynchronously preparing
-        the other axes for the aperture that's to follow::
+        We may then want to keep the assembly out of the beam whilst asynchronously
+        preparing the other axes for the aperture that's to follow::
 
             await aperture_scatterguard.prepare(ApertureValue.LARGE)
 
@@ -185,8 +185,8 @@ class ApertureScatterguard(StandardReadable, Preparable):
                 current_ap_z=self.aperture.z.user_readback,
             )
 
-        self.radius = derived_signal_r(
-            self._get_current_radius,
+        self.diameter = derived_signal_r(
+            self._get_current_diameter,
             current_aperture=self.selected_aperture,
             derived_units="µm",
         )
@@ -198,7 +198,7 @@ class ApertureScatterguard(StandardReadable, Preparable):
                 self.aperture.z.user_readback,
                 self.scatterguard.x.user_readback,
                 self.scatterguard.y.user_readback,
-                self.radius,
+                self.diameter,
             ],
         )
 
@@ -262,8 +262,8 @@ class ApertureScatterguard(StandardReadable, Preparable):
                     "triggering another move."
                 )
 
-    def _get_current_radius(self, current_aperture: ApertureValue) -> float:
-        return self._loaded_positions[current_aperture].radius
+    def _get_current_diameter(self, current_aperture: ApertureValue) -> float:
+        return self._loaded_positions[current_aperture].diameter
 
     def _is_in_position(
         self, position: ApertureValue, current_ap_y: float, current_ap_z: float
@@ -300,11 +300,10 @@ class ApertureScatterguard(StandardReadable, Preparable):
         )
 
     async def _safe_move_whilst_in_beam(self, position: AperturePosition):
-        """
-        Move the aperture and scatterguard combo safely to a new position.
+        """Move the aperture and scatterguard combo safely to a new position.
         See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
-        for why this is required. TLDR is that we have a collision at the top of y so we need
-        to make sure we move the assembly down before we move the scatterguard up.
+        for why this is required. TLDR is that we have a collision at the top of y so we
+        need to make sure we move the assembly down before we move the scatterguard up.
         """
         current_ap_y = await self.aperture.y.user_readback.get_value()
 

dodal/devices/areadetector/plugins/cam.py

@@ -3,9 +3,7 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
 class ColorMode(StrictEnum):
-    """
-    Enum to store the various color modes of the camera. We use RGB1.
-    """
+    """Enum to store the various color modes of the camera. We use RGB1."""
 
     MONO = "Mono"
     BAYER = "Bayer"

dodal/devices/areadetector/plugins/mjpg.py

@@ -25,7 +25,8 @@ class MJPG(StandardReadable, Triggerable, ABC):
     """The MJPG areadetector plugin creates an MJPG video stream of the camera's output.
 
     This devices uses that stream to grab images. When it is triggered it will send the
-    latest image from the stream to the `post_processing` method for child classes to handle.
+    latest image from the stream to the `post_processing` method for child classes to
+    handle.
     """
 
     def __init__(
@@ -51,9 +52,9 @@ class MJPG(StandardReadable, Triggerable, ABC):
         super().__init__(name)
 
     async def _save_image(self, image: Image.Image):
-        """A helper function to save a given image to the path supplied by the \
-            directory and filename signals. The full resultant path is put on the \
-            last_saved_path signal
+        """A helper function to save a given image to the path supplied by the
+        directory and filename signals. The full resultant path is put on the
+        last_saved_path signal.
         """
         filename_str = await self.filename.get_value()
         directory_str = await self.directory.get_value()
@@ -74,7 +75,7 @@ class MJPG(StandardReadable, Triggerable, ABC):
         """This takes a snapshot image from the MJPG stream and send it to the
         post_processing method, expected to be implemented by a child of this class.
 
-        It is the responsibility of the child class to save any resulting images by \
+        It is the responsibility of the child class to save any resulting images by
         calling _save_image.
         """
         url_str = await self.url.get_value()

dodal/devices/attenuator/attenuator.py

@@ -37,13 +37,15 @@ class ReadOnlyAttenuator(StandardReadable):
 
 class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """The attenuator will insert filters into the beam to reduce its transmission.
-    In this attenuator, each filter can be in one of two states: IN or OUT
+    In this attenuator, each filter can be in one of two states: IN or OUT.
 
     This device should be set with:
+
         yield from bps.set(attenuator, desired_transmission)
 
     Where desired_transmission is fraction e.g. 0-1. When the actual_transmission is
-    read from the device it is also fractional"""
+    read from the device it is also fractional
+    """
 
     def __init__(self, prefix: str, num_filters: int, name: str = ""):
         self._calculated_filter_states: DeviceVector[SignalR[int]] = DeviceVector(
@@ -72,11 +74,10 @@ class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     async def set(self, value: float):
         """Set the transmission to the fractional (0-1) value given.
 
-        The attenuator IOC will then insert filters to reach the desired transmission for
-        the current beamline energy, the set will only complete when they have all been
-        applied.
+        The attenuator IOC will then insert filters to reach the desired transmission
+        for the current beamline energy, the set will only complete when they have all
+        been applied.
         """
-
         LOGGER.debug("Using current energy ")
         await self._use_current_energy.trigger()
         LOGGER.info(f"Setting desired transmission to {value}")
@@ -110,7 +111,8 @@ ENUM_ATTENUATOR_SETTLE_TIME_S = 0.15
 class EnumFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """The attenuator will insert filters into the beam to reduce its transmission.
 
-    This device is currently working, but feature incomplete. See https://github.com/DiamondLightSource/dodal/issues/972
+    This device is currently working, but feature incomplete. See
+    https://github.com/DiamondLightSource/dodal/issues/972
 
     In this attenuator, the state of a filter corresponds to the selected material,
     e.g Ag50, in contrast to being either 'IN' or 'OUT'; see BinaryFilterAttenuator.
@@ -141,11 +143,10 @@ class EnumFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     async def set(self, value: float):
         """Set the transmission to the fractional (0-1) value given.
 
-        The attenuator IOC will then insert filters to reach the desired transmission for
-        the current beamline energy, the set will only complete when they have all been
-        applied.
+        The attenuator IOC will then insert filters to reach the desired transmission
+        for the current beamline energy, the set will only complete when they have all
+        been applied.
         """
-
         # auto move should normally be on, but check here incase it was manually turned off
         await self._auto_move_on_desired_transmission_set.set(YesNo.YES)
 

dodal/devices/beamlines/b07/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.beamlines.b07.enums import Grating, LensMode, PsuMode
+
+__all__ = ["Grating", "LensMode", "PsuMode"]

dodal/devices/{b07_1 → beamlines/b07_1}/__init__.py

@@ -1,8 +1,8 @@
-from dodal.devices.b07_1.ccmc import (
+from dodal.devices.beamlines.b07_1.ccmc import (
     ChannelCutMonochromator,
     ChannelCutMonochromatorPositions,
 )
-from dodal.devices.b07_1.enums import Grating, LensMode
+from dodal.devices.beamlines.b07_1.enums import Grating, LensMode
 
 __all__ = [
     "Grating",

dodal/devices/{b07_1 → beamlines/b07_1}/ccmc.py

@@ -25,13 +25,16 @@ error_message = "Can not get energy value in eV from ccmc position: "
 class ChannelCutMonochromator(
     StandardReadable, Movable[ChannelCutMonochromatorPositions]
 ):
-    """
-    Device to move the channel cut monochromator (ccmc). CCMC has three
+    """Device to move the channel cut monochromator (ccmc). CCMC has three
     choices of crystal (Xtal for short). Setting energy is by means of a
     multi-positioner. The positions are named after the nominal energies of the
     crystals. To change energy select one of the crystals from the list.
     This causes the Y motor to move that crystal into the beam and other
     motors have to align the angles correctly.
+
+    Args:
+        prefix (str): Beamline specific part of the PV.
+        name (str, optional): Name of the device.
     """
 
     def __init__(
@@ -39,14 +42,6 @@ class ChannelCutMonochromator(
         prefix: str,
         name: str = "",
     ) -> None:
-        """
-        Parameters
-        ----------
-        prefix:
-            Beamline specific part of the PV
-        name:
-            Name of the device
-        """
         with self.add_children_as_readables():
             # crystal motors
             self._xyz = XYZStage(prefix)