dls-dodal 1.36.1a0__tar.gz → 1.36.2__tar.gz

dls_dodal-1.36.2/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @DiamondLightSource/bluesky-reviewers

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.36.1a0
+Version: 1.36.2
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License

dls_dodal-1.36.2/docs/explanations/decisions/0003-codeowners.md

@@ -0,0 +1,19 @@
+# 3. Use CODEOWNERS Github feature to restrict approved reviewers
+
+## Status
+
+Accepted
+
+## Context
+
+As dodal expands and covers an increasing number of beamlines it is important to maintain quality. So far we have seen good results from following bluesky's own standards: Encouraging high test coverage, readable code (including type annotations, where appropriate) and collective ownership, including via thorough reviews which appropriately balance velocity with technical debt management. We would like to make sure this developer culture is preserved as we expand.
+
+## Decision
+
+Have a team of approved reviewers in the DiamondLightSource Github organisation. Every PR into dodal **must** be reviewed by a member of this team before merging (enforced by repo settings and [CODEOWNERS feature](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners)). Have a set of [documented criteria](../reviews.md) for becoming part of the team, with the expectation that any team that regularly works on dodal will become members over time. The hope is that a consistent set of standards can be maintained by the approver community.
+
+## Consequences
+
+PRs will not be mergable until an approved owner has reviewed them, approved individuals/teams will have to review/support onboarding of new individuals/teams for some time before they are approved for review. 
+
+Once a critical mass of Diamond staff are used to this way of working, this ADR may be obsolete and should be replaced with a more open review system.

dls_dodal-1.36.2/docs/explanations/reviews.md

@@ -0,0 +1,56 @@
+# Approved Reviewers
+
+Code reviews are an important tool for ensuring both quality and collective responsibility for the codebase. Dodal PRs *must* be reviewed by a member of [the approved review team](https://github.com/orgs/DiamondLightSource/teams/bluesky-reviewers) before they are merged. 
+
+## Review Standards and Practices
+
+When reviewing you should ensure the code meets the [repository standards](../reference/standards.rst) and [device standards](../reference/device-standards.rst). Approved reviewers will adhere to the following, if they do not, junior reviewers and reviewees should feel empowered to hold them to account.
+
+### Questions and Comments
+
+Questions and requests for clarification are encouraged. If you have comments for the reviewer you could add them with the following prefixes to be helpful:
+
+- **Must**: This will negatively effect functionality if not implemented. The PR will not be merged until the comment is addressed to both the reviewer and developer's satisfaction.
+- **Should**: This will improve quality/performance/etc. is but unlikely to affect functionality. If the developer doesn't want to do this they should write an explanation.
+- **Could**: Similar to **Should** but without the requirement for explicit justification. The developer can dismiss on the grounds that velocity is the priority at the moment. 
+- **Nit**: Preference only, the developer can dismiss without any justification.
+
+### The Happy Path
+
+If the review passes then the reviewer should approve the change and either the reviewer or PR author should merge it. 
+
+### Requesting Changes
+
+If the review fails the reviewer should request any changes (this issue is said to require rework)
+A developer should ideally pick up any rework PRs before starting new work
+When a developer is happy that a rework is complete they should press the re-request review button on the PR
+
+### Making Changes
+
+Reviewers should feel free to make small changes to a PR as part of a review e.g. typos, poorly named variables, fixing a test. However, if code has been changed in this way they need then need to run it past another developer (ideally the original developer). This means that no code is merged into main without being looked at by at least 2 people, ensuring collective responsibility for the codebase.
+
+### Dismissing Stale Reviews
+
+There may be times where one person requests changes on a PR, these changes are addressed and another person then approves it. In this case the PR still cannot be merged until the original review is dismissed. We're happy for people to dismiss stale reviews with the understanding that:
+
+- The new reviewer should check that the must and should comments have been addressed
+- If it's a big change it may still be worth the original reviewer looking again, if so they should make this clear to the original reviewer and the person that wrote the code
+
+## Joining the Review Team
+
+At least two members of the review team from two different DLS teams *must* approve adding a new member, neither of them can be on the new member's DLS team. At least one of the approvers should ideally be a senior engineer but this will not always be possible. 
+
+In the event of a rejection the review team should provide concise and actionable feedback and set a date for re-consideration.
+
+### Criteria for New Members
+
+New members should be regular contributors to dodal and should have been "shadow-reviewing" approved reviewers for a period of weeks or months before becoming approved. In both their contributions and reviews they should be consistently demonstrating the following *without prompting*:
+
+- A good understanding of Python, including advanced langauge features such as [generators](https://wiki.python.org/moin/Generators), [coroutines](https://docs.python.org/3/library/asyncio-task.html), [comprehensions](https://www.geeksforgeeks.org/comprehensions-in-python/) and [pattern matching](https://peps.python.org/pep-0636/).
+- A pythonic coding style, demonstrated by using appropriate class/variable names, aherence to [PEP 8](https://peps.python.org/pep-0008). 
+- Adherence to the review standards above as well as the [repository standards](../reference/standards.rst) and [device standards](../reference/device-standards.rst).
+- Independent (i.e. not just to satisfy a reviewer) motivation to make sure all code in dodal is well-tested. Use of unit and system tests as appropriate. Clear effort made to keep test coverage high (>90%). 
+- Advanced understanding of bluesky and ophyd-async including concepts and best practices, such as how to appropriately split logic between devices/plans/callbacks.
+- Humility in the use of reviewing as a tool in a way that balances the need to preserve quality with the need for progress. Appropriate use of the Must/Should/Could/Nit system documented above is helpful in showing this, as it gives the reviewer the opportunity to weight their comments in terms of project impact. They should also demonstrate similar humiliary as a reviewee.
+
+Additionally, they should be regularly raising issues in the repository and demonstrating the ability to write well formed issues, with well defined acceptance criteria, that are understandable without large amounts of context.

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/pyproject.toml

@@ -101,6 +101,7 @@ reportMissingImports = false  # Ignore missing stubs in imported modules
 asyncio_mode = "auto"
 markers = [
     "s03: marks tests as requiring the s03 simulator running (deselect with '-m \"not s03\"')",
+    "adsim: marks tests as requiring the containerised AreaDetector simulator running (deselect with '-m \"not adsim\"')",
     "skip_in_pycharm: marks test as not working in pycharm testrunner",
 ]
 addopts = """
@@ -150,7 +151,7 @@ allowlist_externals =
     sphinx-build
     sphinx-autobuild
 commands =
-    tests: pytest -m 'not s03' --cov=dodal --cov-report term --cov-report xml:cov.xml {posargs}
+    tests: pytest -m 'not (s03 or adsim)' --cov=dodal --cov-report term --cov-report xml:cov.xml {posargs}
     type-checking: pyright src tests {posargs}
     pre-commit: pre-commit run --all-files --show-diff-on-failure {posargs}
     docs: sphinx-{posargs:build -E} -T docs build/html

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dls_dodal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.36.1a0
+Version: 1.36.2
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dls_dodal.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ conftest.py
 pull_request_template.md
 pyproject.toml
 .devcontainer/devcontainer.json
+.github/CODEOWNERS
 .github/CONTRIBUTING.md
 .github/dependabot.yml
 .github/ISSUE_TEMPLATE/issue_template.md
@@ -41,8 +42,10 @@ docs/_templates/autosummary/class.rst
 docs/_templates/autosummary/module.rst
 docs/assets/zocalo.png
 docs/explanations/decisions.md
+docs/explanations/reviews.md
 docs/explanations/decisions/0001-record-architecture-decisions.md
 docs/explanations/decisions/0002-switched-to-python-copier-template.md
+docs/explanations/decisions/0003-codeowners.md
 docs/explanations/decisions/0003-make-devices-factory.md
 docs/explanations/decisions/COPYME
 docs/how-to/build-docs.md
@@ -78,7 +81,6 @@ src/dls_dodal.egg-info/top_level.txt
 src/dodal/__init__.py
 src/dodal/__main__.py
 src/dodal/_version.py
-src/dodal/adsim.py
 src/dodal/cli.py
 src/dodal/log.py
 src/dodal/utils.py
@@ -86,6 +88,7 @@ src/dodal/beamline_specific_utils/__init__.py
 src/dodal/beamline_specific_utils/i03.py
 src/dodal/beamlines/README.md
 src/dodal/beamlines/__init__.py
+src/dodal/beamlines/adsim.py
 src/dodal/beamlines/b01_1.py
 src/dodal/beamlines/i03.py
 src/dodal/beamlines/i04.py
@@ -155,10 +158,6 @@ src/dodal/devices/webcam.py
 src/dodal/devices/xbpm_feedback.py
 src/dodal/devices/zebra.py
 src/dodal/devices/zebra_controlled_shutter.py
-src/dodal/devices/areadetector/__init__.py
-src/dodal/devices/areadetector/adaravis.py
-src/dodal/devices/areadetector/adsim.py
-src/dodal/devices/areadetector/adutils.py
 src/dodal/devices/areadetector/plugins/CAM.py
 src/dodal/devices/areadetector/plugins/MJPG.py
 src/dodal/devices/detector/__init__.py
@@ -226,6 +225,7 @@ src/dodal/plans/__init__.py
 src/dodal/plans/scanspec.py
 src/dodal/plans/wrapped.py
 system_tests/__init__.py
+system_tests/test_adsim.py
 system_tests/test_aperturescatterguard_system.py
 system_tests/test_eiger_system.py
 system_tests/test_gridscan_system.py

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.36.1a0'
-__version_tuple__ = version_tuple = (1, 36, 1)
+__version__ = version = '1.36.2'
+__version_tuple__ = version_tuple = (1, 36, 2)

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/beamlines/__init__.py

@@ -16,6 +16,7 @@ _BEAMLINE_NAME_OVERRIDES = {
     "p47": "training_rig",
     "p48": "training_rig",
     "p49": "training_rig",
+    "t01": "adsim",
 }
 
 

dls_dodal-1.36.2/src/dodal/beamlines/adsim.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+
+from ophyd_async.epics.adsimdetector import SimDetector
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+    get_path_provider,
+    set_path_provider,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
+from dodal.devices.adsim import SimStage
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix
+
+BL = "adsim"
+PREFIX = BeamlinePrefix("t01")
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/tmp"),
+        client=LocalDirectoryServiceClient(),
+    )
+)
+
+"""
+Beamline module for use with the simulated AreaDetector and motors.
+These devices are simulated at the EPICS level, enabling testing of
+dodal and ophyd-async against what appear to be "real" signals.
+
+Usage Example
+-------------
+
+Start the simulated beamline by following the epics-containers tutorial at
+https://epics-containers.github.io/main/tutorials/launch_example.html
+And ensure that the signals are visible:
+
+```sh
+export EPICS_CA_ADDR_LIST=127.0.0.1
+```
+
+How to use the devices in a plan:
+In an ipython terminal run:
+
+```python
+from bluesky.run_engine import RunEngine
+
+from dodal.beamlines.adsim import det, stage
+from dodal.plans import count
+
+RE = RunEngine()
+d = det(connect_immediately=True)
+s = stage(connect_immediately=True)
+RE(count([d], num=10))
+```
+
+"""
+
+
+@device_factory()
+def stage() -> SimStage:
+    return SimStage(f"{PREFIX.beamline_prefix}-MO-SIMC-01:")
+
+
+@device_factory()
+def det() -> SimDetector:
+    return SimDetector(
+        f"{PREFIX.beamline_prefix}-DI-CAM-01:",
+        path_provider=get_path_provider(),
+        drv_suffix="DET:",
+        hdf_suffix="HDF:",
+    )

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/beamlines/i24.py

@@ -1,5 +1,6 @@
 from dodal.common.beamlines.beamline_utils import BL, device_instantiation
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.attenuator import ReadOnlyAttenuator
 from dodal.devices.detector import DetectorParams
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.hutch_shutter import HutchShutter
@@ -29,6 +30,21 @@ set_log_beamline(BL)
 set_utils_beamline(BL)
 
 
+def attenuator(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> ReadOnlyAttenuator:
+    """Get a read-only attenuator device for i24, instantiate it if it hasn't already
+    been. If this is called when already instantiated in i24, it will return the
+    existing object."""
+    return device_instantiation(
+        ReadOnlyAttenuator,
+        "attenuator",
+        "-OP-ATTN-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )
+
+
 def aperture(
     wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
 ) -> Aperture:

dls_dodal-1.36.2/src/dodal/devices/adsim.py

@@ -0,0 +1,13 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class SimStage(StandardReadable):
+    """Simulated Sample Stage for use with the containerised simulated beamline
+    https://github.com/epics-containers/example-services"""
+
+    def __init__(self, prefix: str, name: str = "sim"):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "M1")
+            self.y = Motor(prefix + "M2")
+        super().__init__(name=name)

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/devices/aperture.py

@@ -12,10 +12,3 @@ class Aperture(StandardReadable):
         self.medium = epics_signal_r(float, prefix + "Y:MEDIUM_CALC")
         self.large = epics_signal_r(float, prefix + "Y:LARGE_CALC")
         super().__init__(name)
-
-    async def in_position(self):
-        return (
-            await self.small.get_value()
-            or await self.medium.get_value()
-            or await self.large.get_value()
-        )

dls_dodal-1.36.2/src/dodal/devices/aperturescatterguard.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import asyncio
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from pydantic import BaseModel, Field
+
+from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.devices.aperture import Aperture
+from dodal.devices.scatterguard import Scatterguard
+
+
+class InvalidApertureMove(Exception):
+    pass
+
+
+class AperturePosition(BaseModel):
+    """
+    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
+    aperture_y: float
+    aperture_z: float
+    scatterguard_x: float
+    scatterguard_y: float
+    radius: float = Field(json_schema_extra={"units": "µm"}, default=0.0)
+
+    @property
+    def values(self) -> tuple[float, float, float, float, float]:
+        return (
+            self.aperture_x,
+            self.aperture_y,
+            self.aperture_z,
+            self.scatterguard_x,
+            self.scatterguard_y,
+        )
+
+    @staticmethod
+    def tolerances_from_gda_params(
+        params: GDABeamlineParameters,
+    ) -> AperturePosition:
+        return AperturePosition(
+            aperture_x=params["miniap_x_tolerance"],
+            aperture_y=params["miniap_y_tolerance"],
+            aperture_z=params["miniap_z_tolerance"],
+            scatterguard_x=params["sg_x_tolerance"],
+            scatterguard_y=params["sg_y_tolerance"],
+        )
+
+    @staticmethod
+    def from_gda_params(
+        name: ApertureValue,
+        radius: float,
+        params: GDABeamlineParameters,
+    ) -> AperturePosition:
+        return AperturePosition(
+            aperture_x=params[f"miniap_x_{name.value}"],
+            aperture_y=params[f"miniap_y_{name.value}"],
+            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,
+        )
+
+
+class ApertureValue(StrictEnum):
+    """Maps from a short usable name to the value name in the GDA Beamline parameters"""
+
+    ROBOT_LOAD = "ROBOT_LOAD"
+    SMALL = "SMALL_APERTURE"
+    MEDIUM = "MEDIUM_APERTURE"
+    LARGE = "LARGE_APERTURE"
+
+
+def load_positions_from_beamline_parameters(
+    params: GDABeamlineParameters,
+) -> dict[ApertureValue, AperturePosition]:
+    return {
+        ApertureValue.ROBOT_LOAD: AperturePosition.from_gda_params(
+            ApertureValue.ROBOT_LOAD, 0, params
+        ),
+        ApertureValue.SMALL: AperturePosition.from_gda_params(
+            ApertureValue.SMALL, 20, params
+        ),
+        ApertureValue.MEDIUM: AperturePosition.from_gda_params(
+            ApertureValue.MEDIUM, 50, params
+        ),
+        ApertureValue.LARGE: AperturePosition.from_gda_params(
+            ApertureValue.LARGE, 100, params
+        ),
+    }
+
+
+class ApertureScatterguard(StandardReadable, Movable):
+    def __init__(
+        self,
+        loaded_positions: dict[ApertureValue, AperturePosition],
+        tolerances: AperturePosition,
+        prefix: str = "",
+        name: str = "",
+    ) -> None:
+        self.aperture = Aperture(prefix + "-MO-MAPT-01:")
+        self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
+        self.radius = create_hardware_backed_soft_signal(
+            float, self._get_current_radius, units="µm"
+        )
+        self._loaded_positions = loaded_positions
+        self._tolerances = tolerances
+        self.add_readables(
+            [
+                self.aperture.x.user_readback,
+                self.aperture.y.user_readback,
+                self.aperture.z.user_readback,
+                self.scatterguard.x.user_readback,
+                self.scatterguard.y.user_readback,
+                self.radius,
+            ],
+        )
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.selected_aperture = create_hardware_backed_soft_signal(
+                ApertureValue, self._get_current_aperture_position
+            )
+
+        super().__init__(name)
+
+    def get_position_from_gda_aperture_name(
+        self, gda_aperture_name: str
+    ) -> ApertureValue:
+        return ApertureValue(gda_aperture_name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: ApertureValue):
+        position = self._loaded_positions[value]
+        await self._safe_move_within_datacollection_range(position, value)
+
+    @AsyncStatus.wrap
+    async def _set_raw_unsafe(self, position: AperturePosition):
+        """Accept the risks and move in an unsafe way. Collisions possible."""
+        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
+            position.values
+        )
+
+        await asyncio.gather(
+            self.aperture.x.set(aperture_x),
+            self.aperture.y.set(aperture_y),
+            self.aperture.z.set(aperture_z),
+            self.scatterguard.x.set(scatterguard_x),
+            self.scatterguard.y.set(scatterguard_y),
+        )
+
+    async def _get_current_aperture_position(self) -> ApertureValue:
+        """
+        Returns the current aperture position using readback values
+        for SMALL, MEDIUM, LARGE. ROBOT_LOAD position defined when
+        mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
+        If no position is found then raises InvalidApertureMove.
+        """
+        current_ap_y = await self.aperture.y.user_readback.get_value(cached=False)
+        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
+        if await self.aperture.large.get_value(cached=False) == 1:
+            return ApertureValue.LARGE
+        elif await self.aperture.medium.get_value(cached=False) == 1:
+            return ApertureValue.MEDIUM
+        elif await self.aperture.small.get_value(cached=False) == 1:
+            return ApertureValue.SMALL
+        elif current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y:
+            return ApertureValue.ROBOT_LOAD
+
+        raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
+
+    async def _get_current_radius(self) -> float:
+        current_value = await self._get_current_aperture_position()
+        return self._loaded_positions[current_value].radius
+
+    async def _safe_move_within_datacollection_range(
+        self, position: AperturePosition, value: ApertureValue
+    ):
+        """
+        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.
+        """
+        assert self._loaded_positions is not None
+
+        ap_z_in_position = await self.aperture.z.motor_done_move.get_value()
+        if not ap_z_in_position:
+            raise InvalidApertureMove(
+                "ApertureScatterguard z is still moving. Wait for it to finish "
+                "before triggering another move."
+            )
+
+        current_ap_z = await self.aperture.z.user_readback.get_value()
+        diff_on_z = abs(current_ap_z - position.aperture_z)
+        if diff_on_z > self._tolerances.aperture_z:
+            raise InvalidApertureMove(
+                "ApertureScatterguard safe move is not yet defined for positions "
+                "outside of LARGE, MEDIUM, SMALL, ROBOT_LOAD. "
+                f"Current aperture z ({current_ap_z}), outside of tolerance ({self._tolerances.aperture_z}) from target ({position.aperture_z})."
+            )
+
+        current_ap_y = await self.aperture.y.user_readback.get_value()
+
+        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
+            position.values
+        )
+
+        if position.aperture_y > current_ap_y:
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+        else:
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/devices/attenuator.py

@@ -14,7 +14,20 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal
 from dodal.log import LOGGER
 
 
-class Attenuator(StandardReadable, Movable):
+class ReadOnlyAttenuator(StandardReadable):
+    """A read-only attenuator class with a minimum set of PVs for reading.
+
+    The actual_transmission will return a fractional transmission between 0-1.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
+
+        super().__init__(name)
+
+
+class Attenuator(ReadOnlyAttenuator, Movable):
     """The attenuator will insert filters into the beam to reduce its transmission.
 
     This device should be set with:
@@ -42,10 +55,7 @@ class Attenuator(StandardReadable, Movable):
         self._use_current_energy = epics_signal_x(prefix + "E2WL:USECURRENTENERGY.PROC")
         self._change = epics_signal_x(prefix + "FANOUT")
 
-        with self.add_children_as_readables():
-            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
-
-        super().__init__(name)
+        super().__init__(prefix, name)
 
     @AsyncStatus.wrap
     async def set(self, value: float):

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/devices/focusing_mirror.py

@@ -1,3 +1,5 @@
+from typing import TypedDict
+
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -36,6 +38,12 @@ class MirrorStripe(StrictEnum):
     PLATINUM = "Platinum"
 
 
+class MirrorStripeConfiguration(TypedDict):
+    stripe: MirrorStripe
+    yaw_mrad: float
+    lat_mm: float
+
+
 class MirrorVoltageDemand(StrictEnum):
     N_A = "N/A"
     OK = "OK"
@@ -173,9 +181,10 @@ class FocusingMirrorWithStripes(FocusingMirror):
 
         super().__init__(prefix, name, *args, **kwargs)
 
-    def energy_to_stripe(self, energy_kev) -> MirrorStripe:
+    def energy_to_stripe(self, energy_kev) -> MirrorStripeConfiguration:
+        """Return the stripe, yaw angle and lateral position for the specified energy"""
         # In future, this should be configurable per-mirror
         if energy_kev < 7:
-            return MirrorStripe.BARE
+            return {"stripe": MirrorStripe.BARE, "yaw_mrad": 6.2, "lat_mm": 0.0}
         else:
-            return MirrorStripe.RHODIUM
+            return {"stripe": MirrorStripe.RHODIUM, "yaw_mrad": 0.0, "lat_mm": 10.0}

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/devices/oav/pin_image_recognition/__init__.py

@@ -61,7 +61,7 @@ class PinTipDetection(StandardReadable):
         self.triggered_bottom_edge, self._bottom_edge_setter = soft_signal_r_and_setter(
             Array1D[np.int32], name="triggered_bottom_edge"
         )
-        self.array_data = epics_signal_r(Array1D[np.uint8], f"pva://{prefix}PVA:ARRAY")
+        self.array_data = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
 
         # Soft parameters for pin-tip detection.
         self.preprocess_operation = soft_signal_rw(int, 10, name="preprocess")
@@ -99,9 +99,7 @@ class PinTipDetection(StandardReadable):
         self._top_edge_setter(results.edge_top)
         self._bottom_edge_setter(results.edge_bottom)
 
-    async def _get_tip_and_edge_data(
-        self, array_data: Array1D[np.uint8]
-    ) -> SampleLocation:
+    async def _get_tip_and_edge_data(self, array_data: np.ndarray) -> SampleLocation:
         """
         Gets the location of the pin tip and the top and bottom edges.
         """

{dls_dodal-1.36.1a0 → dls_dodal-1.36.2}/src/dodal/devices/undulator_dcm.py

@@ -5,6 +5,7 @@ from ophyd_async.core import AsyncStatus, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 
+from ..log import LOGGER
 from .dcm import DCM
 from .undulator import Undulator
 
@@ -59,3 +60,6 @@ class UndulatorDCM(StandardReadable, Movable):
             self.dcm.energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
             self.undulator.set(value),
         )
+        # DCM Perp pitch
+        LOGGER.info(f"Adjusting DCM offset to {self.dcm_fixed_offset_mm} mm")
+        await self.dcm.offset_in_mm.set(self.dcm_fixed_offset_mm)