ophyd-async 0.3.4a1__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/{panda → fastcs/panda}/_common_blocks.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 from enum import Enum
 
-from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW
-from ophyd_async.panda._table import DatasetTable, SeqTable
+from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW, SubsetEnum
+
+from ._table import DatasetTable, SeqTable
 
 
 class DataBlock(Device):
@@ -22,6 +23,25 @@ class PulseBlock(Device):
     width: SignalRW[float]
 
 
+class PcompDirectionOptions(str, Enum):
+    positive = "Positive"
+    negative = "Negative"
+    either = "Either"
+
+
+EnableDisableOptions = SubsetEnum["ZERO", "ONE"]
+
+
+class PcompBlock(Device):
+    active: SignalR[bool]
+    dir: SignalRW[PcompDirectionOptions]
+    enable: SignalRW[EnableDisableOptions]
+    pulses: SignalRW[int]
+    start: SignalRW[int]
+    step: SignalRW[int]
+    width: SignalRW[int]
+
+
 class TimeUnits(str, Enum):
     min = "min"
     s = "s"
@@ -35,7 +55,7 @@ class SeqBlock(Device):
     repeats: SignalRW[int]
     prescale: SignalRW[float]
     prescale_units: SignalRW[TimeUnits]
-    enable: SignalRW[str]
+    enable: SignalRW[EnableDisableOptions]
 
 
 class PcapBlock(Device):
@@ -46,5 +66,6 @@ class PcapBlock(Device):
 class CommonPandaBlocks(Device):
     pulse: DeviceVector[PulseBlock]
     seq: DeviceVector[SeqBlock]
+    pcomp: DeviceVector[PcompBlock]
     pcap: PcapBlock
     data: DataBlock

ophyd_async/{panda → fastcs/panda}/_hdf_panda.py

@@ -2,24 +2,19 @@ from __future__ import annotations
 
 from typing import Sequence
 
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    DirectoryProvider,
-    SignalR,
-    StandardDetector,
-)
+from ophyd_async.core import DEFAULT_TIMEOUT, PathProvider, SignalR, StandardDetector
 from ophyd_async.epics.pvi import create_children_from_annotations, fill_pvi_entries
 
 from ._common_blocks import CommonPandaBlocks
+from ._hdf_writer import PandaHDFWriter
 from ._panda_controller import PandaPcapController
-from .writers._hdf_writer import PandaHDFWriter
 
 
 class HDFPanda(CommonPandaBlocks, StandardDetector):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         config_sigs: Sequence[SignalR] = (),
         name: str = "",
     ):
@@ -28,7 +23,9 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         create_children_from_annotations(self)
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
-            directory_provider=directory_provider,
+            prefix=prefix,
+            path_provider=path_provider,
+            name_provider=lambda: name,
             panda_device=self,
         )
         super().__init__(

ophyd_async/{panda/writers → fastcs/panda}/_hdf_writer.py

@@ -8,13 +8,15 @@ from p4p.client.thread import Context
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorWriter,
-    DirectoryProvider,
+    HDFDataset,
+    HDFFile,
+    NameProvider,
+    PathProvider,
+    observe_value,
     wait_for_value,
 )
-from ophyd_async.core.signal import observe_value
 
-from .._common_blocks import CommonPandaBlocks
-from ._panda_hdf_file import _HDFDataset, _HDFFile
+from ._common_blocks import CommonPandaBlocks
 
 
 class PandaHDFWriter(DetectorWriter):
@@ -22,13 +24,17 @@ class PandaHDFWriter(DetectorWriter):
 
     def __init__(
         self,
-        directory_provider: DirectoryProvider,
+        prefix: str,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
         panda_device: CommonPandaBlocks,
     ) -> None:
         self.panda_device = panda_device
-        self._directory_provider = directory_provider
-        self._datasets: List[_HDFDataset] = []
-        self._file: Optional[_HDFFile] = None
+        self._prefix = prefix
+        self._path_provider = path_provider
+        self._name_provider = name_provider
+        self._datasets: List[HDFDataset] = []
+        self._file: Optional[HDFFile] = None
         self._multiplier = 1
 
     # Triggered on PCAP arm
@@ -39,16 +45,18 @@ class PandaHDFWriter(DetectorWriter):
         await self.panda_device.data.flush_period.set(0)
 
         self._file = None
-        info = self._directory_provider()
+        info = self._path_provider(device_name=self.panda_device.name)
         # Set the initial values
         await asyncio.gather(
             self.panda_device.data.hdf_directory.set(
                 str(info.root / info.resource_dir)
             ),
             self.panda_device.data.hdf_file_name.set(
-                f"{info.prefix}{self.panda_device.name}{info.suffix}.h5",
+                f"{info.filename}.h5",
             ),
             self.panda_device.data.num_capture.set(0),
+            # TODO: Set create_dir_depth once available
+            # https://github.com/bluesky/ophyd-async/issues/317
         )
 
         # Wait for it to start, stashing the status that tells us when it finishes
@@ -71,6 +79,7 @@ class PandaHDFWriter(DetectorWriter):
                 source=self.panda_device.data.hdf_directory.source,
                 shape=ds.shape,
                 dtype="array" if ds.shape != [1] else "number",
+                dtype_numpy="<f8",  # PandA data should always be written as Float64
                 external="STREAM:",
             )
             for ds in self._datasets
@@ -85,7 +94,7 @@ class PandaHDFWriter(DetectorWriter):
 
         capture_table = await self.panda_device.data.datasets.get_value()
         self._datasets = [
-            _HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
+            HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
             for dataset_name in capture_table["name"]
         ]
 
@@ -120,9 +129,10 @@ class PandaHDFWriter(DetectorWriter):
         # TODO: fail if we get dropped frames
         if indices_written:
             if not self._file:
-                self._file = _HDFFile(
-                    self._directory_provider(),
-                    Path(await self.panda_device.data.hdf_file_name.get_value()),
+                self._file = HDFFile(
+                    self._path_provider(),
+                    Path(await self.panda_device.data.hdf_directory.get_value())
+                    / Path(await self.panda_device.data.hdf_file_name.get_value()),
                     self._datasets,
                 )
                 for doc in self._file.stream_resources():

ophyd_async/{panda → fastcs/panda}/_panda_controller.py

@@ -7,7 +7,8 @@ from ophyd_async.core import (
     DetectorTrigger,
     wait_for_value,
 )
-from ophyd_async.panda import PcapBlock
+
+from ._common_blocks import PcapBlock
 
 
 class PandaPcapController(DetectorControl):

ophyd_async/{panda → fastcs/panda}/_table.py

@@ -1,9 +1,11 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional, Sequence, Type, TypedDict, TypeVar
+from typing import Optional, Sequence, Type, TypeVar
 
 import numpy as np
 import numpy.typing as npt
+import pydantic_numpy.typing as pnd
+from typing_extensions import NotRequired, TypedDict
 
 
 class PandaHdf5DatasetType(str, Enum):
@@ -54,23 +56,23 @@ class SeqTableRow:
 
 
 class SeqTable(TypedDict):
-    repeats: npt.NDArray[np.uint16]
-    trigger: Sequence[SeqTrigger]
-    position: npt.NDArray[np.int32]
-    time1: npt.NDArray[np.uint32]
-    outa1: npt.NDArray[np.bool_]
-    outb1: npt.NDArray[np.bool_]
-    outc1: npt.NDArray[np.bool_]
-    outd1: npt.NDArray[np.bool_]
-    oute1: npt.NDArray[np.bool_]
-    outf1: npt.NDArray[np.bool_]
-    time2: npt.NDArray[np.uint32]
-    outa2: npt.NDArray[np.bool_]
-    outb2: npt.NDArray[np.bool_]
-    outc2: npt.NDArray[np.bool_]
-    outd2: npt.NDArray[np.bool_]
-    oute2: npt.NDArray[np.bool_]
-    outf2: npt.NDArray[np.bool_]
+    repeats: NotRequired[pnd.Np1DArrayUint16]
+    trigger: NotRequired[Sequence[SeqTrigger]]
+    position: NotRequired[pnd.Np1DArrayInt32]
+    time1: NotRequired[pnd.Np1DArrayUint32]
+    outa1: NotRequired[pnd.Np1DArrayBool]
+    outb1: NotRequired[pnd.Np1DArrayBool]
+    outc1: NotRequired[pnd.Np1DArrayBool]
+    outd1: NotRequired[pnd.Np1DArrayBool]
+    oute1: NotRequired[pnd.Np1DArrayBool]
+    outf1: NotRequired[pnd.Np1DArrayBool]
+    time2: NotRequired[pnd.Np1DArrayUint32]
+    outa2: NotRequired[pnd.Np1DArrayBool]
+    outb2: NotRequired[pnd.Np1DArrayBool]
+    outc2: NotRequired[pnd.Np1DArrayBool]
+    outd2: NotRequired[pnd.Np1DArrayBool]
+    oute2: NotRequired[pnd.Np1DArrayBool]
+    outf2: NotRequired[pnd.Np1DArrayBool]
 
 
 def seq_table_from_rows(*rows: SeqTableRow):

ophyd_async/fastcs/panda/_trigger.py

@@ -0,0 +1,90 @@
+import asyncio
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from ophyd_async.core import TriggerLogic, wait_for_value
+
+from ._common_blocks import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
+from ._table import SeqTable
+
+
+class SeqTableInfo(BaseModel):
+    sequence_table: SeqTable = Field(strict=True)
+    repeats: int = Field(ge=0)
+    prescale_as_us: float = Field(default=1, ge=0)  # microseconds
+
+
+class StaticSeqTableTriggerLogic(TriggerLogic[SeqTableInfo]):
+    def __init__(self, seq: SeqBlock) -> None:
+        self.seq = seq
+
+    async def prepare(self, value: SeqTableInfo):
+        await asyncio.gather(
+            self.seq.prescale_units.set(TimeUnits.us),
+            self.seq.enable.set("ZERO"),
+        )
+        await asyncio.gather(
+            self.seq.prescale.set(value.prescale_as_us),
+            self.seq.repeats.set(value.repeats),
+            self.seq.table.set(value.sequence_table),
+        )
+
+    async def kickoff(self) -> None:
+        await self.seq.enable.set("ONE")
+        await wait_for_value(self.seq.active, True, timeout=1)
+
+    async def complete(self) -> None:
+        await wait_for_value(self.seq.active, False, timeout=None)
+
+    async def stop(self):
+        await self.seq.enable.set("ZERO")
+        await wait_for_value(self.seq.active, False, timeout=1)
+
+
+class PcompInfo(BaseModel):
+    start_postion: int = Field(description="start position in counts")
+    pulse_width: int = Field(description="width of a single pulse in counts", gt=0)
+    rising_edge_step: int = Field(
+        description="step between rising edges of pulses in counts", gt=0
+    )  #
+    number_of_pulses: int = Field(
+        description=(
+            "Number of pulses to send before the PCOMP block is disarmed. "
+            "0 means infinite."
+        ),
+        ge=0,
+    )
+    direction: PcompDirectionOptions = Field(
+        description=(
+            "Specifies which direction the motor counts should be "
+            "moving. Pulses won't be sent unless the values are moving in "
+            "this direction."
+        )
+    )
+
+
+class StaticPcompTriggerLogic(TriggerLogic[PcompInfo]):
+    def __init__(self, pcomp: PcompBlock) -> None:
+        self.pcomp = pcomp
+
+    async def prepare(self, value: PcompInfo):
+        await self.pcomp.enable.set("ZERO")
+        await asyncio.gather(
+            self.pcomp.start.set(value.start_postion),
+            self.pcomp.width.set(value.pulse_width),
+            self.pcomp.step.set(value.rising_edge_step),
+            self.pcomp.pulses.set(value.number_of_pulses),
+            self.pcomp.dir.set(value.direction),
+        )
+
+    async def kickoff(self) -> None:
+        await self.pcomp.enable.set("ONE")
+        await wait_for_value(self.pcomp.active, True, timeout=1)
+
+    async def complete(self, timeout: Optional[float] = None) -> None:
+        await wait_for_value(self.pcomp.active, False, timeout=timeout)
+
+    async def stop(self):
+        await self.pcomp.enable.set("ZERO")
+        await wait_for_value(self.pcomp.active, False, timeout=1)

ophyd_async/plan_stubs/__init__.py

@@ -1,5 +1,5 @@
-from .ensure_connected import ensure_connected
-from .fly import (
+from ._ensure_connected import ensure_connected
+from ._fly import (
     fly_and_collect,
     prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
     time_resolved_fly_and_collect_with_static_seq_table,

ophyd_async/plan_stubs/_ensure_connected.py

@@ -0,0 +1,26 @@
+import bluesky.plan_stubs as bps
+
+from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
+
+
+def ensure_connected(
+    *devices: Device,
+    mock: bool = False,
+    timeout: float = DEFAULT_TIMEOUT,
+    force_reconnect=False,
+):
+    (connect_task,) = yield from bps.wait_for(
+        [
+            lambda: wait_for_connection(
+                **{
+                    device.name: device.connect(
+                        mock=mock, timeout=timeout, force_reconnect=force_reconnect
+                    )
+                    for device in devices
+                }
+            )
+        ]
+    )
+
+    if connect_task and connect_task.exception() is not None:
+        raise connect_task.exception()

ophyd_async/plan_stubs/{fly.py → _fly.py}

@@ -1,24 +1,53 @@
-from typing import List
+from typing import List, Optional
 
 import bluesky.plan_stubs as bps
 from bluesky.utils import short_uid
 
-from ophyd_async.core.detector import DetectorTrigger, StandardDetector, TriggerInfo
-from ophyd_async.core.flyer import HardwareTriggeredFlyable
-from ophyd_async.core.utils import in_micros
-from ophyd_async.panda._table import SeqTable, SeqTableRow, seq_table_from_rows
-from ophyd_async.panda._trigger import SeqTableInfo
+from ophyd_async.core import (
+    DetectorTrigger,
+    StandardDetector,
+    StandardFlyer,
+    TriggerInfo,
+    in_micros,
+)
+from ophyd_async.fastcs.panda import (
+    PcompDirectionOptions,
+    PcompInfo,
+    SeqTable,
+    SeqTableInfo,
+    SeqTableRow,
+    seq_table_from_rows,
+)
+
+
+def prepare_static_pcomp_flyer_and_detectors(
+    flyer: StandardFlyer[PcompInfo],
+    detectors: List[StandardDetector],
+    pcomp_info: PcompInfo,
+    trigger_info: TriggerInfo,
+):
+    """Prepare a hardware triggered flyable and one or more detectors.
+
+    Prepare a hardware triggered flyable and one or more detectors with the
+    same trigger.
+
+    """
+
+    for det in detectors:
+        yield from bps.prepare(det, trigger_info, wait=False, group="prep")
+    yield from bps.prepare(flyer, pcomp_info, wait=False, group="prep")
+    yield from bps.wait(group="prep")
 
 
 def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    flyer: StandardFlyer[SeqTableInfo],
     detectors: List[StandardDetector],
     number_of_frames: int,
     exposure: float,
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
-    frame_timeout: float | None = None,
+    frame_timeout: Optional[float] = None,
 ):
     """Prepare a hardware triggered flyable and one or more detectors.
 
@@ -36,7 +65,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     deadtime = max(det.controller.get_deadtime(exposure) for det in detectors)
 
     trigger_info = TriggerInfo(
-        num=number_of_frames * repeats,
+        number=number_of_frames * repeats,
         trigger=DetectorTrigger.constant_gate,
         deadtime=deadtime,
         livetime=exposure,
@@ -65,7 +94,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
         SeqTableRow(time2=in_micros(shutter_time)),
     )
 
-    table_info = SeqTableInfo(table, repeats)
+    table_info = SeqTableInfo(sequence_table=table, repeats=repeats)
 
     for det in detectors:
         yield from bps.prepare(det, trigger_info, wait=False, group="prep")
@@ -75,7 +104,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
 
 def fly_and_collect(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    flyer: StandardFlyer[SeqTableInfo] | StandardFlyer[PcompInfo],
     detectors: List[StandardDetector],
 ):
     """Kickoff, complete and collect with a flyer and multiple detectors.
@@ -113,9 +142,35 @@ def fly_and_collect(
     yield from bps.wait(group=group)
 
 
+def fly_and_collect_with_static_pcomp(
+    stream_name: str,
+    flyer: StandardFlyer[PcompInfo],
+    detectors: List[StandardDetector],
+    number_of_pulses: int,
+    pulse_width: int,
+    rising_edge_step: int,
+    direction: PcompDirectionOptions,
+    trigger_info: TriggerInfo,
+):
+    # Set up scan and prepare trigger
+    pcomp_info = PcompInfo(
+        start_postion=0,
+        pulse_width=pulse_width,
+        rising_edge_step=rising_edge_step,
+        number_of_pulses=number_of_pulses,
+        direction=direction,
+    )
+    yield from prepare_static_pcomp_flyer_and_detectors(
+        flyer, detectors, pcomp_info, trigger_info
+    )
+
+    # Run the fly scan
+    yield from fly_and_collect(stream_name, flyer, detectors)
+
+
 def time_resolved_fly_and_collect_with_static_seq_table(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    flyer: StandardFlyer[SeqTableInfo],
     detectors: List[StandardDetector],
     number_of_frames: int,
     exposure: float,

ophyd_async/sim/__init__.py

@@ -1,11 +0,0 @@
-from .pattern_generator import PatternGenerator
-from .sim_pattern_detector_control import SimPatternDetectorControl
-from .sim_pattern_detector_writer import SimPatternDetectorWriter
-from .sim_pattern_generator import SimPatternDetector
-
-__all__ = [
-    "PatternGenerator",
-    "SimPatternDetectorControl",
-    "SimPatternDetectorWriter",
-    "SimPatternDetector",
-]

ophyd_async/sim/demo/__init__.py

@@ -1,3 +1,19 @@
-from .sim_motor import SimMotor
+from ._pattern_detector import (
+    DATA_PATH,
+    SUM_PATH,
+    PatternDetector,
+    PatternDetectorController,
+    PatternDetectorWriter,
+    PatternGenerator,
+)
+from ._sim_motor import SimMotor
 
-__all__ = ["SimMotor"]
+__all__ = [
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "SimMotor",
+]

ophyd_async/sim/demo/_pattern_detector/__init__.py

@@ -0,0 +1,13 @@
+from ._pattern_detector import PatternDetector
+from ._pattern_detector_controller import PatternDetectorController
+from ._pattern_detector_writer import PatternDetectorWriter
+from ._pattern_generator import DATA_PATH, SUM_PATH, PatternGenerator
+
+__all__ = [
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+]

ophyd_async/sim/demo/_pattern_detector/_pattern_detector.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from typing import Sequence
+
+from ophyd_async.core import (
+    AsyncReadable,
+    FilenameProvider,
+    PathProvider,
+    StandardDetector,
+    StaticFilenameProvider,
+    StaticPathProvider,
+)
+
+from ._pattern_detector_controller import PatternDetectorController
+from ._pattern_detector_writer import PatternDetectorWriter
+from ._pattern_generator import PatternGenerator
+
+
+class PatternDetector(StandardDetector):
+    def __init__(
+        self,
+        path: Path,
+        config_sigs: Sequence[AsyncReadable] = [],
+        name: str = "",
+    ) -> None:
+        fp: FilenameProvider = StaticFilenameProvider(name)
+        self.path_provider: PathProvider = StaticPathProvider(fp, path)
+        self.pattern_generator = PatternGenerator()
+        writer = PatternDetectorWriter(
+            pattern_generator=self.pattern_generator,
+            path_provider=self.path_provider,
+            name_provider=lambda: self.name,
+        )
+        controller = PatternDetectorController(
+            pattern_generator=self.pattern_generator,
+            path_provider=self.path_provider,
+        )
+        super().__init__(
+            controller=controller,
+            writer=writer,
+            config_sigs=config_sigs,
+            name=name,
+        )

ophyd_async/sim/{sim_pattern_detector_control.py → demo/_pattern_detector/_pattern_detector_controller.py}

@@ -1,22 +1,21 @@
 import asyncio
 from typing import Optional
 
-from ophyd_async.core import DirectoryProvider
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.detector import DetectorControl, DetectorTrigger
-from ophyd_async.sim.pattern_generator import PatternGenerator
+from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger, PathProvider
 
+from ._pattern_generator import PatternGenerator
 
-class SimPatternDetectorControl(DetectorControl):
+
+class PatternDetectorController(DetectorControl):
     def __init__(
         self,
         pattern_generator: PatternGenerator,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         exposure: float = 0.1,
     ) -> None:
         self.pattern_generator: PatternGenerator = pattern_generator
         self.pattern_generator.set_exposure(exposure)
-        self.directory_provider: DirectoryProvider = directory_provider
+        self.path_provider: PathProvider = path_provider
         self.task: Optional[asyncio.Task] = None
         super().__init__()
 

ophyd_async/sim/{sim_pattern_detector_writer.py → demo/_pattern_detector/_pattern_detector_writer.py}

@@ -2,23 +2,27 @@ from typing import AsyncGenerator, AsyncIterator, Dict
 
 from bluesky.protocols import DataKey
 
-from ophyd_async.core import DirectoryProvider
-from ophyd_async.core.detector import DetectorWriter
-from ophyd_async.sim.pattern_generator import PatternGenerator
+from ophyd_async.core import DetectorWriter, NameProvider, PathProvider
 
+from ._pattern_generator import PatternGenerator
 
-class SimPatternDetectorWriter(DetectorWriter):
+
+class PatternDetectorWriter(DetectorWriter):
     pattern_generator: PatternGenerator
 
     def __init__(
-        self, pattern_generator: PatternGenerator, directoryProvider: DirectoryProvider
+        self,
+        pattern_generator: PatternGenerator,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
     ) -> None:
         self.pattern_generator = pattern_generator
-        self.directory_provider = directoryProvider
+        self.path_provider = path_provider
+        self.name_provider = name_provider
 
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         return await self.pattern_generator.open_file(
-            self.directory_provider, multiplier
+            self.path_provider, self.name_provider(), multiplier
         )
 
     async def close(self) -> None:
@@ -31,4 +35,4 @@ class SimPatternDetectorWriter(DetectorWriter):
         return self.pattern_generator.observe_indices_written()
 
     async def get_indices_written(self) -> int:
-        return self.pattern_generator.written_images_counter
+        return self.pattern_generator.image_counter