karabo.bound 2.21.3__py3-none-any.whl

karabo/__init__.py

@@ -0,0 +1 @@
+__version__ = '2.21.3'

karabo/_version.py

@@ -0,0 +1 @@
+version = '2.21.3'

karabo/bound/__init__.py

@@ -0,0 +1,109 @@
+# This file is part of Karabo.
+#
+# http://www.karabo.eu
+#
+# Copyright (C) European XFEL GmbH Schenefeld. All rights reserved.
+#
+# Karabo is free software: you can redistribute it and/or modify it under
+# the terms of the MPL-2 Mozilla Public License.
+#
+# You should have received a copy of the MPL-2 Public License along with
+# Karabo. If not, see <https://www.mozilla.org/en-US/MPL/2.0/>.
+#
+# Karabo 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.
+# flake8: noqa: F401
+from karabind import (
+    ADMIN, ALARM_ELEMENT, AMPERE, AMPERE_PER_SECOND, ATTO, ATTOSEC, BAR, BAYER,
+    BECQUEREL, BGR, BGRA, BIT, BMP, BOOL_ELEMENT, BYTE, BYTEARRAY_ELEMENT,
+    CANDELA, CENTI, CHOICE_ELEMENT, CHOICE_OF_NODES, CMYK, COMMAND, COULOMB,
+    COUNT, DAY, DECA, DECI, DEGREE, DEGREE_CELSIUS, DOUBLE_ELEMENT,
+    ELECTRONVOLT, EVERY_1MIN, EVERY_1S, EVERY_5S, EVERY_10MIN, EVERY_10S,
+    EVERY_100MS, EVERY_EVENT, EXA, EXPERT, FARAD, FEMTO, FEMTOSEC,
+    FLOAT_ELEMENT, GIGA, GRAM, GRAY, HECTO, HENRY, HERTZ, HOUR,
+    IMAGEDATA_ELEMENT, INIT, INPUT_CHANNEL, INPUT_ELEMENT, INT32_ELEMENT,
+    INT64_ELEMENT, INTERNAL, JOULE, JPEG, KATAL, KELVIN, KILO, LEAF,
+    LIST_ELEMENT, LIST_OF_NODES, LUMEN, LUX, MANDATORY, MEGA, METER,
+    METER_PER_SECOND, MICRO, MICROSEC, MILLI, MILLISEC, MINUTE, MOLE, NANO,
+    NANOSEC, NDARRAY_ELEMENT, NEWTON, NO_ARCHIVING, NODE, NODE_ELEMENT, NONE,
+    NOT_ASSIGNED, NUMBER, OBSERVER, OHM, ONESECOND, OPERATOR, OPTIONAL,
+    OUTPUT_CHANNEL, OUTPUT_ELEMENT, OVERWRITE_ELEMENT, PASCAL, PATH_ELEMENT,
+    PERCENT, PETA, PICO, PICOSEC, PIXEL, PNG, PROPERTY, RADIAN, READ, RGB,
+    RGBA, SECOND, SIEMENS, SIEVERT, SLOT_ELEMENT, STATE_ELEMENT, STERADIAN,
+    STRING_ELEMENT, TABLE_ELEMENT, TERA, TESLA, TIFF, TIME_UNITS,
+    UINT32_ELEMENT, UINT64_ELEMENT, UNDEFINED, USER, VECTOR_BOOL_ELEMENT,
+    VECTOR_CHAR_ELEMENT, VECTOR_DOUBLE_ELEMENT, VECTOR_FLOAT_ELEMENT,
+    VECTOR_INT32_ELEMENT, VECTOR_INT64_ELEMENT, VECTOR_STRING,
+    VECTOR_STRING_ELEMENT, VECTOR_UINT32_ELEMENT, VECTOR_UINT64_ELEMENT, VOLT,
+    VOLT_PER_SECOND, WATT, WEBER, WRITE, YEAR, YOCTO, YOTTA, YUV, ZEPTO, ZETTA,
+    AccessLevel, AccessType, ArchivePolicy, AssemblyRules, AssignmentType,
+    BinarySerializerHash, BinarySerializerSchema, Broker, Category, Channel,
+    ChannelMetaData, ClassInfo, Connection, ConnectionStatus, DaqDataType,
+    DAQPolicy, DateTimeString, DeviceClient as BoundDeviceClient,
+    DimensionType, Dims, Encoding, Epochstamp, ErrorCode, EventLoop, Hash,
+    HashAttributes, HashAttributesNode, HashFilter, HashMergePolicy, HashNode,
+    ImageData, InputChannel, InputHash, InputSchema, LeafType, Logger,
+    MetricPrefix, NodeType, OutputChannel, OutputHash, OutputSchema,
+    PriorityLevel, Requestor, RollingWindowStatistics, Rotation, Schema,
+    SignalSlotable, SignalSlotableIntern, Slot, SlotElementBase,
+    TextSerializerHash, TextSerializerSchema, TimeDuration, Timestamp,
+    Trainstamp, Types, TypesClass, Unit, Validator, ValidatorValidationRules,
+    VectorHash, VectorHashPointer, _DimsIntern, cppNDArray, cppNDArrayCopy,
+    fullyEqual, generateAutoStartHash, jsonToHash, loadFromFile,
+    loadHashFromFile, loadSchemaFromFile, saveHashToFile, saveSchemaToFile,
+    saveToFile, setDims, similar, startDeviceServer, stopDeviceServer)
+
+from ..common.alarm_conditions import AlarmCondition
+from ..common.states import State, StateSignifier
+from .base_fsm import BaseFsm
+from .camera_fsm import CameraFsm
+from .configurator import Configurator
+from .decorators import KARABO_CLASSINFO, KARABO_CONFIGURATION_BASE_CLASS
+from .device import PythonDevice, launchPythonDevice
+from .device_client import DeviceClient
+from .device_server import DeviceServer, Launcher
+from .fsm import (
+    KARABO_FSM_ACTION, KARABO_FSM_ACTION0, KARABO_FSM_ACTION1,
+    KARABO_FSM_ACTION2, KARABO_FSM_ACTION3, KARABO_FSM_ACTION4,
+    KARABO_FSM_CREATE_MACHINE, KARABO_FSM_EVENT0, KARABO_FSM_EVENT1,
+    KARABO_FSM_EVENT2, KARABO_FSM_EVENT3, KARABO_FSM_EVENT4, KARABO_FSM_GUARD,
+    KARABO_FSM_GUARD0, KARABO_FSM_GUARD1, KARABO_FSM_GUARD2, KARABO_FSM_GUARD3,
+    KARABO_FSM_GUARD4, KARABO_FSM_INTERRUPT_STATE,
+    KARABO_FSM_INTERRUPT_STATE_A, KARABO_FSM_INTERRUPT_STATE_AE,
+    KARABO_FSM_INTERRUPT_STATE_AEE, KARABO_FSM_INTERRUPT_STATE_E,
+    KARABO_FSM_INTERRUPT_STATE_EE, KARABO_FSM_NO_TRANSITION_ACTION,
+    KARABO_FSM_PERIODIC_ACTION, KARABO_FSM_STATE, KARABO_FSM_STATE_A,
+    KARABO_FSM_STATE_AE, KARABO_FSM_STATE_AEE, KARABO_FSM_STATE_E,
+    KARABO_FSM_STATE_EE, KARABO_FSM_STATE_MACHINE, KARABO_FSM_STATE_MACHINE_E,
+    KARABO_FSM_STATE_MACHINE_EE)
+from .no_fsm import NoFsm
+from .ok_error_fsm import OkErrorFsm
+from .plugin_loader import PluginLoader
+from .runner import Runner
+from .server_entry_point import runSingleDeviceServer
+from .start_stop_fsm import StartStopFsm
+from .start_stop_fsm_periodic import StartStopFsmPeriodic
+from .worker import QueueWorker, Worker
+
+# For comptibility with old karathon bindings, take care that e.g.
+# str(Types.INT32) is 'INT32' and not 'Types.INT32'
+
+def __typesToString(self):
+    repStr = repr(self)  # i.e. '<Types.{this we want}: {enum value}>'
+    return repStr[7:repStr.find(':')]
+
+
+setattr(Types, "__str__", __typesToString)
+
+
+class AbstractInput:
+    pass
+
+
+def isStdVectorDefaultConversion():
+    return True
+
+
+def setStdVectorDefaultConversion():
+    pass

karabo/bound/base_fsm.py

@@ -0,0 +1,104 @@
+# This file is part of Karabo.
+#
+# http://www.karabo.eu
+#
+# Copyright (C) European XFEL GmbH Schenefeld. All rights reserved.
+#
+# Karabo is free software: you can redistribute it and/or modify it under
+# the terms of the MPL-2 Mozilla Public License.
+#
+# You should have received a copy of the MPL-2 Public License along with
+# Karabo. If not, see <https://www.mozilla.org/en-US/MPL/2.0/>.
+#
+# Karabo 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.
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+__author__ = "Sergey Esenov <serguei.essenov at xfel.eu>"
+__date__ = "$May 10, 2013 2:17:13 PM$"
+
+import threading
+
+from karabo.common.states import State
+
+from .decorators import KARABO_CLASSINFO, KARABO_CONFIGURATION_BASE_CLASS
+from .fsm import KARABO_FSM_NO_TRANSITION_ACTION
+from .no_fsm import NoFsm
+
+
+@KARABO_CONFIGURATION_BASE_CLASS
+@KARABO_CLASSINFO("BaseFsm", "1.0")
+class BaseFsm(NoFsm):
+    """The BaseFSM class is the basis of all finite state machines.
+
+    It provides methods for starting and retrieving the derived specific
+    state machines, and for processing events occurring in the state machine.
+    """
+
+    @staticmethod
+    def expectedParameters(expected):
+        """Expected parameters of the FSM.
+
+        Derived state machines will usually implement slots in their
+        expected parameters.
+
+        :param expected: schema to insert parameters into
+        """
+
+        pass
+
+    def __init__(self, configuration):
+        """Initialize the state machine according to the configuration Hash.
+
+        :param configuration:
+        """
+        super().__init__(configuration)
+        self.fsm = None
+        self.processEventLock = threading.RLock()
+        KARABO_FSM_NO_TRANSITION_ACTION(self.noStateTransition)
+
+    def getFsm(self):
+        """
+        Return the concrete FSM implementation that inherits from BaseFsm
+        """
+        return self.fsm
+
+    def startFsm(self):
+        """Start state machine"""
+        fsm = self.getFsm()
+        if fsm is not None:
+            try:
+                fsm.start()
+            except Exception as e:
+                raise RuntimeError(f"startFsm -- Exception: {str(e)}")
+
+            state = fsm.get_state()
+            self.updateState(state)
+
+    def processEvent(self, event):
+        """Process input event, i.e. drive state machine to the next state."""
+        with self.processEventLock:
+            fsm = self.getFsm()
+            if fsm is not None:
+                self.updateState(State.CHANGING)
+                try:
+                    fsm.process_event(event)
+                except Exception as e:
+                    name = event.__class__.__name__
+                    self.exceptionFound(
+                        f"Exception while processing event '{name}': {e}")
+                finally:
+                    state = fsm.get_state()
+                    self.updateState(state)
+
+    def exceptionFound(self, userFriendlyMessage, detailedMessage):
+        """Hook for when an exception is encountered.
+
+        Catch exceptions where they can occur instead, e.g.
+        when calling a slot or requesting a value!
+
+        :param shortMessage: exception message
+        :param detailedMessage: detailed exception message
+        """

karabo/bound/camera_fsm.py

@@ -0,0 +1,231 @@
+# This file is part of Karabo.
+#
+# http://www.karabo.eu
+#
+# Copyright (C) European XFEL GmbH Schenefeld. All rights reserved.
+#
+# Karabo is free software: you can redistribute it and/or modify it under
+# the terms of the MPL-2 Mozilla Public License.
+#
+# You should have received a copy of the MPL-2 Public License along with
+# Karabo. If not, see <https://www.mozilla.org/en-US/MPL/2.0/>.
+#
+# Karabo 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.
+__author__ = "andrea.parenti@xfel.eu"
+__date__ = "August  7, 2013"
+
+import karabo.bound.base_fsm as base
+from karabind import SLOT_ELEMENT, VECTOR_STRING_ELEMENT
+from karabo.common.states import State
+
+from .decorators import KARABO_CLASSINFO
+from .fsm import (
+    KARABO_FSM_ACTION0, KARABO_FSM_ACTION2, KARABO_FSM_CREATE_MACHINE,
+    KARABO_FSM_EVENT0, KARABO_FSM_EVENT2, KARABO_FSM_GUARD0,
+    KARABO_FSM_STATE_EE, KARABO_FSM_STATE_MACHINE)
+
+
+@KARABO_CLASSINFO("CameraFsm", "1.0")
+class CameraFsm(base.BaseFsm):
+    """The CameraFSM is a state machine suited for camera devices.
+
+    This finite state machine implements actions for acquiring, triggering
+    stopping and resetting camera type devices.
+
+    Here acquire sends the camera into the acquisition state, i.e. it is ready
+    to receive and react on trigger signals. The trigger command will send
+    such a trigger. Stop will stop acquisition, i.e. the camera will not
+    respond to triggers anymore. Finally, reset is used to bring the camera
+    back into an active state after hardware errors have occured.
+    """
+
+    @staticmethod
+    def expectedParameters(expected):
+        (
+            SLOT_ELEMENT(expected).key("connectCamera")
+            .displayedName("Connect")
+            .description("Connects to the hardware")
+            .allowedStates(State.UNKNOWN)
+            .commit(),
+
+            SLOT_ELEMENT(expected).key("acquire")
+            .displayedName("Acquire")
+            .description("Instructs camera to go into acquisition state")
+            .allowedStates(State.ON)
+            .commit(),
+
+            SLOT_ELEMENT(expected).key("trigger")
+            .displayedName("Trigger")
+            .description("Sends a software trigger to the camera")
+            .allowedStates(State.ACQUIRING)
+            .commit(),
+
+            SLOT_ELEMENT(expected).key("stop")
+            .displayedName("Stop")
+            .description("Instructs camera to stop current acquisition")
+            .allowedStates(State.ACQUIRING)
+            .commit(),
+
+            SLOT_ELEMENT(expected).key("reset")
+            .displayedName("Reset")
+            .description("Resets the camera in case of an error")
+            .allowedStates(State.ERROR)
+            .commit(),
+
+            VECTOR_STRING_ELEMENT(expected).key("interfaces")
+            .displayedName("Interfaces")
+            .description("Describes the interfaces of this device")
+            .readOnly()
+            .initialValue(["Camera"])
+            .commit(),
+        )
+
+    def __init__(self, configuration):
+        super().__init__(configuration)
+
+        # **************************************************************
+        # *                        Events                              *
+        # **************************************************************
+        KARABO_FSM_EVENT2(self, 'ErrorFoundEvent', 'errorFound')
+        KARABO_FSM_EVENT0(self, 'ConnectEvent', 'connectCamera')
+        KARABO_FSM_EVENT0(self, 'DisconnectEvent', 'disconnectCamera')
+        KARABO_FSM_EVENT0(self, 'ResetEvent', 'reset')
+        KARABO_FSM_EVENT0(self, 'AcquireEvent', 'acquire')
+        KARABO_FSM_EVENT0(self, 'StopEvent', 'stop')
+        KARABO_FSM_EVENT0(self, 'TriggerEvent', 'trigger')
+
+        # **************************************************************
+        # *                        States                              *
+        # **************************************************************
+        KARABO_FSM_STATE_EE(State.ERROR, self.errorStateOnEntry,
+                            self.errorStateOnExit)
+        KARABO_FSM_STATE_EE(State.INIT, self.initializationStateOnEntry,
+                            self.initializationStateOnExit)
+        KARABO_FSM_STATE_EE(State.UNKNOWN, self.unknownStateOnEntry,
+                            self.unknownStateOnExit)
+        KARABO_FSM_STATE_EE(State.ACQUIRING, self.acquisitionStateOnEntry,
+                            self.acquisitionStateOnExit)
+        KARABO_FSM_STATE_EE(State.ON, self.readyStateOnEntry,
+                            self.readyStateOnExit)
+
+        # **************************************************************
+        # *                    Transition Actions                      *
+        # **************************************************************
+        # KARABO_FSM_NO_TRANSITION_ACTION(self.noStateTransition)
+        KARABO_FSM_ACTION2('ErrorFoundAction', self.errorFoundAction, str, str)
+        KARABO_FSM_ACTION0('ConnectAction', self.connectAction)
+        KARABO_FSM_ACTION0('DisconnectAction', self.disconnectAction)
+        KARABO_FSM_ACTION0('ResetAction', self.resetAction)
+        KARABO_FSM_ACTION0('AcquireAction', self.acquireAction)
+        KARABO_FSM_ACTION0('StopAction', self.stopAction)
+        KARABO_FSM_ACTION0('TriggerAction', self.triggerAction)
+
+        KARABO_FSM_GUARD0('ConnectGuard', self.connectGuard)
+
+        # **************************************************************
+        # *                       Ok State Machine                     *
+        # **************************************************************
+        okStt = [
+            # Source-State    Event        Target-State     Action        Guard
+            (
+                State.ON, 'AcquireEvent', State.ACQUIRING, 'AcquireAction',
+                'none'),
+            (State.ACQUIRING, 'StopEvent', State.ON, 'StopAction', 'none'),
+            (State.ACQUIRING, 'TriggerEvent', None, 'TriggerAction', 'none')
+        ]
+        #                        Name  Transition-Table  Initial-State
+        KARABO_FSM_STATE_MACHINE(State.NORMAL, okStt, State.ON)
+
+        # **************************************************************
+        # *                      Known Machine                         *
+        # **************************************************************
+        knownStt = [
+            # Source-State   Event         Target-State   Action          Guard
+            (State.NORMAL, 'ErrorFoundEvent', State.ERROR, 'ErrorFoundAction',
+             'none'),
+            (State.ERROR, 'ResetEvent', State.NORMAL, 'ResetAction', 'none')
+        ]
+        #                         Name      Transition-Table  Initial-State
+        KARABO_FSM_STATE_MACHINE(State.KNOWN, knownStt, State.NORMAL)
+
+        # **************************************************************
+        # *                       Top Machine                          *
+        # **************************************************************
+        cameraStt = [
+            # Source-State   Event        Target-State   Action           Guard
+            (State.INIT, 'none', State.UNKNOWN, 'none', 'none'),
+            (State.UNKNOWN, 'ConnectEvent', State.KNOWN, 'ConnectAction',
+             'ConnectGuard'),
+            (State.KNOWN, 'DisconnectEvent', State.UNKNOWN, 'DisconnectAction',
+             'none')
+        ]
+        #                     Name      Transition-Table  Initial-State
+        KARABO_FSM_STATE_MACHINE('CameraMachine', cameraStt, State.INIT)
+        self.fsm = KARABO_FSM_CREATE_MACHINE('CameraMachine')
+
+    def getFsm(self):
+        return self.fsm
+
+    def initFsmSlots(self, sigslot):
+        sigslot.registerSlot(self.connectCamera)
+        sigslot.registerSlot(self.acquire)
+        sigslot.registerSlot(self.trigger)
+        sigslot.registerSlot(self.stop)
+        sigslot.registerSlot(self.reset)
+        sigslot.registerSlot(self.errorFound)
+
+    def initializationStateOnEntry(self):
+        """Actions executed on entry to 'Initialization' state"""
+
+    def initializationStateOnExit(self):
+        """Actions executed on exit from 'Initialization' state"""
+
+    def unknownStateOnEntry(self):
+        """Actions executed on entry to 'Initialization' state"""
+
+    def unknownStateOnExit(self):
+        """Actions executed on exit from 'Initialization' state"""
+
+    def errorStateOnEntry(self):
+        """Actions executed on entry to 'Error' state"""
+
+    def errorStateOnExit(self):
+        """Actions executed on exit from 'Error' state"""
+
+    def acquisitionStateOnEntry(self):
+        """Actions executed on entry to 'Acquisition' state"""
+
+    def acquisitionStateOnExit(self):
+        """Actions executed on exit from 'Acquisition' state"""
+
+    def readyStateOnEntry(self):
+        """Actions executed on entry to 'Ready' state"""
+
+    def readyStateOnExit(self):
+        """Actions executed on exit from 'Ready' state"""
+
+    def errorFoundAction(self, shortMessage, detailedMessage):
+        """Action executed when an error is found """
+
+    def connectAction(self):
+        """Actions executed at 'connect' event"""
+
+    def disconnectAction(self):
+        """Actions executed at 'disconnect' event"""
+
+    def acquireAction(self):
+        """Actions executed at 'acquire' event"""
+
+    def stopAction(self):
+        """Actions executed at 'stop' event"""
+
+    def triggerAction(self):
+        """Actions executed at 'trigger' event"""
+
+    def resetAction(self):
+        """Action to execute upon reset event"""
+
+    def connectGuard(self):
+        """Guard for UNKNOWN -> KNOWN transition"""