karabo.native 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/common/__init__.py

@@ -0,0 +1,15 @@
+# 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.

karabo/common/alarm_conditions.py

@@ -0,0 +1,120 @@
+# 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.
+from enum import Enum
+from functools import total_ordering
+
+
+@total_ordering
+class AlarmCondition(Enum):
+    """A class for unified alarm conditions.
+
+    Alarms are categorized by severity, which can either be none, warn, alarm
+    or interlock. Interlock is the most severe condition.
+    """
+
+    NONE = "none"
+    WARN = "warn"
+    WARN_LOW = "warnLow"
+    WARN_HIGH = "warnHigh"
+    WARN_VARIANCE_LOW = "warnVarianceLow"
+    WARN_VARIANCE_HIGH = "warnVarianceHigh"
+    ALARM = "alarm"
+    ALARM_LOW = "alarmLow"
+    ALARM_HIGH = "alarmHigh"
+    ALARM_VARIANCE_LOW = "alarmVarianceLow"
+    ALARM_VARIANCE_HIGH = "alarmVarianceHigh"
+    INTERLOCK = "interlock"
+
+    @staticmethod
+    def criticalityList():
+        """Return the severity list
+
+        severity increases from left to right
+        :return: an list with alarm severities
+        """
+        return [
+            AlarmCondition.NONE,
+            AlarmCondition.WARN,
+            AlarmCondition.ALARM,
+            AlarmCondition.INTERLOCK,
+        ]
+
+    def criticalityLevel(self):
+        """Return the severity level of this alarm condition"""
+        for p in AlarmCondition.criticalityList():
+            if p.value in self.value:
+                return p
+        return self
+
+    @staticmethod
+    def returnMostSignificant(conditionList):
+        """Returns the most severe/significant condition
+
+        Returns the most severe/significant condition in the given list of
+        conditions
+        :param conditionList: a list containing alarm conditions
+        :return: The most severe condition in the list
+        """
+        if len(conditionList) == 0:
+            return AlarmCondition.NONE
+        else:
+            s = conditionList[0]
+            for c in conditionList:
+                s = s.returnMoreSignificant(c)
+            return s.criticalityLevel()
+
+    def returnMoreSignificant(self, other):
+        """Return the more significant of this and the other condition
+
+        :param other: The condition to compare against
+        """
+        if self.criticalityList().index(
+            self.criticalityLevel()
+        ) > self.criticalityList().index(other.criticalityLevel()):
+            return self
+        else:
+            return other
+
+    @staticmethod
+    def fromString(name):
+        """Return an alarm condition from its stringified representation."""
+        return AlarmCondition(name)
+
+    def asString(self):
+        """Return the string representation of the alarm condition"""
+        return self.value
+
+    def asBaseString(self):
+        """Return the severity level, e.g. base of the alarmcondtions"""
+        return self.parent().value
+
+    def isSameCriticality(self, other):
+        """Return whether *other* is of same criticality/severity
+
+        Return whether this alarm condition is of same criticality/severity
+        as *other*
+        :param other: the alarm condition to compare against
+        """
+        return self.criticalityList().index(
+            self.criticalityLevel()
+        ) == self.criticalityList().index(other.criticalityLevel())
+
+    def __lt__(self, other):
+        return self.level < other.level
+
+
+for i, condition in enumerate(AlarmCondition.__members__.values()):
+    condition.level = i

karabo/common/api.py

@@ -0,0 +1,73 @@
+# 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
+from .alarm_conditions import AlarmCondition
+from .const import (
+    KARABO_ALARM_HIGH, KARABO_ALARM_LOW, KARABO_ALARM_VARIANCE_HIGH,
+    KARABO_ALARM_VARIANCE_LOW, KARABO_CLASS_ID_ALARM, KARABO_CLASS_ID_STATE,
+    KARABO_EDITABLE_ATTRIBUTES, KARABO_LOGGER_CONTENT_DEFAULT,
+    KARABO_RUNTIME_ATTRIBUTES_MDL, KARABO_RUNTIME_SCHEMA_UPDATE,
+    KARABO_SCHEMA_ABSOLUTE_ERROR, KARABO_SCHEMA_ACCESS_MODE,
+    KARABO_SCHEMA_ALARM_ACK, KARABO_SCHEMA_ALARM_INFO, KARABO_SCHEMA_ALIAS,
+    KARABO_SCHEMA_ALLOWED_STATES, KARABO_SCHEMA_ARCHIVE_POLICY,
+    KARABO_SCHEMA_ASSIGNMENT, KARABO_SCHEMA_ATTRIBUTES, KARABO_SCHEMA_CLASS_ID,
+    KARABO_SCHEMA_DAQ_DATA_TYPE, KARABO_SCHEMA_DAQ_POLICY,
+    KARABO_SCHEMA_DEFAULT_SCENE, KARABO_SCHEMA_DEFAULT_VALUE,
+    KARABO_SCHEMA_DESCRIPTION, KARABO_SCHEMA_DISPLAY_TYPE,
+    KARABO_SCHEMA_DISPLAYED_NAME, KARABO_SCHEMA_ENABLE_ROLLING_STATS,
+    KARABO_SCHEMA_LEAF_TYPE, KARABO_SCHEMA_MAX, KARABO_SCHEMA_MAX_EXC,
+    KARABO_SCHEMA_MAX_INC, KARABO_SCHEMA_MAX_SIZE,
+    KARABO_SCHEMA_METRIC_PREFIX_ENUM, KARABO_SCHEMA_METRIC_PREFIX_NAME,
+    KARABO_SCHEMA_METRIC_PREFIX_SYMBOL, KARABO_SCHEMA_MIN,
+    KARABO_SCHEMA_MIN_EXC, KARABO_SCHEMA_MIN_INC, KARABO_SCHEMA_MIN_SIZE,
+    KARABO_SCHEMA_NODE_TYPE, KARABO_SCHEMA_OPTIONS, KARABO_SCHEMA_OVERWRITE,
+    KARABO_SCHEMA_REGEX, KARABO_SCHEMA_RELATIVE_ERROR,
+    KARABO_SCHEMA_REQUIRED_ACCESS_LEVEL, KARABO_SCHEMA_ROLLING_STATS_EVAL,
+    KARABO_SCHEMA_ROW_SCHEMA, KARABO_SCHEMA_SKIP_VALIDATION,
+    KARABO_SCHEMA_TAGS, KARABO_SCHEMA_UNIT_ENUM, KARABO_SCHEMA_UNIT_NAME,
+    KARABO_SCHEMA_UNIT_SYMBOL, KARABO_SCHEMA_VALUE_TYPE, KARABO_TYPE_BOOL,
+    KARABO_TYPE_BYTE_ARRAY, KARABO_TYPE_CHAR, KARABO_TYPE_COMPLEX_DOUBLE,
+    KARABO_TYPE_COMPLEX_FLOAT, KARABO_TYPE_DOUBLE, KARABO_TYPE_FLOAT,
+    KARABO_TYPE_HASH, KARABO_TYPE_INT8, KARABO_TYPE_INT16, KARABO_TYPE_INT32,
+    KARABO_TYPE_INT64, KARABO_TYPE_NONE, KARABO_TYPE_SCHEMA,
+    KARABO_TYPE_STRING, KARABO_TYPE_UINT8, KARABO_TYPE_UINT16,
+    KARABO_TYPE_UINT32, KARABO_TYPE_UINT64, KARABO_TYPE_VECTOR_BOOL,
+    KARABO_TYPE_VECTOR_CHAR, KARABO_TYPE_VECTOR_COMPLEX_DOUBLE,
+    KARABO_TYPE_VECTOR_COMPLEX_FLOAT, KARABO_TYPE_VECTOR_DOUBLE,
+    KARABO_TYPE_VECTOR_FLOAT, KARABO_TYPE_VECTOR_HASH, KARABO_TYPE_VECTOR_INT8,
+    KARABO_TYPE_VECTOR_INT16, KARABO_TYPE_VECTOR_INT32,
+    KARABO_TYPE_VECTOR_INT64, KARABO_TYPE_VECTOR_STRING,
+    KARABO_TYPE_VECTOR_UINT8, KARABO_TYPE_VECTOR_UINT16,
+    KARABO_TYPE_VECTOR_UINT32, KARABO_TYPE_VECTOR_UINT64, KARABO_WARN_HIGH,
+    KARABO_WARN_LOW, KARABO_WARN_VARIANCE_HIGH, KARABO_WARN_VARIANCE_LOW)
+from .decorators import karabo_deprecated
+from .display_types import (
+    KARABO_SCHEMA_DISPLAY_TYPE_ALARM, KARABO_SCHEMA_DISPLAY_TYPE_BIN,
+    KARABO_SCHEMA_DISPLAY_TYPE_BITSET, KARABO_SCHEMA_DISPLAY_TYPE_CURVE,
+    KARABO_SCHEMA_DISPLAY_TYPE_DIRECTORY, KARABO_SCHEMA_DISPLAY_TYPE_FILEIN,
+    KARABO_SCHEMA_DISPLAY_TYPE_FILEOUT, KARABO_SCHEMA_DISPLAY_TYPE_HEX,
+    KARABO_SCHEMA_DISPLAY_TYPE_IMAGEDATA, KARABO_SCHEMA_DISPLAY_TYPE_OCT,
+    KARABO_SCHEMA_DISPLAY_TYPE_RUNCONFIGURATOR,
+    KARABO_SCHEMA_DISPLAY_TYPE_SCENES, KARABO_SCHEMA_DISPLAY_TYPE_STATE)
+from .enums import Capabilities, InstanceStatus, Interfaces, ServerFlags
+from .module import create_module
+from .sanity_check import has_sub_imports
+from .savable import BaseSavableModel, set_initialized_flag, set_modified_flag
+from .services import (
+    KARABO_ALARM_SERVICE, KARABO_CONFIG_MANAGER, KARABO_DAEMON_MANAGER,
+    KARABO_LOGBOOK_MANAGER, KARABO_PROJECT_MANAGER)
+from .states import State, StateSignifier
+from .utils import WeakMethodRef, walk_traits_object

karabo/common/const.py

@@ -0,0 +1,374 @@
+# 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.
+# Copied from karabo/util/Schema.hh!
+KARABO_SCHEMA_NODE_TYPE = "nodeType"
+KARABO_SCHEMA_LEAF_TYPE = "leafType"
+KARABO_SCHEMA_VALUE_TYPE = "valueType"
+KARABO_SCHEMA_CLASS_ID = "classId"
+KARABO_SCHEMA_DISPLAYED_NAME = "displayedName"
+KARABO_SCHEMA_DESCRIPTION = "description"
+KARABO_SCHEMA_DEFAULT_VALUE = "defaultValue"
+KARABO_SCHEMA_DISPLAY_TYPE = "displayType"
+KARABO_SCHEMA_ACCESS_MODE = "accessMode"
+KARABO_SCHEMA_ALIAS = "alias"
+KARABO_SCHEMA_ALLOWED_STATES = "allowedStates"
+KARABO_SCHEMA_ASSIGNMENT = "assignment"
+KARABO_SCHEMA_TAGS = "tags"
+KARABO_SCHEMA_ROW_SCHEMA = "rowSchema"
+KARABO_SCHEMA_SKIP_VALIDATION = "skipValidation"
+KARABO_SCHEMA_OPTIONS = "options"
+KARABO_SCHEMA_REQUIRED_ACCESS_LEVEL = "requiredAccessLevel"
+KARABO_SCHEMA_UNIT_ENUM = "unitEnum"
+KARABO_SCHEMA_UNIT_NAME = "unitName"
+KARABO_SCHEMA_UNIT_SYMBOL = "unitSymbol"
+KARABO_SCHEMA_METRIC_PREFIX_ENUM = "metricPrefixEnum"
+KARABO_SCHEMA_METRIC_PREFIX_NAME = "metricPrefixName"
+KARABO_SCHEMA_METRIC_PREFIX_SYMBOL = "metricPrefixSymbol"
+KARABO_SCHEMA_MIN_INC = "minInc"
+KARABO_SCHEMA_MAX_INC = "maxInc"
+KARABO_SCHEMA_MIN_EXC = "minExc"
+KARABO_SCHEMA_MAX_EXC = "maxExc"
+KARABO_SCHEMA_RELATIVE_ERROR = "relativeError"
+KARABO_SCHEMA_ABSOLUTE_ERROR = "absoluteError"
+KARABO_SCHEMA_MIN_SIZE = "minSize"
+KARABO_SCHEMA_MAX_SIZE = "maxSize"
+KARABO_SCHEMA_ENABLE_ROLLING_STATS = "enableRollingStats"
+KARABO_SCHEMA_ROLLING_STATS_EVAL = "rollingStatsEvalInterval"
+KARABO_SCHEMA_ARCHIVE_POLICY = "archivePolicy"
+KARABO_SCHEMA_MIN = "min"
+KARABO_SCHEMA_MAX = "max"
+KARABO_SCHEMA_OVERWRITE = "overwrite"
+KARABO_SCHEMA_ALARM_ACK = "alarmNeedsAck"
+KARABO_SCHEMA_ALARM_INFO = "alarmInfo"
+KARABO_RUNTIME_SCHEMA_UPDATE = "runtimeSchemaUpdates"
+KARABO_SCHEMA_DAQ_DATA_TYPE = "daqDataType"
+KARABO_SCHEMA_DAQ_POLICY = "daqPolicy"
+KARABO_SCHEMA_REGEX = "regex"
+
+# Fixed classId definitions
+
+KARABO_CLASS_ID_STATE = "State"
+KARABO_CLASS_ID_ALARM = "AlarmCondition"
+
+# These are from AlarmConditions.hh, but they also apply to schemata
+KARABO_WARN_LOW = "warnLow"
+KARABO_WARN_HIGH = "warnHigh"
+KARABO_ALARM_LOW = "alarmLow"
+KARABO_ALARM_HIGH = "alarmHigh"
+KARABO_WARN_VARIANCE_LOW = "warnVarianceLow"
+KARABO_WARN_VARIANCE_HIGH = "warnVarianceHigh"
+KARABO_ALARM_VARIANCE_LOW = "alarmVarianceLow"
+KARABO_ALARM_VARIANCE_HIGH = "alarmVarianceHigh"
+
+# The default scene name to be used
+KARABO_SCHEMA_DEFAULT_SCENE = "scene"
+
+# A tuple which defines the ordering of the above attributes
+KARABO_SCHEMA_ATTRIBUTES = (
+    KARABO_SCHEMA_DISPLAYED_NAME,
+    KARABO_SCHEMA_DESCRIPTION,
+    KARABO_SCHEMA_DEFAULT_VALUE,
+    KARABO_SCHEMA_DISPLAY_TYPE,
+    KARABO_SCHEMA_ACCESS_MODE,
+    KARABO_WARN_LOW,
+    KARABO_WARN_HIGH,
+    KARABO_ALARM_LOW,
+    KARABO_ALARM_HIGH,
+    KARABO_WARN_VARIANCE_LOW,
+    KARABO_WARN_VARIANCE_HIGH,
+    KARABO_ALARM_VARIANCE_LOW,
+    KARABO_ALARM_VARIANCE_HIGH,
+    KARABO_SCHEMA_NODE_TYPE,
+    KARABO_SCHEMA_LEAF_TYPE,
+    KARABO_SCHEMA_VALUE_TYPE,
+    KARABO_SCHEMA_CLASS_ID,
+    KARABO_SCHEMA_ALIAS,
+    KARABO_SCHEMA_ALLOWED_STATES,
+    KARABO_SCHEMA_ASSIGNMENT,
+    KARABO_SCHEMA_TAGS,
+    KARABO_SCHEMA_ROW_SCHEMA,
+    KARABO_SCHEMA_SKIP_VALIDATION,
+    KARABO_SCHEMA_OPTIONS,
+    KARABO_SCHEMA_REQUIRED_ACCESS_LEVEL,
+    KARABO_SCHEMA_UNIT_ENUM,
+    KARABO_SCHEMA_UNIT_NAME,
+    KARABO_SCHEMA_UNIT_SYMBOL,
+    KARABO_SCHEMA_METRIC_PREFIX_ENUM,
+    KARABO_SCHEMA_METRIC_PREFIX_NAME,
+    KARABO_SCHEMA_METRIC_PREFIX_SYMBOL,
+    KARABO_SCHEMA_MIN_INC,
+    KARABO_SCHEMA_MAX_INC,
+    KARABO_SCHEMA_MIN_EXC,
+    KARABO_SCHEMA_MAX_EXC,
+    KARABO_SCHEMA_RELATIVE_ERROR,
+    KARABO_SCHEMA_ABSOLUTE_ERROR,
+    KARABO_SCHEMA_MIN_SIZE,
+    KARABO_SCHEMA_MAX_SIZE,
+    KARABO_SCHEMA_ENABLE_ROLLING_STATS,
+    KARABO_SCHEMA_ROLLING_STATS_EVAL,
+    KARABO_SCHEMA_ARCHIVE_POLICY,
+    KARABO_SCHEMA_MIN,
+    KARABO_SCHEMA_MAX,
+    KARABO_SCHEMA_REGEX,
+    KARABO_SCHEMA_OVERWRITE,
+    KARABO_SCHEMA_ALARM_ACK,
+    KARABO_SCHEMA_ALARM_INFO,
+    KARABO_RUNTIME_SCHEMA_UPDATE,
+    KARABO_SCHEMA_DAQ_DATA_TYPE,
+    KARABO_SCHEMA_DAQ_POLICY,
+)
+
+# A tuple containing only the attributes which are editable pre-instantiation
+KARABO_EDITABLE_ATTRIBUTES = (
+    KARABO_WARN_LOW,
+    KARABO_WARN_HIGH,
+    KARABO_ALARM_LOW,
+    KARABO_ALARM_HIGH,
+)
+
+# A tuple containing only the attributes which are editable on run-time
+KARABO_RUNTIME_ATTRIBUTES_MDL = (
+    KARABO_SCHEMA_MIN_EXC,
+    KARABO_SCHEMA_MAX_EXC,
+    KARABO_SCHEMA_MIN_INC,
+    KARABO_SCHEMA_MAX_INC,
+    KARABO_SCHEMA_ABSOLUTE_ERROR,
+    KARABO_SCHEMA_RELATIVE_ERROR,
+    KARABO_WARN_LOW,
+    KARABO_WARN_HIGH,
+    KARABO_ALARM_LOW,
+    KARABO_ALARM_HIGH,
+    KARABO_SCHEMA_DAQ_POLICY,
+)
+
+KARABO_TYPE_BOOL = "BOOL"
+KARABO_TYPE_CHAR = "CHAR"
+KARABO_TYPE_INT8 = "INT8"
+KARABO_TYPE_UINT8 = "UINT8"
+KARABO_TYPE_INT16 = "INT16"
+KARABO_TYPE_UINT16 = "UINT16"
+KARABO_TYPE_INT32 = "INT32"
+KARABO_TYPE_UINT32 = "UINT32"
+KARABO_TYPE_INT64 = "INT64"
+KARABO_TYPE_UINT64 = "UINT64"
+KARABO_TYPE_FLOAT = "FLOAT"
+KARABO_TYPE_DOUBLE = "DOUBLE"
+KARABO_TYPE_COMPLEX_FLOAT = "COMPLEX_FLOAT"
+KARABO_TYPE_COMPLEX_DOUBLE = "COMPLEX_DOUBLE"
+KARABO_TYPE_STRING = "STRING"
+KARABO_TYPE_HASH = "HASH"
+KARABO_TYPE_SCHEMA = "SCHEMA"
+KARABO_TYPE_NONE = "NONE"
+KARABO_TYPE_BYTE_ARRAY = "BYTE_ARRAY"
+KARABO_TYPE_VECTOR_BOOL = "VECTOR_BOOL"
+KARABO_TYPE_VECTOR_CHAR = "VECTOR_CHAR"
+KARABO_TYPE_VECTOR_INT8 = "VECTOR_INT8"
+KARABO_TYPE_VECTOR_UINT8 = "VECTOR_UINT8"
+KARABO_TYPE_VECTOR_INT16 = "VECTOR_INT16"
+KARABO_TYPE_VECTOR_UINT16 = "VECTOR_UINT16"
+KARABO_TYPE_VECTOR_INT32 = "VECTOR_INT32"
+KARABO_TYPE_VECTOR_UINT32 = "VECTOR_UINT32"
+KARABO_TYPE_VECTOR_INT64 = "VECTOR_INT64"
+KARABO_TYPE_VECTOR_UINT64 = "VECTOR_UINT64"
+KARABO_TYPE_VECTOR_DOUBLE = "VECTOR_DOUBLE"
+KARABO_TYPE_VECTOR_FLOAT = "VECTOR_FLOAT"
+KARABO_TYPE_VECTOR_COMPLEX_DOUBLE = "VECTOR_COMPLEX_DOUBLE"
+KARABO_TYPE_VECTOR_COMPLEX_FLOAT = "VECTOR_COMPLEX_FLOAT"
+KARABO_TYPE_VECTOR_STRING = "VECTOR_STRING"
+KARABO_TYPE_VECTOR_HASH = "VECTOR_HASH"
+
+KARABO_LOGGER_CONTENT_DEFAULT = 100
+
+KARABO_TYPES = (
+    KARABO_TYPE_BOOL,
+    KARABO_TYPE_CHAR,
+    KARABO_TYPE_INT8,
+    KARABO_TYPE_UINT8,
+    KARABO_TYPE_INT16,
+    KARABO_TYPE_UINT16,
+    KARABO_TYPE_INT32,
+    KARABO_TYPE_UINT32,
+    KARABO_TYPE_INT64,
+    KARABO_TYPE_UINT64,
+    KARABO_TYPE_FLOAT,
+    KARABO_TYPE_DOUBLE,
+    KARABO_TYPE_COMPLEX_FLOAT,
+    KARABO_TYPE_COMPLEX_DOUBLE,
+    KARABO_TYPE_STRING,
+    KARABO_TYPE_HASH,
+    KARABO_TYPE_SCHEMA,
+    KARABO_TYPE_NONE,
+    KARABO_TYPE_BYTE_ARRAY,
+    KARABO_TYPE_VECTOR_BOOL,
+    KARABO_TYPE_VECTOR_CHAR,
+    KARABO_TYPE_VECTOR_INT8,
+    KARABO_TYPE_VECTOR_UINT8,
+    KARABO_TYPE_VECTOR_INT16,
+    KARABO_TYPE_VECTOR_UINT16,
+    KARABO_TYPE_VECTOR_INT32,
+    KARABO_TYPE_VECTOR_UINT32,
+    KARABO_TYPE_VECTOR_INT64,
+    KARABO_TYPE_VECTOR_UINT64,
+    KARABO_TYPE_VECTOR_DOUBLE,
+    KARABO_TYPE_VECTOR_FLOAT,
+    KARABO_TYPE_VECTOR_COMPLEX_DOUBLE,
+    KARABO_TYPE_VECTOR_COMPLEX_FLOAT,
+    KARABO_TYPE_VECTOR_STRING,
+    KARABO_TYPE_VECTOR_HASH,
+)
+
+__KARABO_VECTOR_TYPES = (
+    KARABO_TYPE_VECTOR_BOOL,
+    KARABO_TYPE_VECTOR_INT8,
+    KARABO_TYPE_VECTOR_UINT8,
+    KARABO_TYPE_VECTOR_INT16,
+    KARABO_TYPE_VECTOR_UINT16,
+    KARABO_TYPE_VECTOR_INT32,
+    KARABO_TYPE_VECTOR_UINT32,
+    KARABO_TYPE_VECTOR_INT64,
+    KARABO_TYPE_VECTOR_UINT64,
+    KARABO_TYPE_VECTOR_DOUBLE,
+    KARABO_TYPE_VECTOR_FLOAT,
+    KARABO_TYPE_VECTOR_COMPLEX_DOUBLE,
+    KARABO_TYPE_VECTOR_COMPLEX_FLOAT,
+    KARABO_TYPE_VECTOR_STRING,
+    KARABO_TYPE_VECTOR_HASH,
+)
+
+__KARABO_INTEGER_TYPES = (
+    KARABO_TYPE_INT8,
+    KARABO_TYPE_UINT8,
+    KARABO_TYPE_INT16,
+    KARABO_TYPE_UINT16,
+    KARABO_TYPE_INT32,
+    KARABO_TYPE_UINT32,
+    KARABO_TYPE_INT64,
+    KARABO_TYPE_UINT64,
+)
+
+__KARABO_SIGNED_INTEGER_TYPES = (
+    KARABO_TYPE_INT8,
+    KARABO_TYPE_INT16,
+    KARABO_TYPE_INT32,
+    KARABO_TYPE_INT64,
+)
+
+__KARABO_UNSIGNED_INTEGER_TYPES = (
+    KARABO_TYPE_UINT8,
+    KARABO_TYPE_UINT16,
+    KARABO_TYPE_UINT32,
+    KARABO_TYPE_UINT64,
+)
+
+__KARABO_FLOAT_TYPES = (
+    KARABO_TYPE_FLOAT,
+    KARABO_TYPE_DOUBLE,
+    KARABO_TYPE_COMPLEX_FLOAT,
+    KARABO_TYPE_COMPLEX_DOUBLE,
+)
+
+__KARABO_VECTOR_INTEGER_TYPES = (
+    KARABO_TYPE_VECTOR_INT8,
+    KARABO_TYPE_VECTOR_INT16,
+    KARABO_TYPE_VECTOR_INT32,
+    KARABO_TYPE_VECTOR_INT64,
+    KARABO_TYPE_VECTOR_UINT8,
+    KARABO_TYPE_VECTOR_UINT16,
+    KARABO_TYPE_VECTOR_UINT32,
+    KARABO_TYPE_VECTOR_UINT64,
+)
+
+__KARABO_VECTOR_FLOAT_TYPES = (
+    KARABO_TYPE_VECTOR_DOUBLE,
+    KARABO_TYPE_VECTOR_FLOAT,
+    KARABO_TYPE_VECTOR_COMPLEX_DOUBLE,
+    KARABO_TYPE_VECTOR_COMPLEX_FLOAT,
+)
+
+
+def is_string_like_type(vtype: str) -> bool:
+    """Check if this value type is a string like type"""
+    return vtype in (KARABO_TYPE_CHAR, KARABO_TYPE_STRING)
+
+
+def is_string_type(vtype: str) -> bool:
+    """Check if this value type is a string type"""
+    return vtype == KARABO_TYPE_STRING
+
+
+def is_boolean_type(vtype: str) -> bool:
+    """Check if this value type is a bool type"""
+    return vtype == KARABO_TYPE_BOOL
+
+
+def is_bytearray_type(vtype: str) -> bool:
+    """Check if this value type is a bytearray type"""
+    return vtype == KARABO_TYPE_BYTE_ARRAY
+
+
+def is_vector_bool_type(vtype: str) -> bool:
+    """Check if this value type is a vector bool type"""
+    return vtype == KARABO_TYPE_VECTOR_BOOL
+
+
+def is_vector_char_type(vtype: str) -> bool:
+    """Check if this value type is a vector char type"""
+    return vtype == KARABO_TYPE_VECTOR_CHAR
+
+
+def is_vector_string_type(vtype: str) -> bool:
+    """Check if this value type is a vector string type"""
+    return vtype == KARABO_TYPE_VECTOR_STRING
+
+
+def is_vector_type(vtype: str) -> bool:
+    """Check if this value type is a vector type"""
+    return vtype in __KARABO_VECTOR_TYPES
+
+
+def is_float_type(vtype: str) -> bool:
+    """Check if this value type is a floating type"""
+    return vtype in __KARABO_FLOAT_TYPES
+
+
+def is_integer_type(vtype: str) -> bool:
+    """Check if this value type is an integer type"""
+    return vtype in __KARABO_INTEGER_TYPES
+
+
+def is_unsigned_integer_type(vtype: str) -> bool:
+    """Check if this value type belongs to an unsigned integer"""
+    return vtype in __KARABO_UNSIGNED_INTEGER_TYPES
+
+
+def is_signed_integer_type(vtype: str) -> bool:
+    """Check if this value type belongs to a signed integer"""
+    return vtype in __KARABO_SIGNED_INTEGER_TYPES
+
+
+def is_vector_integer_type(vtype: str) -> bool:
+    """Check if this value type belongs to a vector with integers"""
+    return vtype in __KARABO_VECTOR_INTEGER_TYPES
+
+
+def is_vector_float_type(vtype: str) -> bool:
+    """Check if this value type belongs to a vector with float types"""
+    return vtype in __KARABO_VECTOR_FLOAT_TYPES
+
+
+def is_vector_hash_type(vtype: str) -> bool:
+    """Check if this value type belongs to a vector hash"""
+    return vtype == KARABO_TYPE_VECTOR_HASH

karabo/common/decorators.py

@@ -0,0 +1,95 @@
+#############################################################################
+# Author: <andrea.parenti@xfel.eu>
+# Created on June 13, 2017
+# 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.
+#############################################################################
+import inspect
+import warnings
+from functools import wraps
+from time import perf_counter
+
+
+def karabo_deprecated(func):
+    """
+    This is a decorator which can be used to mark functions
+    as deprecated. It will result in a warning being emitted
+    when the function is used.
+
+    ## Usage examples ##
+    @karabo_deprecated
+    def my_func():
+        pass
+
+    @other_decorators_must_be_upper
+    @karabo_deprecated
+    def my_func():
+        pass
+    """
+
+    @wraps(func)
+    def new_func(*args, **kwargs):
+        warnings.warn_explicit(
+            f"Call to deprecated function {func.__name__}.",
+            category=DeprecationWarning,
+            filename=func.__code__.co_filename,
+            lineno=func.__code__.co_firstlineno + 1,
+        )
+        return func(*args, **kwargs)
+
+    return new_func
+
+
+def timeit(func):
+    """A timing decorator"""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        t_start = perf_counter()
+        ret = func(*args, **kwargs)
+        elapsed = perf_counter() - t_start
+        print(f"{func.__name__} took {elapsed}")
+        return ret
+
+    return wrapper
+
+
+def validate_args(func):
+    """A decorator to be used to validate arguments with their annotations
+
+    Usage examples::
+
+        @validate_args
+        def my_func(param1: str, param2: (float, int)):
+            pass
+
+    The decorator will raise if the function is called with wrong type input.
+
+    Note: Booleans are also valid for integers!
+    """
+
+    @wraps(func)
+    def wrapper(*args):
+        argspec = inspect.getfullargspec(func).args
+        for index, name in enumerate(argspec):
+            if not isinstance(args[index], func.__annotations__[name]):
+                raise ValueError(
+                    "Argument {} got wrong input "
+                    "type {}".format(name, args[index])
+                )
+        return func(*args)
+
+    return wrapper