mxcubecore 1.402.0__tar.gz → 1.404.0__tar.gz

{mxcubecore-1.402.0 → mxcubecore-1.404.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mxcubecore
-Version: 1.402.0
+Version: 1.404.0
 Summary: Core libraries for the MXCuBE application
 License: LGPL-3.0-or-later
 Keywords: mxcube,mxcube3,mxcubecore

{mxcubecore-1.402.0 → mxcubecore-1.404.0}/mxcubecore/Command/Epics.py

@@ -72,7 +72,7 @@ class EpicsCommand(CommandObject):
             self.read_as_str,
         )
         self.pv = epics.PV(pv_name, auto_monitor=self.auto_monitor)
-        time.sleep(0.01)
+        time.sleep(0.1)
         self.pv_connected = self.pv.connect(timeout=0.1)
 
         if self.pv_connected:

{mxcubecore-1.402.0 → mxcubecore-1.404.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mxcubecore"
-version = "1.402.0"
+version = "1.404.0"
 license = "LGPL-3.0-or-later"
 description = "Core libraries for the MXCuBE application"
 authors = [

mxcubecore-1.402.0/mxcubecore/HardwareObjects/LNLS/EPICSActuator.py

@@ -1,78 +0,0 @@
-"""
-Superclass for EPICS actuators.
-
-Should be put as the first superclass,
-e.g. class EPICSMotor(EPICSActuator, AbstractMotor):
-
-Example of xml file:
-
-<object class="LNLS.EPICSActuator">
-    <channel type="epics" name="epicsActuator_val">MNC:B:LUCIOLE01:LIGHT_CH1</channel>
-    <channel type="epics" name="epicsActuator_rbv" polling="500">MNC:B:LUCIOLE01:LIGHT_CH1</channel>
-    <username>BackLight</username>
-    <motor_name>BackLight</motor_name>
-    <default_limits>(0, 8000)</default_limits>
-</object>
-"""
-
-import time
-
-import gevent
-
-from mxcubecore.HardwareObjects.abstract import AbstractActuator
-
-
-class EPICSActuator(AbstractActuator.AbstractActuator):
-    """EPCIS actuator class"""
-
-    ACTUATOR_VAL = "epicsActuator_val"  # target
-    ACTUATOR_RBV = "epicsActuator_rbv"  # readback
-
-    def __init__(self, name):
-        super(EPICSActuator, self).__init__(name)
-        self.__wait_actuator_task = None
-        self._nominal_limits = (-1e4, 1e4)
-
-    def init(self):
-        """Initialization method"""
-        super(EPICSActuator, self).init()
-        self.update_state(self.STATES.READY)
-
-    def _wait_actuator(self):
-        """Wait actuator to be ready."""
-        time.sleep(0.3)
-        self.update_state(self.STATES.READY)
-
-    def get_value(self):
-        """Override AbstractActuator method."""
-        return self.get_channel_value(self.ACTUATOR_RBV)
-
-    def set_value(self, value, timeout=0):
-        """Override AbstractActuator method."""
-        if self.read_only:
-            raise ValueError("Attempt to set value for read-only Actuator")
-        if self.validate_value(value):
-            self.update_state(self.STATES.BUSY)
-            if timeout or timeout is None:
-                with gevent.Timeout(
-                    timeout, RuntimeError("Motor %s timed out" % self.username)
-                ):
-                    self._set_value(value)
-                    new_value = self._wait_actuator(value)
-            else:
-                self._set_value(value)
-                self.__wait_actuator_task = gevent.spawn(self._wait_actuator)
-        else:
-            raise ValueError(
-                "Invalid value %s; limits are %s" % (value, self.get_limits())
-            )
-
-    def abort(self):
-        """Immediately halt movement. By default self.stop = self.abort"""
-        if self.__wait_actuator_task is not None:
-            self.__wait_actuator_task.kill()
-        self.update_state(self.STATES.READY)
-
-    def _set_value(self, value):
-        """Override AbstractActuator method."""
-        self.set_channel_value(self.ACTUATOR_VAL, value)

mxcubecore-1.402.0/mxcubecore/HardwareObjects/LNLS/EPICSMotor.py

@@ -1,104 +0,0 @@
-"""
-EPICS implementation of AbstractMotor.
-
-Example of xml file:
-
-<object class="LNLS.EPICSMotor">
-    <channel type="epics" name="epicsActuator_val">SOL:S:m1.VAL</channel>
-    <channel type="epics" name="epicsActuator_rbv" polling="500">SOL:S:m1.RBV</channel>
-    <channel type="epics" name="epicsMotor_rlv">SOL:S:m1.RLV</channel>
-    <channel type="epics" name="epicsMotor_dmov" polling="500">SOL:S:m1.DMOV</channel>
-    <channel type="epics" name="epicsMotor_stop">SOL:S:m1.STOP</channel>
-    <channel type="epics" name="epicsMotor_velo">SOL:S:m1.VELO</channel>
-    <channel type="epics" name="epicsMotor_llm">SOL:S:m1.DLLM</channel>
-    <channel type="epics" name="epicsMotor_hlm">SOL:S:m1.DHLM</channel>
-    <channel type="epics" name="epicsMotor_egu">SOL:S:m1.EGU</channel>
-    <username>Omega</username>
-    <motor_name>Omega</motor_name>
-    <unit>1e-3</unit>
-    <GUIstep>90</GUIstep>
-</object>
-"""
-
-import time
-
-import gevent
-
-from mxcubecore.HardwareObjects.abstract.AbstractMotor import AbstractMotor
-from mxcubecore.HardwareObjects.LNLS.EPICSActuator import EPICSActuator
-
-
-class EPICSMotor(EPICSActuator, AbstractMotor):
-    """EPICS Motor class"""
-
-    MOTOR_DMOV = "epicsMotor_dmov"
-    MOTOR_STOP = "epicsMotor_stop"
-    MOTOR_RLV = "epicsMotor_rlv"
-    MOTOR_VELO = "epicsMotor_velo"
-    MOTOR_HLM = "epicsMotor_hlm"
-    MOTOR_LLM = "epicsMotor_llm"
-    MOTOR_EGU = "epicsMotor_egu"
-
-    def __init__(self, name):
-        super().__init__(name)
-        self._wrap_range = None
-
-    def init(self):
-        """Initialization method"""
-        super().init()
-        self.get_limits()
-        self.get_velocity()
-        self.__watch_task = gevent.spawn(self._watch)
-        self.update_state(self.STATES.READY)
-
-    def _watch(self):
-        """Watch motor current value and update it on the UI."""
-        while True:
-            time.sleep(0.25)
-            self.update_value()
-
-    def _wait_actuator(self):
-        """Override EPICSActuator method."""
-        self.update_specific_state(self.SPECIFIC_STATES.MOVING)
-        current_value = self.get_value()
-
-        while not self.done_movement():
-            time.sleep(0.25)
-
-        self.update_specific_state(None)
-        self.update_state(self.STATES.READY)
-
-    def abort(self):
-        """Override EPICSActuator method."""
-        self.set_channel_value(self.MOTOR_STOP, 1)
-        super().abort()
-
-    def get_limits(self):
-        """Override AbstractActuator method."""
-        try:
-            low_limit = float(self.get_channel_value(self.MOTOR_LLM))
-            high_limit = float(self.get_channel_value(self.MOTOR_HLM))
-            self._nominal_limits = (low_limit, high_limit)
-        except BaseException:
-            self._nominal_limits = (None, None)
-
-        if self._nominal_limits in [(0, 0), (float("-inf"), float("inf"))]:
-            # Treat infinite limits
-            self._nominal_limits = (None, None)
-
-        self.log.info("Motor %s limits: %s" % (self.motor_name, self._nominal_limits))
-        return self._nominal_limits
-
-    def get_velocity(self):
-        """Override AbstractMotor method."""
-        self._velocity = self.get_channel_value(self.MOTOR_VELO)
-        return self._velocity
-
-    def set_velocity(self, value):
-        """Override AbstractMotor method."""
-        self.__velocity = self.set_channel_value(self.MOTOR_VELO, value)
-
-    def done_movement(self):
-        """Return whether motor finished movement or not."""
-        dmov = self.get_channel_value(self.MOTOR_DMOV)
-        return bool(dmov)

mxcubecore-1.402.0/mxcubecore/HardwareObjects/LNLS/EPICSNState.py

@@ -1,87 +0,0 @@
-"""
-EPICS implementation of AbstractNState.
-Example xml file:
-<object class="LNLS.LNLSInOut">
-  <channel type="epics" name="epicsActuator_val">SOL:S:m4.SET</channel>
-  <channel type="epics" name="epicsActuator_rbv" polling="500">SOL:S:m4.SET</channel>
-  <username>Microdiff backlight</username>
-  <motor_name>BackLightIsOn</motor_name>
-  <values>{"in": True, "out": False}</values>
-</object>
-"""
-
-import logging
-from enum import Enum
-
-from mxcubecore.HardwareObjects.abstract.AbstractNState import AbstractNState
-from mxcubecore.HardwareObjects.LNLS.EPICSActuator import EPICSActuator
-
-
-class EPICSNState(AbstractNState, EPICSActuator):
-    def __init__(self, name):
-        AbstractNState.__init__(self, name)
-        self.username = "unknown"
-        self.actuatorState = "unknown"
-        self.state_attr = None
-
-    def init(self):
-        AbstractNState.initialise_values(self)
-        self.username = self.getProperty("username")
-        self.states = dict((item.value, item.name) for item in self.VALUES)
-        self.moves = dict((item.name, item.value) for item in self.VALUES)
-        self.get_actuator_state()
-
-    def connectNotify(self, signal):
-        if signal == "actuatorStateChanged":
-            self.valueChanged(self.state_attr)
-
-    def _set_value(self, value):
-        """Set device to value
-        Args:
-            value (str, int, float or enum): Value to be set.
-        """
-        if isinstance(value, Enum):
-            try:
-                value = value.value[0]
-            except TypeError:
-                value = value.value
-        EPICSActuator._set_value(self, value)
-        # self.set_channel_value(self.ACTUATOR_VAL, value)
-        self.update_state()
-
-    def get_value(self):
-        """Get the device value
-        Returns:
-            (Enum): Enum member, corresponding to the value or UNKNOWN.
-        """
-        value = EPICSActuator.get_value(self)
-        # value = self.get_channel_value(self.ACTUATOR_RBV)
-        return self.value_to_enum(value)
-
-    def get_actuator_state(self, read=False):
-        current_value = self.get_value()
-        self.state_attr = current_value.value  # Bool
-        self.actuatorState = self.states.get(self.state_attr, "unknown")  # Name
-        return self.actuatorState
-
-    def valueChanged(self, value):
-        enum_val = self.value_to_enum(value)
-        self.set_value(enum_val)
-        self.actuatorState = self.states.get(value, "unknown")
-        self.emit("actuatorStateChanged", (self.actuatorState,))
-
-    def actuatorIn(self, wait=True, timeout=None):
-        try:
-            self.state_attr = self.moves["in"]
-            self.valueChanged(self.state_attr)
-        except BaseException:
-            logging.getLogger("user_level_log").error("Cannot put %s in", self.username)
-
-    def actuatorOut(self, wait=True, timeout=None):
-        try:
-            self.state_attr = self.moves["out"]
-            self.valueChanged(self.state_attr)
-        except BaseException as e:
-            logging.getLogger("user_level_log").error(
-                "Cannot put %s out: %s", (self.username, e)
-            )

mxcubecore-1.402.0/mxcubecore/HardwareObjects/LNLS/LNLSAperture.py

@@ -1,69 +0,0 @@
-#
-#  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/>.
-
-
-from mxcubecore.HardwareObjects.abstract.AbstractAperture import AbstractAperture
-
-__credits__ = ["MXCuBE collaboration"]
-__license__ = "LGPLv3"
-
-DEFAULT_POSITION_LIST = ("BEAM", "OFF", "PARK")
-DEFAULT_DIAMETER_SIZE_LIST = (5, 10, 20, 30, 50, 100)
-
-
-class LNLSAperture(AbstractAperture):
-    def __init__(self, name):
-        AbstractAperture.__init__(self, name)
-
-    def init(self):
-        try:
-            self._diameter_size_list = eval(self.getProperty("diameter_size_list"))
-        except BaseException:
-            self._diameter_size_list = DEFAULT_DIAMETER_SIZE_LIST
-            self.log.error(
-                "Aperture: no diameter size list defined, using default list"
-            )
-
-        try:
-            self._position_list = eval(self.getProperty("position_list"))
-        except BaseException:
-            self._position_list = DEFAULT_POSITION_LIST
-            self.log.error("Aperture: no position list defined, using default list")
-
-        self.set_position_index(0)
-        self.set_diameter_index(1)  # 100um as default
-
-    def set_in(self):
-        """
-        Sets aperture in the beam
-        """
-        self.set_position("BEAM")
-
-    def set_out(self):
-        """
-        Removes aperture from the beam
-        """
-        self.set_position("OFF")
-
-    def is_out(self):
-        """
-        Returns:
-            bool: True if aperture is in the beam, otherwise returns false
-        """
-        return self._current_position_name != "BEAM"

mxcubecore-1.402.0/mxcubecore/HardwareObjects/LNLS/LNLSBeam.py

@@ -1,125 +0,0 @@
-# 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/>.
-
-"""
-LNLSBeam class
-"""
-
-__copyright__ = """ Copyright © 2016 - 2020 by MXCuBE Collaboration """
-__license__ = "LGPLv3+"
-
-import ast
-
-from mxcubecore.HardwareObjects.abstract.AbstractBeam import (
-    AbstractBeam,
-)
-
-
-class LNLSBeam(AbstractBeam):
-    def __init__(self, name):
-        AbstractBeam.__init__(self, name)
-
-        self._beam_size_dict["slits"] = [9999, 9999]
-        self._beam_size_dict["aperture"] = [9999, 9999]
-        self._beam_position_on_screen = [1024 / 2, 1024 / 2]
-        self._beam_divergence = (0, 0)
-
-    def init(self):
-        self._aperture = self.get_object_by_role("aperture")
-        if self._aperture is not None:
-            self.connect(
-                self._aperture,
-                "diameterIndexChanged",
-                self.aperture_diameter_changed,
-            )
-
-            ad = self._aperture.get_diameter_size() / 1000.0
-            self._beam_size_dict["aperture"] = [ad, ad]
-
-        self._slits = self.get_object_by_role("slits")
-        if self._slits is not None:
-            self.connect(self._slits, "valueChanged", self.slits_gap_changed)
-
-            sx, sy = self._slits.get_gaps()
-            self._beam_size_dict["slits"] = [sx, sy]
-
-        beam_pos = self.getProperty("default_beam_pos_on_screen")
-        self._beam_position_on_screen = list(ast.literal_eval(beam_pos))
-
-        self.evaluate_beam_info()
-        self.emit_beam_info_change()
-        self.emit("beamPosChanged", (self._beam_position_on_screen,))
-
-    def aperture_diameter_changed(self, name, size):
-        """
-        Method called when the aperture diameter changes
-        Args:
-            name (str): diameter name - not used.
-            size (float): diameter size in microns
-        """
-        self._beam_size_dict["aperture"] = [size, size]
-        self.evaluate_beam_info()
-        self.emit_beam_info_change()
-
-    def slits_gap_changed(self, size):
-        """
-        Method called when the slits gap changes
-        Args:
-            size (tuple): two floats indicates beam size in microns
-        """
-        self._beam_size_dict["slits"] = size
-        self.evaluate_beam_info()
-        self.emit_beam_info_change()
-
-    def set_beam_position_on_screen(self, beam_x, beam_y):
-        """
-        Sets beam mark position on screen
-        #TODO move method to sample_view
-        Args:
-            beam_x (int): horizontal position in pixels
-            beam_y (int): vertical position in pixels
-        """
-        self._beam_position_on_screen = (beam_x, beam_y)
-        self.emit("beamPosChanged", (self._beam_position_on_screen,))
-
-    def get_slits_gap(self):
-        """
-        Returns: tuple with beam size in microns
-        """
-        self.evaluate_beam_info()
-        return self._beam_size_dict["slits"]
-
-    def set_slits_gap(self, width_microns, height_microns):
-        """
-        Sets slits gap in microns
-        Args:
-            width_microns (int):
-            height_microns (int):
-        """
-        if self._slits:
-            self._slits.set_horizontal_gap(width_microns / 1000.0)
-            self._slits.set_vertical_gap(height_microns / 1000.0)
-
-    def get_aperture_pos_name(self):
-        """
-        Returns (str): name of current aperture position
-        """
-        if self._aperture:
-            return self._aperture.get_current_pos_name()