mxcubecore 1.440.0__py3-none-any.whl → 1.449.0__py3-none-any.whl

mxcubecore/HardwareObjects/QtGraphicsManager.py

@@ -39,8 +39,8 @@ example xml:
 import logging
 import math
 import os
+import warnings
 from copy import deepcopy
-from datetime import datetime
 
 import gevent
 import matplotlib.pyplot as plt
@@ -324,12 +324,16 @@ class QtGraphicsManager(AbstractSampleView):
         # self.set_scrollbars_off(\
         #     self.get_property("scrollbars_always_off") is True)
 
-        try:
-            self.graphics_magnification_item.set_properties(
-                eval(self.get_property("magnification_tool"))
-            )
-        except Exception:
-            self.log.exception("")
+        magnification_tool = self.get_property("magnification_tool")
+        if not magnification_tool:
+            warnings.warn("GraphicsManager: Magnification tool not defined")
+        else:
+            if isinstance(magnification_tool, str):
+                try:
+                    magnification_tool = eval(magnification_tool)
+                except TypeError:
+                    self.log.exception("")
+            self.graphics_magnification_item.set_properties(magnification_tool)
 
         # try:
         #    self.set_view_scale(self.get_property("view_scale"))
@@ -778,20 +782,23 @@ class QtGraphicsManager(AbstractSampleView):
         gevent.spawn_later(2, self.save_crystal_image)
 
     def save_crystal_image(self):
-        try:
-            raw_snapshot = self.get_raw_snapshot()
-            result_image = raw_snapshot.copy(
-                self.beam_position[0]
-                - self.beam_info_dict["size_x"] * self.pixels_per_mm[0] / 2,
-                self.beam_position[1]
-                - self.beam_info_dict["size_y"] * self.pixels_per_mm[1] / 2,
-                self.beam_info_dict["size_x"] * self.pixels_per_mm[0] * 1.5,
-                self.beam_info_dict["size_y"] * self.pixels_per_mm[1] * 1.5,
-            )
-            date_time_str = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
-            result_image.save("/opt/embl-hh/var/crystal_images/%s.png" % date_time_str)
-        except Exception:
-            self.log.exception("")
+        pass
+        # This code ios EMBL-specific and broken.
+        # Left as comment to mark ned for refactoring
+        # try:
+        #     raw_snapshot = self.get_raw_snapshot()
+        #     result_image = raw_snapshot.copy(
+        #         self.beam_position[0]
+        #         - self.beam_info_dict["size_x"] * self.pixels_per_mm[0] / 2,
+        #         self.beam_position[1]
+        #         - self.beam_info_dict["size_y"] * self.pixels_per_mm[1] / 2,
+        #         self.beam_info_dict["size_x"] * self.pixels_per_mm[0] * 1.5,
+        #         self.beam_info_dict["size_y"] * self.pixels_per_mm[1] * 1.5,
+        #     )
+        #     date_time_str = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
+        #     result_image.save("/opt/embl-hh/var/crystal_images/%s.png" % date_time_str)
+        # except Exception:
+        #     self.log.exception("")
 
     def diffractometer_centring_failed(self, method, centring_status):
         """CleanUp method after centring failed

mxcubecore/HardwareObjects/abstract/AbstractMultiCollect.py

@@ -1,8 +1,6 @@
 import abc
 import collections
 import errno
-
-# import types
 import logging
 import os
 import socket
@@ -13,11 +11,7 @@ import autoprocessing
 import gevent
 
 from mxcubecore import HardwareRepository as HWR
-from mxcubecore.TaskUtils import (
-    cleanup,
-    error_cleanup,
-    task,
-)
+from mxcubecore.TaskUtils import cleanup, error_cleanup, task
 
 BeamlineControl = collections.namedtuple(
     "BeamlineControl",
@@ -105,6 +99,9 @@ class AbstractMultiCollect(object):
     def data_collection_end_hook(self, data_collect_parameters):
         pass
 
+    def _bliss_data_collection_hook(self, data_collect_parameters):
+        pass
+
     @abc.abstractmethod
     @task
     def close_fast_shutter(self):
@@ -115,21 +112,21 @@ class AbstractMultiCollect(object):
     def move_motors(self, motor_position_dict):
         return
 
-    @abc.abstractmethod
-    @task
     def open_safety_shutter(self):
         pass
 
+    def open_detector_cover(self):
+        """Placeholder for implementing opening of the detector cover"""
+
+    def close_detector_cover(self):
+        """Placeholder for implementing closing of the detector cover"""
+
     def safety_shutter_opened(self):
         return False
 
-    @abc.abstractmethod
-    @task
     def close_safety_shutter(self):
         pass
 
-    @abc.abstractmethod
-    @task
     def prepare_intensity_monitors(self):
         pass
 
@@ -243,39 +240,42 @@ class AbstractMultiCollect(object):
         Use fast characterisation
 
         Args:
-            value (boolean): True if to use fast characterisation otherwise False
+            value: True if to use fast characterisation otherwise False
         """
-        pass
 
     @abc.abstractmethod
     @task
     def generate_image_jpeg(self, filename, jpeg_path, jpeg_thumbnail_path):
         pass
 
-    def get_sample_info_from_parameters(self, parameters):
-        """Returns sample_id, sample_location and sample_code from data collection parameters"""
+    def get_sample_info_from_parameters(self, parameters: dict):
+        """Returns sample_id, sample_location and sample_code from data
+           collection parameters.
+        Args:
+            parameters: Dictionary with the data collection parameters
+        """
         sample_info = parameters.get("sample_reference")
         try:
-            sample_id = int(sample_info["blSampleId"])
-        except Exception:
+            sample_id = int(sample_info.get("blSampleId"))
+        except (AttributeError, TypeError):
             sample_id = None
 
         try:
             sample_code = sample_info["code"]
-        except Exception:
+        except KeyError:
             sample_code = None
 
         sample_location = None
 
         try:
             sample_container_number = int(sample_info["container_reference"])
-        except Exception:
-            logging.getLogger("HWR").exception("")
+        except KeyError:
+            pass
         else:
             try:
                 vial_number = int(sample_info["sample_location"])
-            except Exception:
-                logging.getLogger("HWR").exception("")
+            except KeyError:
+                pass
             else:
                 sample_location = (sample_container_number, vial_number)
 
@@ -370,8 +370,6 @@ class AbstractMultiCollect(object):
         wedges_to_collect = []
 
         for wedge_size in wedge_sizes_list:
-            orig_start = start
-
             wedges_to_collect.append((start, wedge_size))
             start += wedge_size * osc_range - overlap
 
@@ -395,12 +393,11 @@ class AbstractMultiCollect(object):
         self, files_directory, prefix, run_number, process_directory
     ):
         """Return XDS input file directory"""
-        pass
 
     @abc.abstractmethod
     @task
     def write_input_files(self, collection_id):
-        pass
+        """Write the input files place holder."""
 
     def execute_collect_without_loop(self, data_collect_parameters):
         return
@@ -558,7 +555,7 @@ class AbstractMultiCollect(object):
 
         current_diffractometer_position = self.diffractometer().get_positions()
 
-        for motor in motors_to_move_before_collect.keys():
+        for motor in motors_to_move_before_collect:
             if motors_to_move_before_collect[motor] is not None:
                 try:
                     if current_diffractometer_position[motor] is not None:
@@ -624,7 +621,6 @@ class AbstractMultiCollect(object):
                 snapshot_i = 1
                 snapshots = []
                 for img in centring_info["images"]:
-                    img_phi_pos = img[0]
                     img_data = img[1]
                     snapshot_filename = "%s_%s_%s.snapshot.jpeg" % (
                         file_parameters["prefix"],
@@ -680,11 +676,6 @@ class AbstractMultiCollect(object):
         sample_id = data_collect_parameters["blSampleId"]
         subwedge_size = oscillation_parameters.get("reference_interval", 1)
 
-        # if data_collect_parameters["shutterless"]:
-        #    subwedge_size = 1
-        # else:
-        #    subwedge_size = oscillation_parameters["number_of_images"]
-
         wedges_to_collect = self.prepare_wedges_to_collect(
             oscillation_parameters["start"],
             oscillation_parameters["number_of_images"],
@@ -703,10 +694,9 @@ class AbstractMultiCollect(object):
         )
 
         start_image_number = oscillation_parameters["start_image_number"]
-        last_frame = start_image_number + nframes - 1
 
         if data_collect_parameters["skip_images"]:
-            for start, wedge_size in wedges_to_collect[:]:
+            for _start, wedge_size in wedges_to_collect[:]:
                 filename = image_file_template % start_image_number
                 file_location = file_parameters["directory"]
                 file_path = os.path.join(file_location, filename)
@@ -775,9 +765,9 @@ class AbstractMultiCollect(object):
                 "Setting resolution to %f", resolution
             )
             try:
-                HWR.beamline.diffractometer.open_detector_cover()
+                self.open_detector_cover()
                 HWR.beamline.resolution.set_value(resolution, timeout=3500)
-            except RuntimeError:
+            except (AttributeError, RuntimeError):
                 logging.getLogger("user_level_log").info(
                     "Failed to set resolution to %f", resolution
                 )
@@ -797,9 +787,6 @@ class AbstractMultiCollect(object):
                 )
                 raise
 
-        # 0: software binned, 1: unbinned, 2:hw binned
-        # self.set_detector_mode(data_collect_parameters["detector_mode"])
-
         with cleanup(self.data_collection_cleanup):
             # if not self.safety_shutter_opened():
             self.open_safety_shutter()
@@ -881,7 +868,7 @@ class AbstractMultiCollect(object):
                 self.write_input_files(self.collection_id, wait=False)
 
             # at this point input files should have been written
-            # TODO agree what parameters will be sent to this function
+            # TO DO: agree what parameters will be sent to this function
             if data_collect_parameters.get("processing", False) == "True":
                 self.trigger_auto_processing(
                     "before",
@@ -1028,11 +1015,10 @@ class AbstractMultiCollect(object):
                         )
 
                         if data_collect_parameters.get("shutterless"):
+                            msg = "Timeout waiting for detector trigger, no image taken"
                             with gevent.Timeout(
                                 self.first_image_timeout,
-                                RuntimeError(
-                                    "Timeout waiting for detector trigger, no image taken"
-                                ),
+                                RuntimeError(msg),
                             ):
                                 if last_image_saved <= 0:
                                     last_image_saved = self.last_image_saved(
@@ -1065,14 +1051,10 @@ class AbstractMultiCollect(object):
                         _total_time_spent += time.time() - _time_start
                         _total_exptime += exptime
 
-                        # if _total_time_spent > (wedge_size * (exptime + 0.005)) * 4:
-                        #    msg = "Data collection failure, detector not responding"
-                        #    logging.getLogger("user_level_log").info(msg)
-                        #    HWR.beamline.detector.recover_from_failure()
-                        #    raise RuntimeError(msg)
-
-            # Bug fix for MD2/3(UP): diffractometer still has things to do even after the last frame is taken (decelerate motors and
-            # possibly download diagnostics) so we cannot trigger the cleanup (that will send an abort on the diffractometer) as soon as
+            # Bug fix for MD2/3(UP): diffractometer still has things to do
+            # even after the last frame is taken (decelerate motors and
+            # possibly download diagnostics) so we cannot trigger the cleanup
+            # (that will send an abort on the diffractometer) as soon as
             # the last frame is counted
             self.diffractometer().wait_ready(1000)
 
@@ -1114,13 +1096,12 @@ class AbstractMultiCollect(object):
 
                     # now really start collect sequence
                     self.do_collect(owner, data_collect_parameters)
-                except Exception as ex:
+                except Exception:
                     failed = True
                     exc_type, exc_value, exc_tb = sys.exc_info()
+                    msg = f"Data collection failed: {exc_value}"
                     logging.exception("Data collection failed")
-                    logging.getLogger("user_level_log").info(
-                        "Data collection failed %s" % exc_value
-                    )
+                    logging.getLogger("user_level_log").info(msg)
                     data_collect_parameters["status"] = (
                         "Data collection failed!"  # Message to be stored in LIMS
                     )
@@ -1178,18 +1159,17 @@ class AbstractMultiCollect(object):
                 if failed:
                     # if one dc fails, stop the whole loop
                     break
-                else:
-                    self.emit(
-                        "collectOscillationFinished",
-                        (
-                            owner,
-                            True,
-                            data_collect_parameters["status"],
-                            self.collection_id,
-                            osc_id,
-                            data_collect_parameters,
-                        ),
-                    )
+                self.emit(
+                    "collectOscillationFinished",
+                    (
+                        owner,
+                        True,
+                        data_collect_parameters["status"],
+                        self.collection_id,
+                        osc_id,
+                        data_collect_parameters,
+                    ),
+                )
 
             if self.get_property("close_safety_shutter_if_idle", False):
                 try:
@@ -1208,10 +1188,7 @@ class AbstractMultiCollect(object):
             self.emit("collectReady", (True,))
 
     def collect_without_loop(self, data_collect_parameters_list):
-        in_multicollect = len(data_collect_parameters_list) > 1
-        collections_analyse_params = []
         self.emit("collectReady", (False,))
-        # self.emit("collectStarted", (self.owner, 1))
         total_frames = 0
         total_time_sec = 0
         # in principle data_collect_parameters_list always has one element
@@ -1303,13 +1280,12 @@ class AbstractMultiCollect(object):
         if isinstance(residues, str):
             try:
                 residues = int(residues)
-            except Exception:
+            except ValueError:
                 residues = 200
 
         # residues = zero should be interpreted as if no value was provided
         # use default of 200
-        if residues == 0:
-            residues = 200
+        residues = residues or 200
 
         processAnalyseParams = {}
         processAnalyseParams["EDNA_files_dir"] = EDNA_files_dir
@@ -1324,15 +1300,13 @@ class AbstractMultiCollect(object):
             processAnalyseParams["residues"] = residues
             processAnalyseParams["spacegroup"] = spacegroup
             processAnalyseParams["cell"] = cell
-        except Exception as msg:
-            logging.getLogger().exception("DataCollect:processing: %r" % str(msg))
+        except Exception as err:
+            msg = f"DataCollect:processing: {err}"
+            logging.getLogger().exception(msg)
         else:
-            # logging.info("AUTO PROCESSING: %s, %s, %s, %s, %s, %s, %r, %r", process_event, EDNA_files_dir, anomalous, residues, do_inducedraddam, spacegroup, cell)
-
+            programs = self.get_property("auto_processing")
             try:
-                autoprocessing.start(
-                    self["auto_processing"], process_event, processAnalyseParams
-                )
+                autoprocessing.start(programs, process_event, processAnalyseParams)
             except Exception:
                 logging.getLogger().exception("Error starting processing")
 

mxcubecore/HardwareObjects/abstract/AbstractNState.py

@@ -94,7 +94,9 @@ class AbstractNState(AbstractActuator):
             values_dict.update(values)
             self.VALUES = Enum("ValueEnum", values_dict)
         except (ValueError, TypeError):
-            self.log.exception("")
+            self.log.exception(
+                "Error initialising values for %s", self.__class__.__name__
+            )
 
     def value_to_enum(self, value, idx=0):
         """Transform a value to Enum

mxcubecore/HardwareObjects/abstract/AbstractVideoDevice.py

@@ -117,10 +117,15 @@ class AbstractVideoDevice(HardwareObject):
 
         self.poll_interval = self.get_property("interval", self.default_poll_interval)
 
-        try:
-            self.cam_gain = float(self.get_property("gain"))
-        except TypeError:
-            self.log.exception("")
+        cam_gain = self.get_property("gain")
+        if cam_gain is None:
+            warnings.warn("VideoDevice gain is not configured")
+        else:
+            try:
+                cam_gain = float(cam_gain)
+            except TypeError:
+                self.log.exception("")
+        self.cam_gain = cam_gain
 
         try:
             self.cam_exposure = float(self.get_property("exposure"))

mxcubecore/HardwareObjects/abstract/ISPyBAbstractLims.py

@@ -53,10 +53,14 @@ class ISPyBAbstractLIMS(AbstractLims):
         else:
             self.proxy = {}
 
-        try:
-            self.base_result_url = self.get_property("base_result_url").strip()
-        except AttributeError:
-            self.log.exception("")
+        base_result_url = self.get_property("base_result_url")
+        if base_result_url and isinstance(base_result_url, str):
+            self.base_result_url = base_result_url.strip()
+        else:
+            warnings.warn(
+                "%s.%s missing or misconfigured: %s"
+                % (self.__class__.__name__, "base_result_url", base_result_url)
+            )
 
         self.adapter = self._create_data_adapter()
         self.log.debug("[ISPYB] Proxy address: %s" % self.proxy)

mxcubecore/HardwareObjects/autoprocessing.py

@@ -43,9 +43,9 @@ def grouped_processing(processEvent, params):
 def start(programs, processEvent, paramsDict):
     for program in programs["program"]:
         try:
-            allowed_events = program.get_property("event").split(" ")
+            allowed_events = program.get("event").split(" ")
             if processEvent in allowed_events:
-                executable = program.get_property("executable")
+                executable = program.get("executable")
 
                 if os.path.isfile(executable):
                     if processEvent == "end_multicollect":

mxcubecore/HardwareObjects/mockup/CollectMockup.py

@@ -55,7 +55,7 @@ class CollectMockup(AbstractCollect):
         """Main collection hook"""
         self.emit("collectStarted", (None, 1))
         self.emit("fsmConditionChanged", "data_collection_started", True)
-        self._store_image_in_lims_by_frame_num(1)
+        self.store_image_in_lims_by_frame_num(1)
         number_of_images = self.current_dc_parameters["oscillation_sequence"][0][
             "number_of_images"
         ]
@@ -84,20 +84,20 @@ class CollectMockup(AbstractCollect):
     def emit_collection_finished(self):
         """Collection finished behaviour"""
         if self.current_dc_parameters["experiment_type"] != "Collect - Multiwedge":
-            self._update_data_collection_in_lims()
+            self.update_data_collection_in_lims()
 
             last_frame = self.current_dc_parameters["oscillation_sequence"][0][
                 "number_of_images"
             ]
             if last_frame > 1:
-                self._store_image_in_lims_by_frame_num(last_frame)
+                self.store_image_in_lims_by_frame_num(last_frame)
             if (
                 self.current_dc_parameters["experiment_type"] in ("OSC", "Helical")
                 and self.current_dc_parameters["oscillation_sequence"][0]["overlap"]
                 == 0
                 and last_frame > 19
             ):
-                self.trigger_auto_processing("after", self.current_dc_parameters, 0)
+                self.trigger_auto_processing("after", 0)
 
         success_msg = "Data collection successful"
         # self.current_dc_parameters["status"] = success_msg
@@ -120,13 +120,16 @@ class CollectMockup(AbstractCollect):
         self._collecting = False
         self.ready_event.set()
 
-    def _store_image_in_lims_by_frame_num(self, frame, motor_position_id=None):
+    def store_image_in_lims_by_frame_num(self, frame, motor_position_id=None):
         """
         Descript. :
         """
-        self.trigger_auto_processing("image", self.current_dc_parameters, frame)
-        image_id = self._store_image_in_lims(frame)
-        return image_id
+        return
+        # This entire function is a mess and it is not clear what should be called
+        # when or how. Disabled till somebody knows how to fix it
+        # self.trigger_auto_processing("image", frame)
+        # image_id = self._store_image_in_lims(frame)
+        # return image_id
 
     def trigger_auto_processing(self, process_event, frame_number):
         """

mxcubecore/HardwareObjects/mockup/ISPyBRestClientMockup.py

@@ -3,6 +3,7 @@ A client for ISPyB Webservices.
 """
 
 import logging
+import warnings
 from datetime import datetime
 from urllib.parse import urljoin
 
@@ -11,8 +12,7 @@ from mxcubecore.BaseHardwareObjects import HardwareObject
 
 _CONNECTION_ERROR_MSG = (
     "Could not connect to ISPyB, please verify that "
-    + "the server is running and that your "
-    + "configuration is correct"
+    "the server is running and that your configuration is correct"
 )
 _NO_TOKEN_MSG = "Could not connect to ISPyB, no valid REST token available."  # noqa: S105
 
@@ -79,10 +79,14 @@ class ISPyBRestClientMockup(HardwareObject):
         self.__rest_password = self.get_property("restPass").strip()
         self.__site = self.get_property("site").strip()
 
-        try:
-            self.base_result_url = self.get_property("base_result_url").strip()
-        except AttributeError:
-            self.log.exception("")
+        base_result_url = self.get_property("base_result_url")
+        if base_result_url and isinstance(base_result_url, str):
+            self.base_result_url = base_result_url.strip()
+        else:
+            warnings.warn(
+                "%s.%s missing or misconfigured: %s"
+                % (self.__class__.__name__, "base_result_url", base_result_url)
+            )
 
         self.__update_rest_token()
 

mxcubecore/HardwareRepository.py

@@ -401,7 +401,7 @@ def init_hardware_repository(
 
     beamline_config_file = _instance.find_beamline_config_file()
     if beamline_config_file.endswith(".yml"):
-        warn(  # noqa: B028 we don't care about stacklevel for this warning
+        warn(
             f"Config file '{beamline_config_file}' have deprecated extension 'yml', "
             "change to 'yaml'."
         )

mxcubecore/protocols_config.py

@@ -132,12 +132,19 @@ def _setup_sardana_commands(hwobj: HardwareObject, sardana_config: dict):
         setup_door(door_name, door_config)
 
 
+def _setup_bluesky_http_server_command(hwobj: HardwareObject, server: str):
+    hwobj.add_command(
+        {"type": "bluesky_http_server", "name": "bluesky_http_server"}, server
+    )
+
+
 def _protocol_handles():
     return {
         "tango": _setup_tango_commands_channels,
         "exporter": _setup_exporter_commands_channels,
         "epics": _setup_epics_channels,
         "sardana": _setup_sardana_commands,
+        "bluesky_http_server": _setup_bluesky_http_server_command,
     }
 
 

mxcubecore/queue_entry/base_queue_entry.py

@@ -800,11 +800,12 @@ class SampleQueueEntry(BaseQueueEntry):
                         }
                     )
 
-        try:
-            programs = HWR.beamline.collect["auto_processing"]
-            autoprocessing.start(programs, "end_multicollect", params)
-        except KeyError:
-            logging.getLogger("HWR").exception("")
+        programs = HWR.beamline.collect.get_property("auto_processing")
+        if programs:
+            try:
+                autoprocessing.start(programs, "end_multicollect", params)
+            except KeyError:
+                logging.getLogger("HWR").exception("")
 
         self._set_background_color()
         self._view.setText(1, "")

mxcubecore/utils/qt_import.py

@@ -242,11 +242,6 @@ if (qt_variant == "PyQt5") or (qt_variant is None and not qt_imported):
     except ImportError:
         logging.getLogger("HWR").exception("")
 
-    try:
-        from PyQt5.QtWebKit import QWebPage
-    except ImportError:
-        logging.getLogger("HWR").exception("")
-
 #
 # PyQt4
 #
@@ -383,11 +378,6 @@ if (qt_variant == "PyQt4") or (qt_variant is None and not qt_imported):
     except BaseException:
         logging.getLogger("HWR").exception("")
 
-    try:
-        from PyQt4.QtWebKit import QWebPage
-    except ImportError:
-        logging.getLogger("HWR").exception("")
-
 #
 # PySide
 #

{mxcubecore-1.440.0.dist-info → mxcubecore-1.449.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mxcubecore
-Version: 1.440.0
+Version: 1.449.0
 Summary: Core libraries for the MXCuBE application
 License-Expression: LGPL-3.0-or-later
 License-File: COPYING