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

dodal/beamlines/p45.py

@@ -1,15 +1,15 @@
 from pathlib import Path
 
-from ophyd_async.epics.areadetector import AravisDetector
-from ophyd_async.panda import HDFPanda
+from ophyd_async.epics.adaravis import AravisDetector
+from ophyd_async.fastcs.panda import HDFPanda
 
 from dodal.common.beamlines.beamline_utils import (
     device_instantiation,
-    get_directory_provider,
-    set_directory_provider,
+    get_path_provider,
+    set_path_provider,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.common.visit import StaticVisitDirectoryProvider
+from dodal.common.visit import StaticVisitPathProvider
 from dodal.devices.p45 import Choppers, TomoStageWithStretchAndSkew
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import get_beamline_name, skip_device
@@ -17,8 +17,8 @@ from dodal.utils import get_beamline_name, skip_device
 BL = get_beamline_name("p45")
 set_log_beamline(BL)
 set_utils_beamline(BL)
-set_directory_provider(
-    StaticVisitDirectoryProvider(
+set_path_provider(
+    StaticVisitPathProvider(
         BL,
         Path("/data/2024/cm37283-2/"),  # latest commissioning visit
     )
@@ -62,7 +62,7 @@ def det(
         fake_with_ophyd_sim,
         drv_suffix="DET:",
         hdf_suffix="HDF5:",
-        directory_provider=get_directory_provider(),
+        path_provider=get_path_provider(),
     )
 
 
@@ -79,7 +79,7 @@ def diff(
         fake_with_ophyd_sim,
         drv_suffix="DET:",
         hdf_suffix="HDF5:",
-        directory_provider=get_directory_provider(),
+        path_provider=get_path_provider(),
     )
 
 
@@ -97,7 +97,7 @@ def panda1(
         "-MO-PANDA-01:",
         wait_for_connection,
         fake_with_ophyd_sim,
-        directory_provider=get_directory_provider(),
+        path_provider=get_path_provider(),
     )
 
 
@@ -112,5 +112,5 @@ def panda2(
         "-MO-PANDA-02:",
         wait_for_connection,
         fake_with_ophyd_sim,
-        directory_provider=get_directory_provider(),
+        path_provider=get_path_provider(),
     )

dodal/beamlines/training_rig.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+
+from ophyd_async.epics.adaravis import AravisDetector
+
+from dodal.common.beamlines.beamline_utils import (
+    device_instantiation,
+    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.training_rig.sample_stage import TrainingRigSampleStage
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import get_beamline_name
+
+#
+# HTSS Training Rig
+#
+# A mock-beamline design that is employed at Diamond, consisting of a pair of
+# simple motors, a GigE camera and a PandA.
+# Since there are multiple rigs whose PVs are identical aside from the prefix,
+# this module can be used for any rig. It should fill in the prefix automatically
+# if the ${BEAMLINE} environment variable is correctly set. It currently defaults
+# to p47.
+#
+
+BL = get_beamline_name("p47")
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/exports/mybeamline/data"),
+        client=LocalDirectoryServiceClient(),
+    )
+)
+
+
+def sample_stage(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> TrainingRigSampleStage:
+    return device_instantiation(
+        TrainingRigSampleStage,
+        "sample_stage",
+        "-MO-MAP-01:STAGE:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )
+
+
+def det(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> AravisDetector:
+    return device_instantiation(
+        AravisDetector,
+        "det",
+        "-EA-DET-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+        drv_suffix="DET:",
+        hdf_suffix="HDF5:",
+        path_provider=get_path_provider(),
+    )

dodal/common/beamlines/beamline_parameters.py

@@ -7,7 +7,7 @@ BEAMLINE_PARAMETER_KEYWORDS = ["FB", "FULL", "deadtime"]
 
 BEAMLINE_PARAMETER_PATHS = {
     "i03": "/dls_sw/i03/software/daq_configuration/domain/beamlineParameters",
-    "i04": "/dls_sw/i04/software/gda_versions/gda_9_29/workspace_git/gda-mx.git/configurations/i04-config/scripts/beamlineParameters",
+    "i04": "/dls_sw/i04/software/gda_versions/gda_9_34/workspace_git/gda-mx.git/configurations/i04-config/scripts/beamlineParameters",
     "s03": "tests/test_data/test_beamline_parameters.txt",
 }
 
@@ -15,6 +15,9 @@ BEAMLINE_PARAMETER_PATHS = {
 class GDABeamlineParameters:
     params: dict[str, Any]
 
+    def __init__(self, params: dict[str, Any]):
+        self.params = params
+
     def __repr__(self) -> str:
         return repr(self.params)
 
@@ -23,7 +26,6 @@ class GDABeamlineParameters:
 
     @classmethod
     def from_lines(cls, file_name: str, config_lines: list[str]):
-        ob = cls()
         config_lines_nocomments = [line.split("#", 1)[0] for line in config_lines]
         config_lines_sep_key_and_value = [
             # XXX removes all whitespace instead of just trim
@@ -46,8 +48,7 @@ class GDABeamlineParameters:
             except Exception as e:
                 LOGGER.warning(f"Unable to parse {file_name} line {i}: {e}")
 
-        ob.params = dict(config_pairs)
-        return ob
+        return cls(params=dict(config_pairs))
 
     @classmethod
     def from_file(cls, path: str):

dodal/common/beamlines/beamline_utils.py

@@ -8,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] = {}
 BL = ""
-DIRECTORY_PROVIDER: UpdatingDirectoryProvider | None = None
+PATH_PROVIDER: UpdatingPathProvider | None = None
 
 
 def set_beamline(beamline: str):
@@ -125,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/types.py

@@ -5,7 +5,7 @@ from typing import (
 )
 
 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
@@ -15,6 +15,8 @@ MsgGenerator = Generator[Msg, Any, None]
 PlanGenerator = Callable[..., MsgGenerator]
 
 
-class UpdatingDirectoryProvider(DirectoryProvider, ABC):
+class UpdatingPathProvider(PathProvider, ABC):
+    @abstractmethod
+    async def data_session(self) -> str: ...
     @abstractmethod
     async def update(self, **kwargs) -> None: ...

dodal/common/udc_directory_provider.py

@@ -1,27 +1,37 @@
 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"""
 
     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
-        )
+
+    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
@@ -32,16 +42,13 @@ class PandASubdirectoryProvider(UpdatingDirectoryProvider):
              suffix: Optional str that will be appended to the panda device name along with the file
                 type extension to construct the output filename
         """
-        output_directory = directory / self.resource_dir
-        output_directory.mkdir(exist_ok=True)
-
-        self._directory_info = DirectoryInfo(
-            root=directory, resource_dir=self.resource_dir, suffix=suffix
+        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,11 +1,12 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
+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
 
 """
@@ -22,7 +23,7 @@ class DataCollectionIdentifier(BaseModel):
     collectionNumber: int
 
 
-class DirectoryServiceClientBase(ABC):
+class DirectoryServiceClient(ABC):
     """
     Object responsible for I/O in determining collection number
     """
@@ -36,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
 
@@ -84,33 +97,30 @@ 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: DirectoryServiceClientBase | None = 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, **kwargs) -> None:
         """
@@ -121,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,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
 
 

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