mx-bluesky 1.2.0__py3-none-any.whl → 1.4.1a0__py3-none-any.whl

mx_bluesky/__init__.py

@@ -1,6 +1,11 @@
-from importlib.metadata import version
+"""Top level API.
 
-__version__ = version("mx_bluesky")
-del version
+.. data:: __version__
+    :type: str
+
+    Version number as calculated by https://github.com/pypa/setuptools_scm
+"""
+
+from ._version import __version__
 
 __all__ = ["__version__"]

mx_bluesky/__main__.py

@@ -1,19 +1,24 @@
-from argparse import ArgumentParser
+"""Interface for ``python -m mx_bluesky``."""
 
-from mx_bluesky.example import run_plan
+from argparse import ArgumentParser
+from collections.abc import Sequence
 
 from . import __version__
 
 __all__ = ["main"]
 
 
-def main(args=None):
+def main(args: Sequence[str] | None = None) -> None:
+    """Argument parser for the CLI."""
     parser = ArgumentParser()
-    parser.add_argument("-v", "--version", action="version", version=__version__)
-    args = parser.parse_args(args)
-    run_plan()
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=__version__,
+    )
+    parser.parse_args(args)
 
 
-# test with: python -m mx_bluesky
 if __name__ == "__main__":
     main()

mx_bluesky/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.2.0'
-__version_tuple__ = version_tuple = (1, 2, 0)
+__version__ = version = '1.4.1a0'
+__version_tuple__ = version_tuple = (1, 4, 1)

mx_bluesky/beamlines/i04/callbacks/murko_callback.py

@@ -1,13 +1,16 @@
 import copy
 import json
+from datetime import timedelta
 
 from bluesky.callbacks import CallbackBase
 from dodal.log import LOGGER
-from event_model.documents import Event, RunStart
+from event_model.documents import Event, RunStart, RunStop
 from redis import StrictRedis
 
 
 class MurkoCallback(CallbackBase):
+    DATA_EXPIRY_DAYS = 7
+
     def __init__(self, redis_host: str, redis_password: str, redis_db: int = 0):
         self.redis_client = StrictRedis(
             host=redis_host, password=redis_password, db=redis_db
@@ -15,15 +18,17 @@ class MurkoCallback(CallbackBase):
         self.last_uuid = None
 
     def start(self, doc: RunStart) -> RunStart | None:
+        self.sample_id = doc.get("sample_id")
         self.murko_metadata = {
             "zoom_percentage": doc.get("zoom_percentage"),
             "microns_per_x_pixel": doc.get("microns_per_x_pixel"),
             "microns_per_y_pixel": doc.get("microns_per_y_pixel"),
             "beam_centre_i": doc.get("beam_centre_i"),
             "beam_centre_j": doc.get("beam_centre_j"),
-            "sample_id": doc.get("sample_id"),
+            "sample_id": self.sample_id,
         }
         self.last_uuid = None
+        LOGGER.info(f"Starting to stream metadata to murko under {self.sample_id}")
         return doc
 
     def event(self, doc: Event) -> Event:
@@ -40,6 +45,11 @@ class MurkoCallback(CallbackBase):
         metadata["uuid"] = uuid
 
         # Send metadata to REDIS and trigger murko
-        self.redis_client.hset("test-metadata", uuid, json.dumps(metadata))
+        redis_key = f"murko:{metadata['sample_id']}:metadata"
+        self.redis_client.hset(redis_key, uuid, json.dumps(metadata))
+        self.redis_client.expire(redis_key, timedelta(days=self.DATA_EXPIRY_DAYS))
         self.redis_client.publish("murko", json.dumps(metadata))
-        LOGGER.info("Metadata sent to redis")
+
+    def stop(self, doc: RunStop) -> RunStop | None:
+        LOGGER.info(f"Finished streaming {self.sample_id} to murko")
+        return doc

mx_bluesky/beamlines/i04/thawing_plan.py

@@ -1,11 +1,13 @@
+from collections.abc import Callable
+
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
 from bluesky.preprocessors import run_decorator, subs_decorator
-from dls_bluesky_core.core import MsgGenerator
+from bluesky.utils import MsgGenerator
 from dodal.beamlines.i04 import MURKO_REDIS_DB, REDIS_HOST, REDIS_PASSWORD
 from dodal.common import inject
 from dodal.devices.oav.oav_detector import OAV
-from dodal.devices.oav.oav_to_redis_forwarder import OAVToRedisForwarder
+from dodal.devices.oav.oav_to_redis_forwarder import OAVToRedisForwarder, Source
 from dodal.devices.robot import BartRobot
 from dodal.devices.smargon import Smargon
 from dodal.devices.thawer import Thawer, ThawerStates
@@ -22,31 +24,62 @@ def thaw_and_stream_to_redis(
     oav: OAV = inject("oav"),
     oav_to_redis_forwarder: OAVToRedisForwarder = inject("oav_to_redis_forwarder"),
 ) -> MsgGenerator:
-    zoom_percentage = yield from bps.rd(oav.zoom_controller.percentage)
+    zoom_percentage = yield from bps.rd(oav.zoom_controller.percentage)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     sample_id = yield from bps.rd(robot.sample_id)
 
-    yield from bps.abs_set(oav.zoom_controller.level, "1.0x", wait=True)
-    yield from bps.abs_set(oav_to_redis_forwarder.sample_id, sample_id)
+    sample_id = int(sample_id)
+    zoom_level_before_thawing = yield from bps.rd(oav.zoom_controller.level)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+
+    yield from bps.mv(oav.zoom_controller.level, "1.0x")  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+
+    def switch_forwarder_to_ROI() -> MsgGenerator:
+        yield from bps.complete(oav_to_redis_forwarder, wait=True)
+        yield from bps.mv(
+            # See: https://github.com/bluesky/bluesky/issues/1809
+            oav_to_redis_forwarder.selected_source,  # type: ignore
+            Source.ROI.value,  # type: ignore
+        )
+        yield from bps.kickoff(oav_to_redis_forwarder, wait=True)
+
+    microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
+    microns_per_pixel_y = yield from bps.rd(oav.microns_per_pixel_y)
+    beam_centre_i = yield from bps.rd(oav.beam_centre_i)
+    beam_centre_j = yield from bps.rd(oav.beam_centre_j)
 
     @subs_decorator(MurkoCallback(REDIS_HOST, REDIS_PASSWORD, MURKO_REDIS_DB))
     @run_decorator(
         md={
-            "microns_per_x_pixel": oav.parameters.micronsPerXPixel,
-            "microns_per_y_pixel": oav.parameters.micronsPerYPixel,
-            "beam_centre_i": oav.parameters.beam_centre_i,
-            "beam_centre_j": oav.parameters.beam_centre_j,
+            "microns_per_x_pixel": microns_per_pixel_x,
+            "microns_per_y_pixel": microns_per_pixel_y,
+            "beam_centre_i": beam_centre_i,
+            "beam_centre_j": beam_centre_j,
             "zoom_percentage": zoom_percentage,
             "sample_id": sample_id,
         }
     )
     def _thaw_and_stream_to_redis():
+        yield from bps.mv(
+            oav_to_redis_forwarder.sample_id,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+            sample_id,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+            oav_to_redis_forwarder.selected_source,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+            Source.FULL_SCREEN.value,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        )
+
         yield from bps.kickoff(oav_to_redis_forwarder, wait=True)
         yield from bps.monitor(smargon.omega.user_readback, name="smargon")
         yield from bps.monitor(oav_to_redis_forwarder.uuid, name="oav")
-        yield from thaw(time_to_thaw, rotation, thawer, smargon)
+        yield from thaw(
+            time_to_thaw, rotation, thawer, smargon, switch_forwarder_to_ROI
+        )
         yield from bps.complete(oav_to_redis_forwarder)
 
-    yield from _thaw_and_stream_to_redis()
+    def cleanup():
+        yield from bps.mv(oav.zoom_controller.level, zoom_level_before_thawing)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+
+    yield from bpp.contingency_wrapper(
+        _thaw_and_stream_to_redis(),
+        final_plan=cleanup,
+    )
 
 
 def thaw(
@@ -54,6 +87,7 @@ def thaw(
     rotation: float = 360,
     thawer: Thawer = inject("thawer"),
     smargon: Smargon = inject("smargon"),
+    plan_between_rotations: Callable[[], MsgGenerator] | None = None,
 ) -> MsgGenerator:
     """Rotates the sample and thaws it at the same time.
 
@@ -64,6 +98,8 @@ def thaw(
         thawer (Thawer, optional): The thawing device. Defaults to inject("thawer").
         smargon (Smargon, optional): The smargon used to rotate.
                                      Defaults to inject("smargon")
+        plan_between_rotations (MsgGenerator, optional): A plan to run between rotations
+                                    of the smargon. Defaults to no plan.
     """
     inital_velocity = yield from bps.rd(smargon.omega.velocity)
     new_velocity = abs(rotation / time_to_thaw) * 2.0
@@ -72,6 +108,8 @@ def thaw(
         yield from bps.abs_set(smargon.omega.velocity, new_velocity, wait=True)
         yield from bps.abs_set(thawer.control, ThawerStates.ON, wait=True)
         yield from bps.rel_set(smargon.omega, rotation, wait=True)
+        if plan_between_rotations:
+            yield from plan_between_rotations()
         yield from bps.rel_set(smargon.omega, -rotation, wait=True)
 
     def cleanup():

mx_bluesky/beamlines/i24/serial/__init__.py

@@ -22,6 +22,7 @@ from .fixed_target.i24ssx_Chip_Manager_py3v1 import (
     upload_parameters,
     write_parameter_file,
 )
+from .log import clean_up_log_config_at_end, setup_collection_logs
 from .setup_beamline.setup_detector import setup_detector_stage
 
 __all__ = [
@@ -46,4 +47,6 @@ __all__ = [
     "save_screen_map",
     "upload_parameters",
     "write_parameter_file",
+    "setup_collection_logs",
+    "clean_up_log_config_at_end",
 ]

mx_bluesky/beamlines/i24/serial/dcid.py

@@ -1,6 +1,5 @@
 import datetime
 import json
-import logging
 import math
 import os
 import re
@@ -10,6 +9,7 @@ from functools import lru_cache
 
 import requests
 
+from mx_bluesky.beamlines.i24.serial.log import SSX_LOGGER
 from mx_bluesky.beamlines.i24.serial.parameters import SSXType
 from mx_bluesky.beamlines.i24.serial.setup_beamline import (
     Detector,
@@ -25,8 +25,6 @@ try:
 except ImportError:
     pass
 
-logger = logging.getLogger("I24ssx.DCID")
-
 
 # Collection start/end script to kick off analysis
 COLLECTION_START_SCRIPT = "/dls_sw/i24/scripts/RunAtStartOfCollect-i24-ssx.sh"
@@ -41,7 +39,7 @@ CREDENTIALS_LOCATION = "/scratch/ssx_dcserver.key"
 def get_auth_header() -> dict:
     """Read the credentials file and build the Authorisation header"""
     if not os.path.isfile(CREDENTIALS_LOCATION):
-        logger.warning(
+        SSX_LOGGER.warning(
             "Could not read %s; attempting to proceed without credentials",
             CREDENTIALS_LOCATION,
         )
@@ -205,12 +203,12 @@ class DCID:
 
             # Log what we are doing here
             try:
-                logger.info(
+                SSX_LOGGER.info(
                     "BRIDGE: POST /dc --data %s",
                     repr(json.dumps(data)),
                 )
             except Exception:
-                logger.info(
+                SSX_LOGGER.info(
                     "Caught exception converting data to JSON. Data:\n%s\nVERBOSE:\n%s",
                     str({k: type(v) for k, v in data.items()}),
                 )
@@ -224,20 +222,20 @@ class DCID:
             )
             resp.raise_for_status()
             self.dcid = resp.json()["dataCollectionId"]
-            logger.info("Generated DCID %s", self.dcid)
+            SSX_LOGGER.info("Generated DCID %s", self.dcid)
         except requests.HTTPError as e:
             self.error = True
-            logger.error(
+            SSX_LOGGER.error(
                 "DCID generation Failed; Reason from server: %s", e.response.text
             )
             if self.emit_errors:
                 raise
-            logger.exception("Error generating DCID: %s", e)
+            SSX_LOGGER.exception("Error generating DCID: %s", e)
         except Exception as e:
             self.error = True
             if self.emit_errors:
                 raise
-            logger.exception("Error generating DCID: %s", e)
+            SSX_LOGGER.exception("Error generating DCID: %s", e)
 
     def __int__(self):
         return self.dcid
@@ -248,13 +246,13 @@ class DCID:
             return None
         try:
             command = [COLLECTION_START_SCRIPT, str(self.dcid)]
-            logger.info("Running %s", " ".join(command))
+            SSX_LOGGER.info("Running %s", " ".join(command))
             subprocess.Popen(command)
         except Exception as e:
             self.error = True
             if self.emit_errors:
                 raise
-            logger.warning("Error starting start of collect script: %s", e)
+            SSX_LOGGER.warning("Error starting start of collect script: %s", e)
 
     def notify_end(self):
         """Send notifications that the collection has now ended"""
@@ -262,13 +260,13 @@ class DCID:
             return
         try:
             command = [COLLECTION_END_SCRIPT, str(self.dcid)]
-            logger.info("Running %s", " ".join(command))
+            SSX_LOGGER.info("Running %s", " ".join(command))
             subprocess.Popen(command)
         except Exception as e:
             self.error = True
             if self.emit_errors:
                 raise
-            logger.warning("Error running end of collect notification: %s", e)
+            SSX_LOGGER.warning("Error running end of collect notification: %s", e)
 
     def collection_complete(
         self, end_time: str | datetime.datetime | None = None, aborted: bool = False
@@ -285,7 +283,7 @@ class DCID:
             # end_time might be a string from time.ctime
             if isinstance(end_time, str):
                 end_time = datetime.datetime.strptime(end_time, "%a %b %d %H:%M:%S %Y")
-                logger.debug("Parsed end time: %s", end_time)
+                SSX_LOGGER.debug("Parsed end time: %s", end_time)
 
             if not end_time:
                 end_time = datetime.datetime.now().astimezone()
@@ -302,13 +300,13 @@ class DCID:
             if self.dcid is None:
                 # Print what we would have sent. This means that if something is failing,
                 # we still have the data to upload in the log files.
-                logger.info(
+                SSX_LOGGER.info(
                     'BRIDGE: No DCID but Would PATCH "/dc/XXXX" --data=%s',
                     repr(json.dumps(data)),
                 )
                 return
 
-            logger.info(
+            SSX_LOGGER.info(
                 'BRIDGE: PATCH "/dc/%s" --data=%s', self.dcid, repr(json.dumps(data))
             )
             response = requests.patch(
@@ -318,7 +316,7 @@ class DCID:
                 headers=get_auth_header(),
             )
             response.raise_for_status()
-            logger.info("Successfully updated end time for DCID %d", self.dcid)
+            SSX_LOGGER.info("Successfully updated end time for DCID %d", self.dcid)
         except Exception as e:
             resp_obj = getattr(e, "response", None)
             try:
@@ -333,7 +331,7 @@ class DCID:
             self.error = True
             if self.emit_errors:
                 raise
-            logger.warning("Error completing DCID: %s (%s)", e, resp_str)
+            SSX_LOGGER.warning("Error completing DCID: %s (%s)", e, resp_str)
 
 
 def get_pilatus_filename_template_from_pvs() -> str:
@@ -385,9 +383,9 @@ def get_beamsize() -> tuple[float | None, float | None]:
     h_mode = caget("BL24I-OP-MFM-01:G1:TARGETAPPLY")
     # Validate these and note an error otherwise
     if not v_mode.startswith("VMFM") or v_mode[4:] not in focus_modes:
-        logger.error("Unrecognised vertical beam mode %s", v_mode)
+        SSX_LOGGER.error("Unrecognised vertical beam mode %s", v_mode)
     if not h_mode.startswith("HMFM") or h_mode[4:] not in focus_modes:
-        logger.error("Unrecognised horizontal beam mode %s", h_mode)
+        SSX_LOGGER.error("Unrecognised horizontal beam mode %s", h_mode)
     _, h, _ = focus_modes.get(h_mode[4:], (None, None, None))
     _, _, v = focus_modes.get(v_mode[4:], (None, None, None))