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

dodal/devices/{dcm.py → i03/dcm.py}

@@ -1,5 +1,5 @@
 import numpy as np
-from ophyd_async.core import Array1D, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.core import Array1D, soft_signal_r_and_setter
 from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
@@ -8,9 +8,14 @@ from dodal.common.crystal_metadata import (
     MaterialsEnum,
     make_crystal_metadata_from_material,
 )
+from dodal.devices.common_dcm import (
+    BaseDCM,
+    PitchAndRollCrystal,
+    StationaryCrystal,
+)
 
 
-class DCM(StandardReadable):
+class DCM(BaseDCM[PitchAndRollCrystal, StationaryCrystal]):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
 
@@ -30,13 +35,7 @@ class DCM(StandardReadable):
             MaterialsEnum.Si, (1, 1, 1)
         )
         with self.add_children_as_readables():
-            self.bragg_in_degrees = Motor(prefix + "BRAGG")
-            self.roll_in_mrad = Motor(prefix + "ROLL")
-            self.offset_in_mm = Motor(prefix + "OFFSET")
             self.perp_in_mm = Motor(prefix + "PERP")
-            self.energy_in_kev = Motor(prefix + "ENERGY")
-            self.pitch_in_mrad = Motor(prefix + "PITCH")
-            self.wavelength = Motor(prefix + "WAVELENGTH")
 
             # temperatures
             self.xtal1_temp = epics_signal_r(float, prefix + "TEMP1")
@@ -58,7 +57,4 @@ class DCM(StandardReadable):
                 Array1D[np.uint64],
                 initial_value=reflection_array,
             )
-            self.crystal_metadata_d_spacing = epics_signal_r(
-                float, prefix + "DSPACING:RBV"
-            )
-        super().__init__(name)
+        super().__init__(prefix, PitchAndRollCrystal, StationaryCrystal, name)

dodal/devices/{undulator_dcm.py → i03/undulator_dcm.py}

@@ -4,10 +4,9 @@ from bluesky.protocols import Movable
 from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
-
-from ..log import LOGGER
-from .dcm import DCM
-from .undulator import Undulator
+from dodal.devices.i03.dcm import DCM
+from dodal.devices.undulator import Undulator
+from dodal.log import LOGGER
 
 ENERGY_TIMEOUT_S: float = 30.0
 
@@ -23,6 +22,9 @@ class UndulatorDCM(StandardReadable, Movable[float]):
     Calling unulator_dcm.set(energy) will move the DCM motor, perform a table lookup
     and move the Undulator gap motor if needed. So the set method can be thought of as
     a comprehensive way to set beam energy.
+
+    This class will be removed in the future. Use the separate Undulator and DCM devices
+    instead. See https://github.com/DiamondLightSource/dodal/issues/1092
     """
 
     def __init__(

dodal/devices/i04/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
+
+__all__ = ["Beamstop", "BeamstopPositions"]

dodal/devices/i04/constants.py

@@ -0,0 +1,9 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RedisConstants:
+    REDIS_HOST = os.environ.get("VALKEY_PROD_SVC_SERVICE_HOST", "test_redis")
+    REDIS_PASSWORD = os.environ.get("VALKEY_PASSWORD", "test_redis_password")
+    MURKO_REDIS_DB = 7

dodal/devices/i04/murko_results.py

@@ -0,0 +1,195 @@
+import json
+import pickle
+from collections import OrderedDict
+from enum import Enum
+from typing import TypedDict
+
+import numpy as np
+from bluesky.protocols import Stageable, Triggerable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+from redis.asyncio import StrictRedis
+
+from dodal.devices.i04.constants import RedisConstants
+from dodal.devices.oav.oav_calculations import (
+    calculate_beam_distance,
+    camera_coordinates_to_xyz_mm,
+)
+from dodal.log import LOGGER
+
+MurkoResult = dict
+FullMurkoResults = dict[str, list[MurkoResult]]
+
+
+class MurkoMetadata(TypedDict):
+    zoom_percentage: float
+    microns_per_x_pixel: float
+    microns_per_y_pixel: float
+    beam_centre_i: int
+    beam_centre_j: int
+    sample_id: str
+    omega_angle: float
+    uuid: str
+
+
+class Coord(Enum):
+    x = 0
+    y = 1
+    z = 2
+
+
+class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
+    """Device that takes crystal centre coords from Murko and uses them to set the
+    x, y, z coordinate of the sample to be in line with the beam centre.
+    (x, z) coords can be read at 90°, and (x, y) at 180° (or the closest omega angle to
+    90° and 180°). The average of the x values at these angles is taken, and sin(omega)z
+    and cosine(omega)y are taken to account for the rotation. This value is used to
+    calculate a number of mm the sample needs to move to be in line with the beam centre.
+    """
+
+    TIMEOUT_S = 2
+
+    def __init__(
+        self,
+        redis_host=RedisConstants.REDIS_HOST,
+        redis_password=RedisConstants.REDIS_PASSWORD,
+        redis_db=RedisConstants.MURKO_REDIS_DB,
+        name="",
+    ):
+        self.redis_client = StrictRedis(
+            host=redis_host,
+            password=redis_password,
+            db=redis_db,
+        )
+        self.pubsub = self.redis_client.pubsub()
+        self._last_omega = 0
+        self._last_result = None
+        self.sample_id = soft_signal_rw(str)  # Should get from redis
+        self.coords = {"x": {}, "y": {}, "z": {}}
+        self.search_angles = OrderedDict(
+            [  # Angles to search and dimensions to gather at each angle
+                (90, ("x", "z")),
+                (180, ("x", "y")),
+                (270, ()),  # Stop searching here
+            ]
+        )
+        self.angles_to_search = list(self.search_angles.keys())
+
+        with self.add_children_as_readables():
+            # Diffs from current x/y/z
+            self.x_mm, self._x_mm_setter = soft_signal_r_and_setter(float)
+            self.y_mm, self._y_mm_setter = soft_signal_r_and_setter(float)
+            self.z_mm, self._z_mm_setter = soft_signal_r_and_setter(float)
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def stage(self):
+        await self.pubsub.subscribe("murko-results")
+        self._x_mm_setter(0)
+        self._y_mm_setter(0)
+        self._z_mm_setter(0)
+
+    @AsyncStatus.wrap
+    async def unstage(self):
+        await self.pubsub.unsubscribe()
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        # Wait for results
+        sample_id = await self.sample_id.get_value()
+        final_message = None
+        while self.angles_to_search:
+            # waits here for next batch to be recieved
+            message = await self.pubsub.get_message(timeout=self.TIMEOUT_S)
+            if message is None:  # No more messages to process
+                await self.process_batch(
+                    final_message, sample_id
+                )  # Process final message again
+                break
+            await self.process_batch(message, sample_id)
+            final_message = message
+        x_values = list(self.coords["x"].values())
+        y_values = list(self.coords["y"].values())
+        z_values = list(self.coords["z"].values())
+        assert x_values, "No x values"
+        assert z_values, "No z values"
+        assert y_values, "No y values"
+        self._x_mm_setter(float(np.mean(x_values)))
+        self._y_mm_setter(float(np.mean(y_values)))
+        self._z_mm_setter(float(np.mean(z_values)))
+
+    async def process_batch(self, message: dict | None, sample_id: str):
+        if message and message["type"] == "message":
+            batch_results = pickle.loads(message["data"])
+            for results in batch_results:
+                LOGGER.info(f"Got {results} from redis")
+                for uuid, result in results.items():
+                    metadata_str = await self.redis_client.hget(  # type: ignore
+                        f"murko:{sample_id}:metadata", uuid
+                    )
+                    if metadata_str and self.angles_to_search:
+                        self.process_result(result, uuid, metadata_str)
+
+    def process_result(
+        self, result: dict, uuid: int, metadata_str: str
+    ) -> float | None:
+        metadata = MurkoMetadata(json.loads(metadata_str))
+        omega_angle = metadata["omega_angle"]
+        LOGGER.info(f"Got angle {omega_angle}")
+        # Find closest to next search angle
+        movement = self.get_coords_if_at_angle(metadata, result, omega_angle)
+        if movement is not None:
+            LOGGER.info(f"Using result {uuid}, {metadata_str}, {result}")
+            search_angle = self.angles_to_search.pop(0)
+            for coord in self.search_angles[search_angle]:
+                self.coords[coord][omega_angle] = movement[Coord[coord].value]
+                LOGGER.info(f"Found {coord} at {movement}, angle = {omega_angle}")
+        self._last_omega = omega_angle
+        self._last_result = result
+
+    def get_coords_if_at_angle(
+        self, metadata: MurkoMetadata, result: MurkoResult, omega: float
+    ) -> np.ndarray | None:
+        """Gets the 'most_likely_click' coordinates from Murko if omega or the last
+        omega are the closest angle to the search angle. Otherwise returns None.
+        """
+        search_angle = self.angles_to_search[0]
+        LOGGER.info(f"Compare {omega}, {search_angle}, {self._last_omega}")
+        if (  # if last omega is closest
+            abs(omega - search_angle) >= abs(self._last_omega - search_angle)
+            and self._last_result is not None
+        ):
+            closest_result = self._last_result
+            closest_omega = self._last_omega
+        elif omega - search_angle >= 0:  # if this omega is closest
+            closest_result = result
+            closest_omega = omega
+        else:
+            return None
+        coords = closest_result[
+            "most_likely_click"
+        ]  # As proportion from top, left of image
+        shape = closest_result["original_shape"]  # Dimensions of image in pixels
+        # Murko returns coords as y, x
+        centre_px = (coords[1] * shape[1], coords[0] * shape[0])
+        LOGGER.info(
+            f"Using image taken at {closest_omega}, which found xtal at {centre_px}"
+        )
+
+        beam_dist_px = calculate_beam_distance(
+            (metadata["beam_centre_i"], metadata["beam_centre_j"]),
+            centre_px[0],
+            centre_px[1],
+        )
+
+        return camera_coordinates_to_xyz_mm(
+            beam_dist_px[0],
+            beam_dist_px[1],
+            closest_omega,
+            metadata["microns_per_x_pixel"],
+            metadata["microns_per_y_pixel"],
+        )

dodal/devices/i10/diagnostics.py

@@ -1,6 +1,4 @@
-from bluesky.protocols import Movable
 from ophyd_async.core import (
-    AsyncStatus,
     Device,
     StandardReadable,
     StrictEnum,
@@ -13,7 +11,6 @@ from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
 )
-from ophyd_async.epics.motor import Motor
 
 from dodal.devices.current_amplifiers import (
     CurrentAmpDet,
@@ -23,6 +20,7 @@ from dodal.devices.current_amplifiers import (
     FemtoDDPCA,
     StruckScaler,
 )
+from dodal.devices.positioner import create_positioner
 
 
 class D3Position(StrictEnum):
@@ -70,36 +68,6 @@ class InOutReadBackTable(StrictEnum):
     OUT_OF_BEAM = "Out of Beam"
 
 
-class Positioner(StandardReadable, Movable):
-    """1D stage with a enum table to select positions."""
-
-    def __init__(
-        self,
-        prefix: str,
-        positioner_enum: type[StrictEnum],
-        positioner_suffix: str = "",
-        Positioner_pv_suffix: str = ":MP:SELECT",
-        name: str = "",
-    ) -> None:
-        self._stage_motion = Motor(prefix=prefix + positioner_suffix)
-        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
-            self.stage_position = epics_signal_rw(
-                positioner_enum,
-                read_pv=prefix + positioner_suffix + Positioner_pv_suffix,
-            )
-        super().__init__(name=name)
-        self.positioner_enum = positioner_enum
-
-    @AsyncStatus.wrap
-    async def set(self, value: StrictEnum) -> None:
-        if value in self.positioner_enum:
-            await self.stage_position.set(value=value)
-        else:
-            raise ValueError(
-                f"{value} is not an allow position. Position must be: {self.positioner_enum}"
-            )
-
-
 class I10PneumaticStage(StandardReadable):
     """Pneumatic stage only has two real positions in or out.
     Use for fluorescent screen which can be insert into the x-ray beam.
@@ -154,16 +122,13 @@ class FullDiagnostic(Device):
         self,
         prefix: str,
         positioner_enum: type[StrictEnum],
-        positioner_suffix: str = "",
-        Positioner_pv_suffix: str = ":MP:SELECT",
+        positioner_suffix: str,
         cam_infix: str = "DCAM:",
         name: str = "",
     ) -> None:
-        self.positioner = Positioner(
-            prefix=prefix,
-            positioner_enum=positioner_enum,
-            positioner_suffix=positioner_suffix,
-            Positioner_pv_suffix=Positioner_pv_suffix,
+        self.positioner = create_positioner(
+            positioner_enum,
+            prefix + positioner_suffix,
         )
         self.screen = ScreenCam(
             prefix,
@@ -185,28 +150,11 @@ class I10Diagnostic(Device):
             positioner_suffix="DET:X",
         )
         self.d4 = ScreenCam(prefix=prefix + "PHDGN-04:")
-        self.d5 = Positioner(
-            prefix=prefix + "IONC-01:",
-            positioner_enum=D5Position,
-            positioner_suffix="Y",
-        )
-
-        self.d5A = Positioner(
-            prefix=prefix + "PHDGN-06:",
-            positioner_enum=D5APosition,
-            positioner_suffix="DET:X",
-        )
+        self.d5 = create_positioner(D5Position, f"{prefix}IONC-01:Y")
+        self.d5A = create_positioner(D5APosition, f"{prefix}PHDGN-06:DET:X")
+        self.d6 = FullDiagnostic(f"{prefix}PHDGN-05:", D6Position, "DET:X")
+        self.d7 = create_positioner(D7Position, f"{prefix}PHDGN-07:Y")
 
-        self.d6 = FullDiagnostic(
-            prefix=prefix + "PHDGN-05:",
-            positioner_enum=D6Position,
-            positioner_suffix="DET:X",
-        )
-        self.d7 = Positioner(
-            prefix=prefix + "PHDGN-07:",
-            positioner_enum=D7Position,
-            positioner_suffix="Y",
-        )
         super().__init__(name)
 
 

dodal/devices/i13_1/merlin.py

@@ -23,10 +23,9 @@ class Merlin(StandardDetector):
         super().__init__(
             MerlinController(self.drv),
             adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
+                fileio=self.hdf,
+                path_provider=path_provider,
+                dataset_describer=adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_period, self.drv.acquire_time),
             name=name,

dodal/devices/i13_1/merlin_controller.py

@@ -37,7 +37,7 @@ class MerlinController(ADBaseController):
             DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         )
         await asyncio.gather(
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 

dodal/devices/i22/dcm.py

@@ -5,7 +5,6 @@ from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import (
     Array1D,
-    StandardReadable,
     StandardReadableFormat,
     soft_signal_r_and_setter,
 )
@@ -13,13 +12,18 @@ from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.crystal_metadata import CrystalMetadata
+from dodal.devices.common_dcm import (
+    BaseDCM,
+    PitchAndRollCrystal,
+    RollCrystal,
+)
 
 # Conversion constant for energy and wavelength, taken from the X-Ray data booklet
 # Converts between energy in KeV and wavelength in angstrom
 _CONVERSION_CONSTANT = 12.3984
 
 
-class DoubleCrystalMonochromator(StandardReadable):
+class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
 
@@ -39,13 +43,7 @@ class DoubleCrystalMonochromator(StandardReadable):
     ) -> None:
         with self.add_children_as_readables():
             # Positionable Parameters
-            self.bragg = Motor(prefix + "BRAGG")
-            self.offset = Motor(prefix + "OFFSET")
             self.perp = Motor(prefix + "PERP")
-            self.energy = Motor(prefix + "ENERGY")
-            self.crystal_1_roll = Motor(prefix + "XTAL1:ROLL")
-            self.crystal_2_roll = Motor(prefix + "XTAL2:ROLL")
-            self.crystal_2_pitch = Motor(prefix + "XTAL2:PITCH")
 
             # Temperatures
             self.backplate_temp = epics_signal_r(float, temperature_prefix + "PT100-7")
@@ -93,12 +91,12 @@ class DoubleCrystalMonochromator(StandardReadable):
                 units=crystal_2_metadata.d_spacing[1],
             )
 
-        super().__init__(name)
+        super().__init__(prefix, RollCrystal, PitchAndRollCrystal, name)
 
     async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
-            f"{self.name}-wavelength": DataKey(
+            f"{self.name}-wavelength_in_a": DataKey(
                 dtype="number",
                 shape=[],
                 source=self.name,
@@ -109,7 +107,7 @@ class DoubleCrystalMonochromator(StandardReadable):
 
     async def read(self) -> dict[str, Reading]:
         default_reading = await super().read()
-        energy: float = default_reading[f"{self.name}-energy"]["value"]
+        energy: float = default_reading[f"{self.name}-energy_in_kev"]["value"]
         if energy > 0.0:
             wavelength = _CONVERSION_CONSTANT / energy
         else:
@@ -117,7 +115,7 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         return {
             **default_reading,
-            f"{self.name}-wavelength": Reading(
+            f"{self.name}-wavelength_in_a": Reading(
                 value=wavelength,
                 timestamp=time.time(),
             ),

dodal/devices/i24/dcm.py

@@ -1,28 +1,19 @@
-from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r
-from ophyd_async.epics.motor import Motor
 
+from dodal.devices.common_dcm import (
+    BaseDCM,
+    PitchAndRollCrystal,
+    RollCrystal,
+)
 
-class DCM(StandardReadable):
+
+class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
     """
     A double crystal monocromator device, used to select the beam energy.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            # Motors
-            self.bragg_in_degrees = Motor(prefix + "-MO-DCM-01:BRAGG")
-            self.x_translation_in_mm = Motor(prefix + "-MO-DCM-01:X")
-            self.offset_in_mm = Motor(prefix + "-MO-DCM-01:OFFSET")
-            self.gap_in_mm = Motor(prefix + "-MO-DCM-01:GAP")
-            self.energy_in_kev = Motor(prefix + "-MO-DCM-01:ENERGY")
-            self.xtal1_roll = Motor(prefix + "-MO-DCM-01:XTAL1:ROLL")
-            self.xtal2_roll = Motor(prefix + "-MO-DCM-01:XTAL2:ROLL")
-            self.xtal2_pitch = Motor(prefix + "-MO-DCM-01:XTAL2:PITCH")
-
-            # Wavelength is calculated in epics from the energy
-            self.wavelength_in_a = epics_signal_r(float, prefix + "-MO-DCM-01:LAMBDA")
-
             # Temperatures
             self.xtal1_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-1")
             self.xtal1_heater_temp = epics_signal_r(
@@ -39,4 +30,4 @@ class DCM(StandardReadable):
             self.b1_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-7")
             self.gap_temp = epics_signal_r(float, prefix + "-DI-DCM-01:TC-1")
 
-        super().__init__(name)
+        super().__init__(prefix + "-MO-DCM-01:", RollCrystal, PitchAndRollCrystal, name)

dodal/devices/i24/focus_mirrors.py

@@ -1,8 +1,6 @@
-from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.core import StandardReadable, StrictEnum, derived_signal_r
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
-
 
 class HFocusMode(StrictEnum):
     FOCUS_10 = "HMFMfocus10"
@@ -40,21 +38,19 @@ class FocusMirrorsMode(StandardReadable):
         self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
 
         with self.add_children_as_readables():
-            self.beam_size_x = create_r_hardware_backed_soft_signal(
-                int, self._get_beam_size_x, units="um"
+            self.beam_size_x = derived_signal_r(
+                self._get_beam_size_x, horizontal=self.horizontal, derived_units="um"
             )
-            self.beam_size_y = create_r_hardware_backed_soft_signal(
-                int, self._get_beam_size_y, units="um"
+            self.beam_size_y = derived_signal_r(
+                self._get_beam_size_y, vertical=self.vertical, derived_units="um"
             )
 
         super().__init__(name)
 
-    async def _get_beam_size_x(self) -> int:
-        h_mode = await self.horizontal.get_value()
-        beam_x = BEAM_SIZES[h_mode.removeprefix("HMFM")][0]
+    def _get_beam_size_x(self, horizontal: HFocusMode) -> int:
+        beam_x = BEAM_SIZES[horizontal.removeprefix("HMFM")][0]
         return beam_x
 
-    async def _get_beam_size_y(self) -> int:
-        v_mode = await self.vertical.get_value()
-        beam_y = BEAM_SIZES[v_mode.removeprefix("VMFM")][1]
+    def _get_beam_size_y(self, vertical: VFocusMode) -> int:
+        beam_y = BEAM_SIZES[vertical.removeprefix("VMFM")][1]
         return beam_y

dodal/devices/i24/pilatus_metadata.py

@@ -2,11 +2,9 @@
 
 import re
 
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, derived_signal_r
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
-
 
 class PilatusMetadata(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -14,21 +12,23 @@ class PilatusMetadata(StandardReadable):
         self.template = epics_signal_r(str, prefix + "cam1:FileTemplate_RBV")
         self.filenumber = epics_signal_r(int, prefix + "cam1:FileNumber_RBV")
         with self.add_children_as_readables():
-            self.filename_template = create_r_hardware_backed_soft_signal(
-                str, self._get_full_filename_template
+            self.filename_template = derived_signal_r(
+                self._get_full_filename_template,
+                filename=self.filename,
+                filename_template=self.template,
+                file_number=self.filenumber,
             )
         super().__init__(name)
 
-    async def _get_full_filename_template(self) -> str:
+    def _get_full_filename_template(
+        self, filename: str, filename_template: str, file_number: int
+    ) -> str:
         """
         Get the template file path by querying the detector PVs.
         Mirror the construction that the PPU does.
 
         Returns: A template string, with the image numbers replaced with '#'
         """
-        filename = await self.filename.get_value()
-        filename_template = await self.template.get_value()
-        file_number = await self.filenumber.get_value()
         # Exploit fact that passing negative numbers will put the - before the 0's
         expected_filename = str(
             filename_template % (filename, f"{file_number:05d}_", -9)