dls-dodal 1.29.4__py3-none-any.whl → 1.31.0__py3-none-any.whl

dodal/common/beamlines/beamline_utils.py

@@ -1,5 +1,6 @@
 import inspect
-from typing import Callable, Dict, Final, List, Optional, TypeVar, cast
+from collections.abc import Callable
+from typing import Final, TypeVar, cast
 
 from bluesky.run_engine import call_in_bluesky_event_loop
 from ophyd import Device as OphydV1Device
@@ -7,14 +8,14 @@ from ophyd.sim import make_fake_device
 from ophyd_async.core import Device as OphydV2Device
 from ophyd_async.core import wait_for_connection as v2_device_wait_for_connection
 
-from dodal.common.types import UpdatingDirectoryProvider
+from dodal.common.types import UpdatingPathProvider
 from dodal.utils import AnyDevice, BeamlinePrefix, skip_device
 
 DEFAULT_CONNECTION_TIMEOUT: Final[float] = 5.0
 
-ACTIVE_DEVICES: Dict[str, AnyDevice] = {}
+ACTIVE_DEVICES: dict[str, AnyDevice] = {}
 BL = ""
-DIRECTORY_PROVIDER: UpdatingDirectoryProvider | None = None
+PATH_PROVIDER: UpdatingPathProvider | None = None
 
 
 def set_beamline(beamline: str):
@@ -33,7 +34,7 @@ def clear_device(name: str):
     del ACTIVE_DEVICES[name]
 
 
-def list_active_devices() -> List[str]:
+def list_active_devices() -> list[str]:
     global ACTIVE_DEVICES
     return list(ACTIVE_DEVICES.keys())
 
@@ -59,7 +60,7 @@ def wait_for_connection(
         )
     else:
         raise TypeError(
-            "Invalid type {} in _wait_for_connection".format(device.__class__.__name__)
+            f"Invalid type {device.__class__.__name__} in _wait_for_connection"
         )
 
 
@@ -73,7 +74,7 @@ def device_instantiation(
     prefix: str,
     wait: bool,
     fake: bool,
-    post_create: Optional[Callable[[T], None]] = None,
+    post_create: Callable[[T], None] | None = None,
     bl_prefix: bool = True,
     **kwargs,
 ) -> T:
@@ -124,15 +125,15 @@ def device_instantiation(
     return device_instance
 
 
-def set_directory_provider(provider: UpdatingDirectoryProvider):
-    global DIRECTORY_PROVIDER
+def set_path_provider(provider: UpdatingPathProvider):
+    global PATH_PROVIDER
 
-    DIRECTORY_PROVIDER = provider
+    PATH_PROVIDER = provider
 
 
-def get_directory_provider() -> UpdatingDirectoryProvider:
-    if DIRECTORY_PROVIDER is None:
+def get_path_provider() -> UpdatingPathProvider:
+    if PATH_PROVIDER is None:
         raise ValueError(
-            "DirectoryProvider has not been set! Ophyd-async StandardDetectors will not be able to write!"
+            "PathProvider has not been set! Ophyd-async StandardDetectors will not be able to write!"
         )
-    return DIRECTORY_PROVIDER
+    return PATH_PROVIDER

dodal/common/maths.py

@@ -1,9 +1,7 @@
-from typing import Tuple
-
 import numpy as np
 
 
-def step_to_num(start: float, stop: float, step: float) -> Tuple[float, float, int]:
+def step_to_num(start: float, stop: float, step: float) -> tuple[float, float, int]:
     """
     Standard handling for converting from start, stop, step to start, stop, num
     Forces step to be same direction as length

dodal/common/types.py

@@ -1,12 +1,11 @@
 from abc import ABC, abstractmethod
+from collections.abc import Callable, Generator
 from typing import (
     Any,
-    Callable,
-    Generator,
 )
 
 from bluesky.utils import Msg
-from ophyd_async.core import DirectoryProvider
+from ophyd_async.core import PathProvider
 
 # String identifier used by 'wait' or stubs that await
 Group = str
@@ -16,6 +15,8 @@ MsgGenerator = Generator[Msg, Any, None]
 PlanGenerator = Callable[..., MsgGenerator]
 
 
-class UpdatingDirectoryProvider(DirectoryProvider, ABC):
+class UpdatingPathProvider(PathProvider, ABC):
     @abstractmethod
-    def update(self, **kwargs) -> None: ...
+    async def data_session(self) -> str: ...
+    @abstractmethod
+    async def update(self, **kwargs) -> None: ...

dodal/common/udc_directory_provider.py

@@ -1,36 +1,54 @@
 from pathlib import Path
 
-from ophyd_async.core import DirectoryInfo
+from ophyd_async.core import FilenameProvider, PathInfo
 
-from dodal.common.types import UpdatingDirectoryProvider
+from dodal.common.types import UpdatingPathProvider
 from dodal.log import LOGGER
 
 
-class PandASubdirectoryProvider(UpdatingDirectoryProvider):
+class PandAFilenameProvider(FilenameProvider):
+    def __init__(self, suffix: str | None = None):
+        self.suffix = suffix
+
+    def __call__(self, device_name: str | None = None):
+        return f"{device_name}-{self.suffix}"
+
+
+class PandASubpathProvider(UpdatingPathProvider):
     """Directory provider for the HDFPanda. Points to a panda subdirectory within the
-    directory path provided, which must exist before attempting to arm the PCAP block"""
+    directory path provided"""
 
     resource_dir = Path("panda")
 
-    def __init__(self, directory: Path | None = None):
-        if directory is None:
+    def __init__(self, root_directory: Path | None = None, suffix: str = ""):
+        self._output_directory: Path | None = (
+            root_directory / self.resource_dir if root_directory else None
+        )
+        self._filename_provider = PandAFilenameProvider(suffix=suffix)
+        if self._output_directory is None:
             LOGGER.debug(
                 f"{self.__class__.__name__} instantiated with no root path, update() must be called before writing data!"
             )
-        self._directory_info = (
-            DirectoryInfo(root=directory, resource_dir=self.resource_dir)
-            if directory
-            else None
-        )
 
-    def update(self, directory: Path):
-        self._directory_info = DirectoryInfo(
-            root=directory, resource_dir=self.resource_dir
+    async def data_session(self) -> str:
+        return self._filename_provider.suffix or ""
+
+    async def update(self, *, directory: Path, suffix: str = "", **kwargs):
+        """Update the root directory into which panda pcap files are written. This will result in the panda
+        subdirectory being created if it does not already exist.
+         Args:
+             directory: Path instance that identifies the root folder. This folder must exist. The panda will
+                attempt to write into the "panda" subdirectory which will be created if not already present.
+             suffix: Optional str that will be appended to the panda device name along with the file
+                type extension to construct the output filename
+        """
+        self._output_directory = directory / self.resource_dir
+        self._filename_provider.suffix = suffix
+
+    def __call__(self, device_name: str | None = None) -> PathInfo:
+        assert self._output_directory, "Directory unknown for PandA to write into, update() needs to be called at least once"
+        return PathInfo(
+            directory_path=self._output_directory,
+            filename=self._filename_provider(device_name),
+            create_dir_depth=-1,  # allows PandA HDFWriter to make any number of dirs
         )
-
-    def __call__(self) -> DirectoryInfo:
-        if self._directory_info is None:
-            raise ValueError(
-                "Directory unknown for PandA to write into, update() needs to be called at least once"
-            )
-        return self._directory_info

dodal/common/visit.py

@@ -1,12 +1,12 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Optional
+from typing import Literal
 
 from aiohttp import ClientSession
-from ophyd_async.core import DirectoryInfo
+from ophyd_async.core import FilenameProvider, PathInfo
 from pydantic import BaseModel
 
-from dodal.common.types import UpdatingDirectoryProvider
+from dodal.common.types import UpdatingPathProvider
 from dodal.log import LOGGER
 
 """
@@ -23,7 +23,7 @@ class DataCollectionIdentifier(BaseModel):
     collectionNumber: int
 
 
-class DirectoryServiceClientBase(ABC):
+class DirectoryServiceClient(ABC):
     """
     Object responsible for I/O in determining collection number
     """
@@ -37,41 +37,53 @@ class DirectoryServiceClientBase(ABC):
         """Get current collection"""
 
 
-class DirectoryServiceClient(DirectoryServiceClientBase):
+class DiamondFilenameProvider(FilenameProvider):
+    def __init__(self, beamline: str, client: DirectoryServiceClient):
+        self._beamline = beamline
+        self._client = client
+        self.collectionId: DataCollectionIdentifier | None = None
+
+    def __call__(self, device_name: str | None = None):
+        assert device_name, "Diamond filename requires device_name to be passed"
+        assert self.collectionId is not None
+        return f"{self._beamline}-{self.collectionId.collectionNumber}-{device_name}"
+
+
+class RemoteDirectoryServiceClient(DirectoryServiceClient):
     """Client for the VisitService REST API
     Currently exposed by the GDA Server to co-ordinate unique filenames.
     While VisitService is embedded in GDA, url is likely to be `ixx-control:8088/api`
     """
 
-    _url: str
-
     def __init__(self, url: str) -> None:
         self._url = url
 
     async def create_new_collection(self) -> DataCollectionIdentifier:
-        async with ClientSession() as session:
-            async with session.post(f"{self._url}/numtracker") as response:
-                response.raise_for_status()
-                json = await response.json()
-                new_collection = DataCollectionIdentifier.parse_obj(json)
-                LOGGER.debug("New DataCollection: %s", new_collection)
-                return new_collection
+        new_collection = await self._identifier_from_response("POST")
+        LOGGER.debug("New DataCollection: %s", new_collection)
+        return new_collection
 
     async def get_current_collection(self) -> DataCollectionIdentifier:
-        async with ClientSession() as session:
-            async with session.get(f"{self._url}/numtracker") as response:
-                response.raise_for_status()
-                json = await response.json()
-                current_collection = DataCollectionIdentifier.parse_obj(json)
-                LOGGER.debug("Current DataCollection: %s", current_collection)
-                return current_collection
-
+        current_collection = await self._identifier_from_response("GET")
+        LOGGER.debug("Current DataCollection: %s", current_collection)
+        return current_collection
 
-class LocalDirectoryServiceClient(DirectoryServiceClientBase):
+    async def _identifier_from_response(
+        self,
+        method: Literal["GET", "POST"],
+    ) -> DataCollectionIdentifier:
+        async with (
+            ClientSession() as session,
+            session.request(method, f"{self._url}/numtracker") as response,
+        ):
+            response.raise_for_status()
+            json = await response.json()
+            return DataCollectionIdentifier.model_validate_json(json)
+
+
+class LocalDirectoryServiceClient(DirectoryServiceClient):
     """Local or dummy impl of VisitService client to co-ordinate unique filenames."""
 
-    _count: int
-
     def __init__(self) -> None:
         self._count = 0
 
@@ -85,35 +97,32 @@ class LocalDirectoryServiceClient(DirectoryServiceClientBase):
         return DataCollectionIdentifier(collectionNumber=self._count)
 
 
-class StaticVisitDirectoryProvider(UpdatingDirectoryProvider):
+class StaticVisitPathProvider(UpdatingPathProvider):
     """
-    Static (single visit) implementation of DirectoryProvider whilst awaiting auth infrastructure to generate necessary information per-scan.
+    Static (single visit) implementation of PathProvider whilst awaiting auth infrastructure to generate necessary information per-scan.
     Allows setting a singular visit into which all run files will be saved.
     update() queries a visit service to get the next DataCollectionIdentifier to increment the suffix of all file writers' next files.
     Requires that all detectors are running with a mutual view on the filesystem.
     Supports a single Visit which should be passed as a Path relative to the root of the Detector IOC mounting.
-    i.e. to write to visit /dls/ixx/data/YYYY/cm12345-1, assuming all detectors are mounted with /data -> /dls/ixx/data, root=/data/YYYY/cm12345-1/
+    i.e. to write to visit /dls/ixx/data/YYYY/cm12345-1
     """
 
-    _beamline: str
-    _root: Path
-    _client: DirectoryServiceClientBase
-    _current_collection: DirectoryInfo | None
-    _session: ClientSession | None
-
     def __init__(
         self,
         beamline: str,
         root: Path,
-        client: Optional[DirectoryServiceClientBase] = None,
+        client: DirectoryServiceClient | None = None,
     ):
         self._beamline = beamline
-        self._client = client or DirectoryServiceClient(f"{beamline}-control:8088/api")
+        self._client = client or RemoteDirectoryServiceClient(
+            f"{beamline}-control:8088/api"
+        )
+        self._filename_provider = DiamondFilenameProvider(self._beamline, self._client)
         self._root = root
-        self._current_collection = None
-        self._session = None
+        self.current_collection: PathInfo | None
+        self._session: ClientSession | None
 
-    async def update(self) -> None:
+    async def update(self, **kwargs) -> None:
         """
         Creates a new data collection in the current visit.
         """
@@ -122,33 +131,22 @@ class StaticVisitDirectoryProvider(UpdatingDirectoryProvider):
         # TODO: DAQ-4827: Pass AuthN information as part of request
 
         try:
-            collection_id_info = await self._client.create_new_collection()
-            self._current_collection = self._generate_directory_info(collection_id_info)
+            self._filename_provider.collectionId = (
+                await self._client.create_new_collection()
+            )
         except Exception:
             LOGGER.error(
                 "Exception while updating data collection, preventing overwriting data by setting current_collection to None"
             )
-            self._current_collection = None
+            self._collection_id_info = None
             raise
 
-    def _generate_directory_info(
-        self,
-        collection_id_info: DataCollectionIdentifier,
-    ) -> DirectoryInfo:
-        return DirectoryInfo(
-            # See DocString of DirectoryInfo. At DLS, root = visit directory, resource_dir is relative to it.
-            root=self._root,
-            # https://github.com/DiamondLightSource/dodal/issues/452
-            # Currently all h5 files written to visit/ directory, as no guarantee that visit/dataCollection/ directory will have been produced. If it is as part of #452, append the resource_dir
-            resource_dir=Path("."),
-            # Diamond standard file naming
-            prefix=f"{self._beamline}-{collection_id_info.collectionNumber}-",
-        )
+    async def data_session(self) -> str:
+        collection = await self._client.get_current_collection()
+        return f"{self._beamline}-{collection.collectionNumber}"
 
-    def __call__(self) -> DirectoryInfo:
-        if self._current_collection is not None:
-            return self._current_collection
-        else:
-            raise ValueError(
-                "No current collection, update() needs to be called at least once"
-            )
+    def __call__(self, device_name: str | None = None) -> PathInfo:
+        assert device_name, "Must call PathProvider with device_name"
+        return PathInfo(
+            directory_path=self._root, filename=self._filename_provider(device_name)
+        )

dodal/devices/CTAB.py

@@ -1,8 +1,9 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor, EpicsSignalRO
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.signal import epics_signal_r
 
 
-class CTAB(Device):
+class CTAB(StandardReadable):
     """Basic collimantion table (CTAB) device for motion plus the motion disable signal
     when laser curtain triggered and hutch not locked.
 
@@ -17,20 +18,24 @@ class CTAB(Device):
     these disabling systems is to cut power to the motors - signal for this is crate_power
     """
 
-    inboard_y = Cpt(EpicsMotor, "-MO-TABLE-01:INBOARDY")
-    outboard_y = Cpt(EpicsMotor, "-MO-TABLE-01:OUTBOARDY")
-    upstream_y = Cpt(EpicsMotor, "-MO-TABLE-01:UPSTREAMY")
-    combined_downstream_y = Cpt(EpicsMotor, "-MO-TABLE-01:DOWNSTREAMY")
-    combined_all_y = Cpt(EpicsMotor, "-MO-TABLE-01:Y")
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.inboard_y = Motor(prefix + "-MO-TABLE-01:INBOARDY")
+            self.outboard_y = Motor(prefix + "-MO-TABLE-01:OUTBOARDY")
+            self.upstream_y = Motor(prefix + "-MO-TABLE-01:UPSTREAMY")
+            self.combined_downstream_y = Motor(prefix + "-MO-TABLE-01:DOWNSTREAMY")
+            self.combined_all_y = Motor(prefix + "-MO-TABLE-01:Y")
 
-    downstream_x = Cpt(EpicsMotor, "-MO-TABLE-01:DOWNSTREAMX")
-    upstream_x = Cpt(EpicsMotor, "-MO-TABLE-01:UPSTREAMX")
-    combined_all_x = Cpt(EpicsMotor, "-MO-TABLE-01:X")
+            self.downstream_x = Motor(prefix + "-MO-TABLE-01:DOWNSTREAMX")
+            self.upstream_x = Motor(prefix + "-MO-TABLE-01:UPSTREAMX")
+            self.combined_all_x = Motor(prefix + "-MO-TABLE-01:X")
 
-    pitch = Cpt(EpicsMotor, "-MO-TABLE-01:PITCH")
-    roll = Cpt(EpicsMotor, "-MO-TABLE-01:ROLL")
-    yaw = Cpt(EpicsMotor, "-MO-TABLE-01:YAW")
+            self.pitch = Motor(prefix + "-MO-TABLE-01:PITCH")
+            self.roll = Motor(prefix + "-MO-TABLE-01:ROLL")
+            self.yaw = Motor(prefix + "-MO-TABLE-01:YAW")
 
-    crate_power = Cpt(
-        EpicsSignalRO, "-MO-PMAC-02:CRATE2_HEALTHY"
-    )  # returns 0 if no power
+            self.crate_power = epics_signal_r(
+                int, prefix + "-MO-PMAC-02:CRATE2_HEALTHY"
+            )  # returns 0 if no power
+
+            super().__init__(name)

dodal/devices/aperture.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r