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

mxcubecore/Command/BlueskyHttpServer.py

@@ -0,0 +1,84 @@
+# encoding: utf-8
+#
+#  Project name: MXCuBE
+#  https://github.com/mxcube
+#
+#  This file is part of MXCuBE software.
+#
+#  MXCuBE is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  MXCuBE is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with MXCuBE. If not, see <http://www.gnu.org/licenses/>.
+
+import json
+import os
+import time
+
+import gevent
+import requests
+
+from mxcubecore.CommandContainer import CommandObject
+
+__copyright__ = """ Copyright © 2010 - 2020 by MXCuBE Collaboration """
+__license__ = "LGPLv3+"
+
+
+class BlueskyHttpServerCommand(CommandObject):
+    """Interface for communicating with the Bluesky Http Server API."""
+
+    _default_timeout = 5
+    _status_path = "api/status"
+    _execute_path = "api/queue/item/execute"
+
+    def __init__(self, name, url, timeout=5, **kwargs):
+        CommandObject.__init__(self, name, **kwargs)
+        self.username = ""
+        self._default_timeout = timeout
+        self._url = f"{url}/" if url[-1] != "/" else url
+        self._headers = {"Authorization": f"ApiKey {os.environ['AUTH_KEY']}"}
+
+    def format_response(self, response):
+        if response:
+            response.raise_for_status()
+            return json.loads(response.text)
+        return response
+
+    def status(self):
+        response = requests.get(
+            self._url + self._status_path,
+            headers=self._headers,
+            timeout=self._default_timeout,
+        )
+        return self.format_response(response)
+
+    def monitor_manager_state(self, stop_state, timeout=86400):
+        with gevent.Timeout(timeout, exception=TimeoutError):
+            while self.status()["manager_state"] != stop_state:
+                time.sleep(0.1)
+
+    def execute_plan(self, plan_name, kwargs=None):
+        if not kwargs:
+            kwargs = {}
+        return requests.post(
+            self._url + self._execute_path,
+            headers=self._headers,
+            json={
+                "user": self.username,
+                "item": {"name": plan_name, "item_type": "plan", "kwargs": kwargs},
+            },
+            timeout=self._default_timeout,
+        )
+
+    def is_connected(self):
+        http_server_status = self.status()
+        re_environment_open = http_server_status["worker_environment_exists"]
+        re_running = http_server_status["re_state"] is not None
+        return re_environment_open and re_running

mxcubecore/CommandContainer.py

@@ -760,6 +760,20 @@ class CommandContainer:
                     cmd_name,
                 )
 
+        elif cmd_type.lower() == "bluesky_http_server":
+            try:
+                from mxcubecore.Command.BlueskyHttpServer import (
+                    BlueskyHttpServerCommand,
+                )
+
+                new_command = BlueskyHttpServerCommand(cmd_name, cmd, **attributes_dict)
+            except Exception as exc:
+                logging.getLogger().exception(
+                    "%s: cannot establish a connection with the Bluesky Http Server %s",
+                    self.id,
+                    cmd_name,
+                )
+
         elif cmd_type.lower() == "sardana":
             doorname = None
             taurusname = None

mxcubecore/HardwareObjects/Gphl/GphlQueueEntry.py

@@ -49,7 +49,7 @@ class GphlWorkflowQueueEntry(BaseQueueEntry):
             )
             HWR.beamline.gphl_workflow.post_execute()
         HWR.beamline.gphl_workflow.pre_execute(self)
-        self.log.debug("Done GphlWorkflowQueueEntry.pre_execute")
+        logging.getLogger("HWR").debug("Done GphlWorkflowQueueEntry.pre_execute")
 
     def post_execute(self):
         BaseQueueEntry.post_execute(self)
@@ -60,5 +60,5 @@ class GphlWorkflowQueueEntry(BaseQueueEntry):
     def stop(self):
         HWR.beamline.gphl_workflow.workflow_aborted("Dummy", "Dummy")
         BaseQueueEntry.stop(self)
-        self.log.info("MXCuBE aborting current GΦL workflow")
+        logging.getLogger("user_level_log").info("MXCuBE aborting current GΦL workflow")
         self.get_view().setText(1, "Stopped")

mxcubecore/HardwareObjects/ICATLIMS.py

@@ -898,12 +898,22 @@ class ICATLIMS(AbstractLims):
             if session is not None:
                 investigation_name = session.proposal_name
 
-        return {
+        actual_instrument = None
+        try:
+            if (
+                self.active_session is None
+                or not self.active_session.is_scheduled_beamline
+            ):
+                actual_instrument = HWR.beamline.session.beamline_name
+        except RuntimeError as e:
+            logger.warning("Failed to set __actualInstrument. %s", e)
+
+        result = {
             "sampleId": sample_id,
             "Sample_name": sample_name,
             "startDate": start_time,
             "endDate": end_time,
-            "investigation_id": investigation_id,
+            "investigationId": investigation_id,
             "beamline_name": beamline_name,
             "proposal": investigation_name,
             "scheduled_beamline_name": scheduled_beamline_name,
@@ -920,6 +930,10 @@ class ICATLIMS(AbstractLims):
             "InstrumentSource_current": machine_info.get("current"),
             "InstrumentSource_mode": machine_info.get("fill_mode"),
         }
+        if actual_instrument is not None:
+            result["__actualInstrument"] = actual_instrument
+
+        return result
 
     def store_energy_scan(self, energyscan_dict: dict):
         try:

mxcubecore/HardwareObjects/LNLS/BlueskyHttpServer.py

@@ -0,0 +1,23 @@
+from mxcubecore.BaseHardwareObjects import HardwareObject
+
+
+class BlueskyHttpServer(HardwareObject):
+    def __init__(self, name):
+        HardwareObject.__init__(self, name)
+
+    def init(self):
+        super().init()
+        self.api = self.get_command_object("bluesky_http_server")
+        self.api.username = "mnc-data"
+
+    def execute_plan(self, plan_name, kwargs=None):
+        response = self.api.execute_plan(plan_name=plan_name, kwargs=kwargs)
+        response_content = response.json()
+        if response_content["success"]:
+            try:
+                self.api.monitor_manager_state("running")
+                self.api.monitor_manager_state("idle")
+            except TimeoutError:
+                self.log.exception("The Bluesky plan has timed out!")
+        else:
+            self.log.exception(response_content["msg"])

mxcubecore/HardwareObjects/LNLS/EPICS/EPICSMotor.py

@@ -97,3 +97,43 @@ class EPICSMotor(EPICSActuator, AbstractMotor):
     def done_movement(self):
         dmov = self.get_channel_value(self.MOTOR_DMOV)
         return bool(dmov)
+
+
+class EPICSMotorDetachable(EPICSMotor):
+    """
+    Class that implements an interface of motor record IOC and accepts
+    a presence PV, that indicated if the motor is or is not present on the
+    facility. If it is present, it actuates as an EpicsMotor, if it is not,
+    then the widget receives the state OFF and remains disabled.
+
+    YAML Example
+    ------------
+
+    %YAML 1.2
+    ---
+    class: LNLS.EPICS.EPICSMotor.EPICSMotorDetachable
+    epics:
+    "MOTOR_PV":
+        channels:
+        '':
+    'PRESENCE_PREFIX':
+        channels:
+        'presence':
+            suffix: "PRESENCE_SUFFIX"
+    configuration:
+    is_absent_value: 0
+
+    """
+
+    MOTOR_PRESENCE_RBV = "presence"
+
+    def init(self):
+        super().init()
+        self.get_value()
+
+    def get_value(self):
+        value = self.get_property("is_absent_value")
+        current_value = int(self.get_channel_value(self.MOTOR_PRESENCE_RBV))
+        if current_value == value:
+            self.update_state(self.STATES.OFF)
+        return super().get_value()

mxcubecore/HardwareObjects/LNLS/LNLSDiffractometer.py

@@ -1,24 +1,3 @@
-#
-#  Project name: MXCuBE
-#  https://github.com/mxcube
-#
-#  This file is part of MXCuBE software.
-#
-#  MXCuBE is free software: you can redistribute it and/or modify
-#  it under the terms of the GNU Lesser General Public License as published by
-#  the Free Software Foundation, either version 3 of the License, or
-#  (at your option) any later version.
-#
-#  MXCuBE is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU Lesser General Public License for more details.
-#
-#   You should have received a copy of the GNU Lesser General Public License
-#  along with MXCuBE. If not, see <http://www.gnu.org/licenses/>.
-
-import logging
-import random
 import time
 
 from gevent.event import AsyncResult
@@ -28,71 +7,33 @@ from mxcubecore.HardwareObjects.GenericDiffractometer import GenericDiffractomet
 
 
 class LNLSDiffractometer(GenericDiffractometer):
-    """
-    Descript. :
-    """
-
     def __init__(self, name):
-        """
-        Descript. :
-        """
         GenericDiffractometer.__init__(self, name)
 
-        # child object slots
-        self.backlight = None
-        self.backlightswitch = None
-        self.beamstop_distance = None
-        self.focus = None
-        self.frontlight = None
-        self.frontlightswitch = None
-        self.phi = None
-        self.phiy = None
-        self.phiz = None
-        self.sampx = None
-        self.sampy = None
-
     def init(self):
-        """
-        Descript. :
-        """
-        # self.image_width = 100
-        # self.image_height = 100
-
         GenericDiffractometer.init(self)
-        # Bzoom: 1.86 um/pixel (or 0.00186 mm/pixel) at minimum zoom
-        self.x_calib = self.get_property("x_calib", "")
-        self.y_calib = self.get_property("y_calib", "")
-        self.last_centred_position = self.get_property("last_centred_position", "")
-
-        self.pixels_per_mm_x = 1.0 / self.x_calib
-        self.pixels_per_mm_y = 1.0 / self.y_calib
-        self.beam_position = self.get_property("beam_position", "")
-
-        self.current_phase = GenericDiffractometer.PHASE_CENTRING
-
-        self.cancel_centring_methods = {}
+        self._bluesky_api = HWR.beamline.get_object_by_role("bluesky")
+        self.pixels_per_mm_x = 10**-4
+        self.pixels_per_mm_y = 10**-4
+        self.beam_position = [318, 238]
+        self.last_centred_position = self.beam_position
         self.current_motor_positions = {
-            "phiy": self.get_property("current_motor_positions_phiy", ""),
-            "sampx": self.get_property("current_motor_positions_sampx", ""),
-            "sampy": self.get_property("current_motor_positions_sampy", ""),
-            "zoom": self.get_property("current_motor_positions_zoom", ""),
-            "focus": self.get_property("current_motor_positions_focus", ""),
-            "phiz": self.get_property("current_motor_positions_phiz", ""),
-            "phi": self.get_property("current_motor_positions_phi", ""),
-            "kappa": self.get_property("current_motor_positions_kappa", ""),
-            "kappa_phi": self.get_property("current_motor_positions_kappa_phi", ""),
+            "phiy": 0,
+            "sampx": 0,
+            "sampy": 0,
+            "zoom": 0,
+            "focus": 0,
+            "phiz": 0,
+            "phi": 0,
+            "kappa": 0,
+            "kappa_phi": 0,
         }
 
-        self.current_state_dict = {}
-        self.centring_status = {"valid": False}
-        self.centring_time = self.get_property("centring_time", "")
-
+        self.centring_time = 0
         self.mount_mode = self.get_property("sample_mount_mode")
         if self.mount_mode is None:
             self.mount_mode = "manual"
 
-        self.equipment_ready()
-
         self.connect(self.motor_hwobj_dict["phi"], "valueChanged", self.phi_motor_moved)
         self.connect(
             self.motor_hwobj_dict["phiy"], "valueChanged", self.phiy_motor_moved
@@ -115,108 +56,10 @@ class LNLSDiffractometer(GenericDiffractometer):
             self.motor_hwobj_dict["sampy"], "valueChanged", self.sampy_motor_moved
         )
 
-    def manual_centring(self):
-        """
-        Descript. :
-        """
-        self.print_log(level="debug", msg="Iniciando centragem manual...")
-        for click in range(3):
-            self.print_log(
-                level="debug", msg=f"Aguardando clique do usuário ({click + 1}/3)..."
-            )
-            self.user_clicked_event = AsyncResult()
-            x, y = self.user_clicked_event.get()
-            self.print_log(
-                level="debug", msg=f"Usuário clicou nas coordenadas: x={x}, y={y}"
-            )
-
-            # go to beam
-            self.print_log(
-                level="debug", msg="Movendo para o feixe com as coordenadas clicadas."
-            )
-            res = self.move_to_beam(x, y)  # wait before continue
-            self.print_log(
-                level="debug", msg=f"Resultado do movimento para o feixe: {res}"
-            )
-
-            if click < 2:
-                self.print_log(
-                    level="debug",
-                    msg=f"Executando rotação relativa do motor phi em 90 graus (click={click})...",
-                )
-                self.motor_hwobj_dict["phi"].set_value_relative(90)
-
-        self.print_log(
-            level="debug", msg=f"Salvando última posição centrada: x={x}, y={y}"
-        )
-        self.last_centred_position[0] = x
-        self.last_centred_position[1] = y
-
-        self.print_log(level="debug", msg="Centragem manual finalizada.")
-        return {}
-
-    def automatic_centring(self):
-        """Automatic centring procedure"""
-        self.print_log(level="debug", msg="Iniciando centragem automática...")
-
-        centred_pos_dir = self._get_random_centring_position()
-        self.print_log(
-            level="debug",
-            msg=f"Posição centrada gerada automaticamente: {centred_pos_dir}",
-        )
-
-        self.emit("newAutomaticCentringPoint", centred_pos_dir)
-        self.print_log(level="debug", msg="Sinal 'newAutomaticCentringPoint' emitido.")
-
-        return centred_pos_dir
-
-    def _get_random_centring_position(self):
-        """Get random centring result for current positions"""
-
-        # Names of motors to vary during centring
-        vary_actuator_names = ("sampx", "sampy", "phiy")
-
-        # Range of random variation
-        var_range = 0.08
-
-        # absolute value limit for varied motors
-        var_limit = 2.0
-
-        result = self.current_motor_positions.copy()
-        for tag in vary_actuator_names:
-            val = result.get(tag)
-            if val is not None:
-                random_num = random.random()
-                var = (random_num - 0.5) * var_range
-                val += var
-                if abs(val) > var_limit:
-                    val *= 1 - var_range / var_limit
-                result[tag] = val
-        return result
-
     def is_ready(self) -> bool:
-        """
-        Descript. :
-        """
         return True
 
-    def get_centred_point_from_coord(self, x, y, return_by_names=None):
-        """
-        Descript. :
-        """
-        centred_pos_dir = self._get_random_centring_position()
-        return centred_pos_dir
-
-    def motor_positions_to_screen(self, centred_positions_dict):
-        """
-        Descript. :
-        """
-        return self.last_centred_position[0], self.last_centred_position[1]
-
     def phi_motor_moved(self, pos):
-        """
-        Descript. :
-        """
         self.current_motor_positions["phi"] = pos
         self.emit("phiMotorMoved", pos)
 
@@ -233,9 +76,6 @@ class LNLSDiffractometer(GenericDiffractometer):
         self.current_motor_positions["sampy"] = pos
 
     def kappa_motor_moved(self, pos):
-        """
-        Descript. :
-        """
         self.current_motor_positions["kappa"] = pos
         if time.time() - self.centring_time > 1.0:
             self.invalidate_centring()
@@ -243,136 +83,43 @@ class LNLSDiffractometer(GenericDiffractometer):
         self.emit("kappaMotorMoved", pos)
 
     def kappa_phi_motor_moved(self, pos):
-        """
-        Descript. :
-        """
         self.current_motor_positions["kappa_phi"] = pos
         if time.time() - self.centring_time > 1.0:
             self.invalidate_centring()
         self.emit_diffractometer_moved()
         self.emit("kappaPhiMotorMoved", pos)
 
-    def calculate_move_to_beam_pos(self, x, y):
-        """
-        Descript. : calculate motor positions to put sample on the beam.
-        Returns: dict of motor positions
-        """
-
-        # Atualiza posição atual do feixe
-        self.beam_position[0], self.beam_position[1] = (
-            HWR.beamline.beam.get_beam_position_on_screen()
-        )
-        self.print_log(
-            level="debug", msg=f"Posição atual do feixe na tela: {self.beam_position}"
-        )
-
-        # Armazena clique do usuário
-        self.last_centred_position[0] = x
-        self.last_centred_position[1] = y
-        self.print_log(
-            level="debug", msg=f"Última posição clicada pelo usuário: x={x}, y={y}"
-        )
-
-        # Obtém posições atuais dos motores
-        omega_pos = self.motor_hwobj_dict["phi"].get_value()
-        goniox_pos = self.motor_hwobj_dict["phiz"].get_value()
-        sampx_pos = self.motor_hwobj_dict["sampx"].get_value()
-        sampy_pos = self.motor_hwobj_dict["sampy"].get_value()
-        self.print_log(
-            level="debug",
-            msg=f"Posições atuais dos motores: omega={omega_pos}, phiz={goniox_pos}, sampx={sampx_pos}, sampy={sampy_pos}",
-        )
-
-        # Cálculo da movimentação de goniox
-        import math
-
-        drx_goniox = abs(-x - y + 1152) / math.sqrt(2)
-        dir_goniox = 1 if y <= (-x + 1152) else -1
-        move_goniox = dir_goniox * drx_goniox / self.pixels_per_mm_x + goniox_pos
-        self.print_log(
-            level="debug",
-            msg=f"Movimento calculado para phiz (goniox): {move_goniox:.4f}",
-        )
-
-        # Cálculo da movimentação em Y
-        dry_samp = abs(x - y - 128) / math.sqrt(2)
-        dir_samp = 1 if y >= x - 128 else -1
-        move_samp = dir_samp * dry_samp
-        self.print_log(
-            level="debug",
-            msg=f"Movimento intermediário para centragem vertical (samp): {move_samp:.4f}",
-        )
-
-        move_sampy = move_samp / self.pixels_per_mm_y
-        self.print_log(
-            level="debug", msg=f"Conversão para mm em Y: move_sampy = {move_sampy:.4f}"
-        )
-
-        move_sampy += sampy_pos
-        self.print_log(
-            level="debug", msg=f"Posição absoluta destino para sampy: {move_sampy:.4f}"
-        )
-
-        # Criação do dicionário de destino
-        centred_pos_dir = {"phiz": move_goniox, "sampy": move_sampy}
-        self.print_log(
-            level="debug",
-            msg=f"Posições alvo calculadas para centragem: {centred_pos_dir}",
-        )
+    def manual_centring(self):
+        self.log.info("Initializing manual sample alignment...")
+        for step in range(3):
+            self.log.info(f"Step {step + 1} of 3...")
+            self.user_clicked_event = AsyncResult()
+            self.waiting_for_click = True
+            x, y = self.user_clicked_event.get()
+            self.log.info(f"{x}, {y}")
+            self._bluesky_api.execute_plan(
+                plan_name="manual_alignment",
+                kwargs={"x_px": x, "y_px": y, "step": step},
+            )
+        self.log.info("Manual sample alignment has finished...")
+        return {}
 
-        return centred_pos_dir
+    def automatic_centring(self):
+        self.log.info("Initializing automatic sample alignment...")
+        self._bluesky_api.execute_plan(plan_name="automatic_alignment")
+        self.log.info("Automatic sample alignment has finished...")
 
     def move_to_beam(self, x, y, omega=None):
-        """
-        Descript. : function to create a centring point based on all motors
-                    positions.
-        """
-        logging.getLogger("HWR").info("Moving to beam...")
-        self.print_log(
-            level="debug",
-            msg=f"Initializing beam centering with beam at x={x}, y={y}...",
-        )
-
-        centred_pos_dir = self.calculate_move_to_beam_pos(x, y)
-
-        self.print_log(level="debug", msg="Moving to beam...")
-        self.move_to_motors_positions(centred_pos_dir, wait=True)
-
-        logging.getLogger("HWR").info("Move to beam has finished...")
-        return centred_pos_dir
+        self.log.info("Moving to beam...")
 
-    def start_move_to_beam(self, coord_x=None, coord_y=None, omega=None):
-        """
-        Descript. :
-        """
-        self.last_centred_position[0] = coord_x
-        self.last_centred_position[1] = coord_y
-        self.centring_time = time.time()
-        curr_time = time.strftime("%Y-%m-%d %H:%M:%S")
-        self.centring_status = {
-            "valid": True,
-            "startTime": curr_time,
-            "endTime": curr_time,
-        }
-        motors = self.get_positions()
-        self.last_centred_position[0] = coord_x
-        self.last_centred_position[1] = coord_y
-        self.centring_status["motors"] = motors
-        self.centring_status["valid"] = True
-        self.centring_status["angleLimit"] = False
-        self.emit_progress_message("")
-        self.accept_centring()
-        self.current_centring_method = None
-        self.current_centring_procedure = None
-
-    def re_emit_values(self):
-        self.emit("zoomMotorPredefinedPositionChanged", None, None)
-        omega_ref = [0, 238]
-        self.emit("omegaReferenceChanged", omega_ref)
-
-    def move_omega_relative(self, relative_angle):
-        self.motor_hwobj_dict["phi"].set_value_relative(relative_angle, 5)
+        self._bluesky_api.execute_plan(
+            plan_name="move_to_beam",
+            kwargs={
+                "x_px": x - self.beam_position[0],
+                "y_px": y - self.beam_position[1],
+            },
+        )
+        self.log.info("Move to beam has finished...")
 
-    def set_phase(self, phase, timeout=None):
-        self.current_phase = str(phase)
-        self.emit("minidiffPhaseChanged", (self.current_phase,))
+    def motor_positions_to_screen(self, motor_positions):
+        return self.beam_position

mxcubecore/HardwareObjects/MicrodiffInOut.py

@@ -1,5 +1,6 @@
 import logging
 import time
+import warnings
 
 from mxcubecore.BaseHardwareObjects import HardwareObject
 
@@ -53,11 +54,17 @@ class MicrodiffInOut(HardwareObject):
             import ast
 
             self.states = ast.literal_eval(states)
-        try:
-            tt = float(self.get_property("timeout"))
-            self.timeout = tt
-        except Exception:
-            self.log.exception("")
+        tt = self.get_property("timeout")
+        if tt is None:
+            warnings.warn(
+                "%s: %s is not configured" % (self.__class__.__name__, "timeout")
+            )
+        else:
+            try:
+                tt = float(tt)
+            except TypeError:
+                self.log.exception("")
+        self.timeout = tt
 
         if self.get_property("use_hwstate"):
             self.hwstate_attr = self.add_channel(