dls-dodal 1.68.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

dodal/devices/zocalo/zocalo_results.py

@@ -53,25 +53,27 @@ _NO_SAMPLE_ID = -1
 
 
 class XrcResult(TypedDict):
-    """
-    Information about a diffracting centre.
+    """Information about a diffracting centre.
 
     NOTE: the coordinate systems of centre_of_mass and max_voxel/bounding_box are not
-        the same; centre_of_mass coordinates are continuous whereas max_voxel and bounding_box
-        coordinates are discrete.
+        the same; centre_of_mass coordinates are continuous whereas max_voxel and
+        bounding_box coordinates are discrete.
+
     Attributes:
-         centre_of_mass: The position of the centre of mass of the crystal, adjusted so that
-         grid box centres lie on integer grid coordinates, such that a 1x1x1 crystal detected in
-         a single grid box at 0, 0, 0, has c.o.m. of 0, 0, 0, not 0.5, 0.5, 0.5
-         max_voxel: Position of the voxel with the maximum count, in integer coordinates
-         max_count: max count achieved in a single voxel for the crystal
-         n_voxels: Number of voxels (aka grid boxes) in the diffracting centre
-         total_count: Total of above-threshold spot counts in the labelled voxels
-         bounding_box: The rectangular prism that bounds the crystal, expressed
-            as the volume of whole boxes as a half-open range i.e such that
+         centre_of_mass (list[float]): The position of the centre of mass of the
+            crystal, adjusted so that grid box centres lie on integer grid coordinates,
+            such that a 1x1x1 crystal detected in a single grid box at 0, 0, 0, has
+            c.o.m. of 0, 0, 0, not 0.5, 0.5, 0.5.
+         max_voxel (list[int]): Position of the voxel with the maximum count, in integer
+            coordinates.
+         max_count (int): Max count achieved in a single voxel for the crystal.
+         n_voxels (int): Number of voxels (aka grid boxes) in the diffracting centre.
+         total_count (int): Total of above-threshold spot counts in the labelled voxels.
+         bounding_box (list[list[int]]): The rectangular prism that bounds the crystal,
+            expressed as the volume of whole boxes as a half-open range i.e such that
             p1 = (x1, y1, z1) <= p < p2 = (x2, y2, z2) and
             p2 - p1 gives the dimensions in whole voxels.
-         sample_id: The sample id associated with the centre.
+         sample_id (int): The sample id associated with the centre.
     """
 
     centre_of_mass: list[float]
@@ -106,21 +108,17 @@ class ZocaloResults(StandardReadable, Triggerable):
     See https://diamondlightsource.github.io/dodal/main/how-to/zocalo.html
 
     Args:
-        name (str): Name of the device
-
-        zocalo_environment (str): How zocalo is configured. Defaults to i03's development configuration
-
-        channel (str): Name for the results Queue
-
-        sort_key (str): How results are ranked. Defaults to sorting by highest counts
-
-        timeout_s (float): Maximum time to wait for the Queue to be filled by an object, starting
-        from when the ZocaloResults device is triggered
-
-        prefix (str): EPICS PV prefix for the device
-
-        results_source (ZocaloSource): Where to get results from, GPU or CPU analysis
-
+        name (str, optional): Name of the device.
+        zocalo_environment (str, optional): How zocalo is configured. Defaults to i03's
+            development configuration.
+        channel (str, optional): Name for the results Queue.
+        sort_key (str, optional): How results are ranked. Defaults to sorting by highest
+            counts.
+        timeout_s (float, optional): Maximum time to wait for the Queue to be filled by
+            an object, starting from when the ZocaloResults device is triggered.
+        prefix (str): EPICS PV prefix for the device.
+        results_source (ZocaloSource, optional): Where to get results from, GPU or CPU
+            analysis.
     """
 
     def __init__(
@@ -205,8 +203,8 @@ class ZocaloResults(StandardReadable, Triggerable):
         """Stages the Zocalo device by: subscribing to the queue, doing a background
         sleep for a few seconds to wait for any stale messages to be received, then
         clearing the queue. Plans using this device should wait on ZOCALO_STAGE_GROUP
-        before triggering processing for the experiment"""
-
+        before triggering processing for the experiment.
+        """
         LOGGER.info("Subscribing to results queue")
         try:
             self._subscribe_to_results()
@@ -312,8 +310,10 @@ def _corrected_xrc_result(uncorrected: XrcResult) -> XrcResult:
 def get_full_processing_results(
     zocalo: ZocaloResults,
 ) -> Generator[Msg, Any, Sequence[XrcResult]]:
-    """A plan that will return the raw zocalo results, ranked in descending order according to the sort key.
-    Returns empty list in the event no results found."""
+    """A plan that will return the raw zocalo results, ranked in descending order
+    according to the sort key.
+    Returns empty list in the event no results found.
+    """
     LOGGER.info("Retrieving raw zocalo processing results")
     com = yield from bps.rd(zocalo.centre_of_mass, default_value=[])
     max_voxel = yield from bps.rd(zocalo.max_voxel, default_value=[])

dodal/log.py

@@ -57,11 +57,11 @@ class CircularMemoryHandler(logging.Handler):
     """Loosely based on the MemoryHandler, which keeps a buffer and writes it when full
     or when there is a record of specific level. This instead keeps a circular buffer
     that always contains the last {capacity} number of messages, this is only flushed
-    when a log of specific {flush_level} comes in. On flush this buffer is then passed to
-    the {target} handler.
+    when a log of specific {flush_level} comes in. On flush this buffer is then passed
+    to the {target} handler.
 
-    The CircularMemoryHandler becomes the owner of the target handler which will be closed
-    on close of this handler.
+    The CircularMemoryHandler becomes the owner of the target handler which will be
+    closed on close of this handler.
     """
 
     def __init__(self, capacity, flush_level=logging.ERROR, target=None):
@@ -76,9 +76,7 @@ class CircularMemoryHandler(logging.Handler):
             self.flush()
 
     def flush(self):
-        """
-        Pass the contents of the buffer forward to the target.
-        """
+        """Pass the contents of the buffer forward to the target."""
         self.acquire()
         try:
             if self.target:
@@ -151,7 +149,8 @@ def set_up_graylog_handler(logger: Logger, host: str, port: int):
 
 def set_up_info_file_handler(logger, path: Path, filename: str):
     """Set up a file handler for the logger, at INFO level, which will keep 30 days
-    of logs, rotating once per day. Creates the directory if necessary."""
+    of logs, rotating once per day. Creates the directory if necessary.
+    """
     print(f"Logging to INFO file handler {path / filename}")
     path.mkdir(parents=True, exist_ok=True)
     file_handler = TimedRotatingFileHandler(
@@ -167,7 +166,8 @@ def set_up_debug_memory_handler(
 ):
     """Set up a Memory handler which holds 200k lines, and writes them to an hourly
     log file when it sees a message of severity ERROR. Creates the directory if
-    necessary"""
+    necessary.
+    """
     debug_path = path / "debug"
     print(f"Logging to DEBUG handler {debug_path / filename}")
     debug_path.mkdir(parents=True, exist_ok=True)
@@ -204,17 +204,20 @@ def set_up_all_logging_handlers(
     debug_logging_path: Path | None = None,
 ) -> DodalLogHandlers:
     """Set up the default logging environment.
+
     Args:
-        logger:                 the logging.Logger object to apply all the handlers to.
-        logging_path:           The location to store log files.
-        filename:               The log filename.
-        dev_mode:               If true, will log to graylog on localhost instead of
-                                production. Defaults to False.
-        error_log_buffer_lines: Number of lines for the CircularMemoryHandler to keep in
-                                buffer and write to file when encountering an error message.
-        graylog_port:           The port to send graylog messages to, if None uses the
-                                default dodal port
-        debug_logging_path:     The location to store debug log files, if None uses `logging_path`
+        logger (Logger): The logging.Logger object to apply all the handlers to.
+        logging_path (Path): The location to store log files.
+        filename (str): The log filename.
+        dev_mode (bool): If true, will log to graylog on localhost instead of
+             production. Defaults to False.
+        error_log_buffer_lines (int): Number of lines for the CircularMemoryHandler to
+            keep in buffer and write to file when encountering an error message.
+        graylog_port (int, optional): The port to send graylog messages to, if None uses
+            the default dodal port
+        debug_logging_path (Path, optional): The location to store debug log files, if
+            None uses `logging_path`
+
     Returns:
         A DodaLogHandlers TypedDict with the created handlers.
     """
@@ -261,7 +264,7 @@ def get_logging_file_paths() -> tuple[Path, Path]:
 
     Returns:
         tuple[Path, Path]: Paths to the standard log file and to the debug log file,
-                           for the file handlers to write to
+            for the file handlers to write to
     """
     beamline: str | None = environ.get("BEAMLINE")
 

dodal/plan_stubs/check_topup.py

@@ -49,15 +49,17 @@ def _delay_to_avoid_topup(
     total_exposure_time_s: float,
 ) -> bool:
     """Determine whether we should delay collection until after a topup. Generally
-    if a topup is due to occur during the collection we will delay collection until after the topup.
-    However for long-running collections, impact of the topup is potentially less and collection-duration may be
-    a significant fraction of the topup-interval, therefore we may wish to collect during a topup.
+    if a topup is due to occur during the collection we will delay collection until
+    after the topup. However for long-running collections, impact of the topup is
+    potentially less and collection-duration may be a significant fraction of the
+    topup-interval, therefore we may wish to collect during a topup.
 
     Args:
-        total_run_time_s: Anticipated time until end of the collection in seconds
-        time_to_topup_s: Time to the start of the topup as measured from the PV
-        topup_configuration: configuration dictionary
-        total_exposure_time_s: Total exposure time of the sample in s"""
+        total_run_time_s (float): Anticipated time until end of the collection in seconds.
+        time_to_topup_s (float): Time to the start of the topup as measured from the PV.
+        topup_configuration (dict): Configuration dictionary.
+        total_exposure_time_s (float): Total exposure time of the sample in s.
+    """
     if total_run_time_s > time_to_topup_s:
         limit_s = topup_configuration.get(
             TopupConfig.THRESHOLD_EXPOSURE_S, DEFAULT_THRESHOLD_EXPOSURE_S
@@ -75,9 +77,7 @@ def _delay_to_avoid_topup(
                 """)
         return gate
     LOGGER.info(
-        """
-        Total run time less than time to next topup. Proceeding with collection.
-        """
+        """Total run time less than time to next topup. Proceeding with collection."""
     )
     return False
 
@@ -95,15 +95,15 @@ def check_topup_and_wait_if_necessary(
     total_exposure_time: float,
     ops_time: float,  # Account for xray centering, rotation speed, etc
 ):  # See https://github.com/DiamondLightSource/hyperion/issues/932
-    """A small plan to check if topup gating is permitted and sleep until the topup\
+    """A small plan to check if topup gating is permitted and sleep until the topup
         is over if it starts before the end of collection.
 
     Args:
         synchrotron (Synchrotron): Synchrotron device.
-        total_exposure_time (float): Expected total exposure time for \
-            collection, in seconds.
-        ops_time (float): Additional time to account for various operations,\
-            eg. x-ray centering, in seconds. Defaults to 30.0.
+        total_exposure_time (float): Expected total exposure time for  collection, in
+            seconds.
+        ops_time (float): Additional time to account for various operations, eg. x-ray
+            centering, in seconds. Defaults to 30.0.
     """
     machine_mode = yield from bps.rd(synchrotron.synchrotron_mode)
     assert isinstance(machine_mode, SynchrotronMode)

dodal/plan_stubs/data_session.py

@@ -15,8 +15,7 @@ DATA_GROUPS = "data_groups"
 def attach_data_session_metadata_wrapper(
     plan: MsgGenerator, provider: PathProvider | None = None
 ) -> MsgGenerator:
-    """
-    Attach data session metadata to the runs within a plan and make it correlate
+    """Attach data session metadata to the runs within a plan and make it correlate
     with an ophyd-async PathProvider.
 
     This updates the path provider (which in turn makes a call to to a service
@@ -24,14 +23,15 @@ def attach_data_session_metadata_wrapper(
     start document contains the correct data session.
 
     Args:
-        plan: The plan to preprocess
-        provider: The path provider that participating detectors are aware of.
+        plan (MsgGenerator): The plan to preprocess.
+        provider (PathProvider): The path provider that participating detectors are
+            aware of.
 
     Returns:
-        MsgGenerator: A plan
+        MsgGenerator: A plan.
 
     Yields:
-        Iterator[Msg]: Plan messages
+        Iterator[Msg]: Plan messages.
     """
     try:
         provider = provider or get_path_provider()

dodal/plan_stubs/motor_utils.py

@@ -29,8 +29,8 @@ def check_and_cache_values(
     maximum_move: float,
 ) -> Generator[Msg, Any, dict[Motor, float]]:
     """Caches the positions of all Motors on specified device if they are within
-    smallest_move of home_position. Throws MoveTooLargeError if they are outside maximum_move
-    of the home_position
+    smallest_move of home_position. Throws MoveTooLargeError if they are outside
+    maximum_move of the home_position.
     """
     positions = {}
     for axis, new_position in devices_and_positions.items():
@@ -68,25 +68,29 @@ def move_and_reset_wrapper(
 ) -> MsgGenerator:
     """Wrapper that does the following:
        1. Caches the positions of all Motors on device
-       2. Throws a MoveTooLargeError exception if any positions are maximum_move away from home_position
-       2. Moves any motor that is more than smallest_move away from the home_position to home_position
-       3. Runs the specified plan
-       4. Moves all motors back to their cached positions
+       2. Throws a MoveTooLargeError exception if any positions are maximum_move away
+          from home_position
+       3. Moves any motor that is more than smallest_move away from the home_position to
+          home_position
+       4. Runs the specified plan
+       5. Moves all motors back to their cached positions
 
     Args:
-        plan (Callable[[], MsgGenerator]): The plan to move between homing and returning to the cache
-        device (Device): The device to move. All Motors in the device will be cached and moved
-        smallest_move (float): The smallest move that we care about doing the home and cache for.
-                               Useful for not wearing out motors if you have large tolerances
-        maximum_move (float): If any Motor starts this far from the home an exception is raised
-                              and no moves occur
-        home_position (float): The position to move every motor to after caching
+        plan (Callable[[], MsgGenerator]): The plan to move between homing and returning
+            to the cache.
+        device_and_positions (dict[Motor, float]): The device to move and position to
+            move it to. All Motors in the device will be cached and moved.
+        smallest_move (float): The smallest move that we care about doing the home and
+            cache for.  Useful for not wearing out motors if you have large tolerances.
+        maximum_move (float): If any Motor starts this far from the home an exception is
+            raised and no moves occur.
+        home_position (float): The position to move every motor to after caching.
         group (str, optional): If set the home move will be done using the home-{group}
-                               group and the reset to cache done using reset-{group}
-        wait_for_all (bool, optional): If true the home and reset to cache will be waited
-                                       on. If false it is left up to the caller to wait on
-                                       them. Defaults to True.
-    """
+            group and the reset to cache done using reset-{group}.
+        wait_for_all (bool, optional): If true the home and reset to cache will be
+            waited on. If false it is left up to the caller to wait on them. Defaults to
+            True.
+    """  # noqa D415
     initial_positions = yield from check_and_cache_values(
         device_and_positions, smallest_move, maximum_move
     )

dodal/plan_stubs/pressure_jump_cell.py

@@ -0,0 +1,18 @@
+import bluesky.plan_stubs as bps
+
+from dodal.devices.pressure_jump_cell import PressureJumpCell
+
+
+def set_pressure_jump(
+    pressure_cell: PressureJumpCell, pressure_from: int, pressure_to: int
+):
+    """Sets the desired pressures for a jump waiting for the device to complete the
+    operation.
+    """
+    yield from bps.mv(
+        pressure_cell.control.from_pressure,
+        pressure_from,
+        pressure_cell.control.to_pressure,
+        pressure_to,
+    )
+    yield from bps.trigger(pressure_cell.control.do_jump, wait=True)

dodal/plan_stubs/wrapped.py

@@ -6,9 +6,7 @@ import bluesky.plan_stubs as bps
 from bluesky.protocols import Movable
 from bluesky.utils import MsgGenerator
 
-"""
-Wrappers for Bluesky built-in plan stubs with type hinting
-"""
+"""Wrappers for Bluesky built-in plan stubs with type hinting."""
 
 Group = Annotated[str, "String identifier used by 'wait' or stubs that await"]
 
@@ -18,22 +16,21 @@ T = TypeVar("T")
 def set_absolute(
     movable: Movable[T], value: T, group: Group | None = None, wait: bool = False
 ) -> MsgGenerator:
-    """
-    Set a device, wrapper for `bp.abs_set`.
+    """Set a device, wrapper for `bp.abs_set`.
 
     Args:
-        movable (Movable[T]): The device to set
-        value (T): The new value
-        group (Group | None, optional): The message group to associate with the
-                                           setting, for sequencing. Defaults to None.
-        wait (bool, optional): The group should wait until all setting is complete
-                               (e.g. a motor has finished moving). Defaults to False.
+        movable (Movable[T]): The device to set.
+        value (T): The new value.
+        group (Group | None, optional): The message group to associate with the setting,
+            for sequencing. Defaults to None.
+        wait (bool, optional): The group should wait until all setting is complete (e.g.
+            a motor has finished moving). Defaults to False.
 
     Returns:
-        MsgGenerator: Plan
+        MsgGenerator: Plan.
 
     Yields:
-        Iterator[MsgGenerator]: Bluesky messages
+        Iterator[MsgGenerator]: Bluesky messages.
     """
     return (yield from bps.abs_set(movable, value, group=group, wait=wait))
 
@@ -41,43 +38,39 @@ def set_absolute(
 def set_relative(
     movable: Movable[T], value: T, group: Group | None = None, wait: bool = False
 ) -> MsgGenerator:
-    """
-    Change a device, wrapper for `bp.rel_set`.
+    """Change a device, wrapper for `bp.rel_set`.
 
     Args:
-        movable (Movable): The device to set
-        value (T): The new value
-        group (Group | None, optional): The message group to associate with the
-                                           setting, for sequencing. Defaults to None.
-        wait (bool, optional): The group should wait until all setting is complete
-                               (e.g. a motor has finished moving). Defaults to False.
+        movable (Movable): The device to set.
+        value (T): The new value.
+        group (Group | None, optional): The message group to associate with the setting,
+            for sequencing. Defaults to None.
+        wait (bool, optional): The group should wait until all setting is complete (e.g.
+            a motor has finished moving). Defaults to False.
 
     Returns:
-        MsgGenerator: Plan
+        MsgGenerator: Plan.
 
     Yields:
-        Iterator[MsgGenerator]: Bluesky messages
+        Iterator[MsgGenerator]: Bluesky messages.
     """
-
     return (yield from bps.rel_set(movable, value, group=group, wait=wait))
 
 
 def move(moves: Mapping[Movable[T], T], group: Group | None = None) -> MsgGenerator:
-    """
-    Move a device, wrapper for `bp.mv`.
+    """Move a device, wrapper for `bp.mv`.
 
     Args:
-        moves (Mapping[Movable, T]): Mapping of Movables to target positions
-        group (Group | None, optional): The message group to associate with the
-                                           setting, for sequencing. Defaults to None.
+        moves (Mapping[Movable, T]): Mapping of Movables to target positions.
+        group (Group | None, optional): The message group to associate with the setting,
+            for sequencing. Defaults to None.
 
     Returns:
-        MsgGenerator: Plan
+        MsgGenerator: Plan.
 
     Yields:
-        Iterator[MsgGenerator]: Bluesky messages
+        Iterator[MsgGenerator]: Bluesky messages.
     """
-
     return (
         yield from bps.mv(*itertools.chain.from_iterable(moves.items()), group=group)
     )
@@ -86,40 +79,36 @@ def move(moves: Mapping[Movable[T], T], group: Group | None = None) -> MsgGenera
 def move_relative(
     moves: Mapping[Movable[T], T], group: Group | None = None
 ) -> MsgGenerator:
-    """
-    Move a device relative to its current position, wrapper for `bp.mvr`.
+    """Move a device relative to its current position, wrapper for `bp.mvr`.
 
     Args:
-        moves (Mapping[Movable, T]): Mapping of Movables to target deltas
+        moves (Mapping[Movable, T]): Mapping of Movables to target deltas.
         group (Group | None, optional): The message group to associate with the
-                                           setting, for sequencing. Defaults to None.
+            setting, for sequencing. Defaults to None.
 
     Returns:
-        MsgGenerator: Plan
+        MsgGenerator: Plan.
 
     Yields:
-        Iterator[MsgGenerator]: Bluesky messages
+        Iterator[MsgGenerator]: Bluesky messages.
     """
-
     return (
         yield from bps.mvr(*itertools.chain.from_iterable(moves.items()), group=group)
     )
 
 
 def sleep(time: float) -> MsgGenerator:
-    """
-    Suspend all action for a given time, wrapper for `bp.sleep`
+    """Suspend all action for a given time, wrapper for `bp.sleep`.
 
     Args:
-        time (float): Time to wait in seconds
+        time (float): Time to wait in seconds.
 
     Returns:
-        MsgGenerator: Plan
+        MsgGenerator: Plan.
 
     Yields:
-        Iterator[MsgGenerator]: Bluesky messages
+        Iterator[MsgGenerator]: Bluesky messages.
     """
-
     return (yield from bps.sleep(time))
 
 
@@ -127,22 +116,18 @@ def wait(
     group: Group | None = None,
     timeout: float | None = None,
 ) -> MsgGenerator:
-    """
-    Wait for a group status to complete, wrapper for `bp.wait`.
+    """Wait for a group status to complete, wrapper for `bp.wait`.
     Does not expose move_on, as when used as a stub will not fail on Timeout.
 
     Args:
-        group (Group | None, optional): The name of the group to wait for, defaults
-                                           to None, in which case waits for all
-                                           groups that have not yet been awaited.
-        timeout (float | None, default=None): a timeout in seconds
-
+        group (Group | None, optional): The name of the group to wait for, defaults to
+            None, in which case waits for all groups that have not yet been awaited.
+        timeout (float | None, default=None): a timeout in seconds.
 
     Returns:
-        MsgGenerator: Plan
+        MsgGenerator: Plan.
 
     Yields:
-        Iterator[MsgGenerator]: Bluesky messages
+        Iterator[MsgGenerator]: Bluesky messages.
     """
-
     return (yield from bps.wait(group, timeout=timeout))