karabo.cpp 3.0.5__tar.gz → 3.0.8__tar.gz

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karabo.cpp
-Version: 3.0.5
+Version: 3.0.8
 Summary: Karabo's C++ API and Python bindings thereof
 Keywords: Karabo,SCADA,async,control system
 Author-Email: European XFEL GmbH <opensource@xfel.eu>
@@ -13,7 +13,7 @@ Project-URL: Homepage, https://github.com/European-XFEL/Karabo
 Project-URL: Bug Reports, https://github.com/European-XFEL/Karabo/issues
 Project-URL: Source, https://github.com/European-XFEL/Karabo
 Requires-Python: ==3.12.*
-Requires-Dist: karabo-native==3.0.5
+Requires-Dist: karabo-native==3.0.8
 Description-Content-Type: text/markdown
 
 # Karabo SCADA Framework - C++ API and Service Devices

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["scikit-build-core"]
 build-backend = "scikit_build_core.build"
 
 [project]
-version = "3.0.5"
+version = "3.0.8"
 name = "karabo.cpp"
 description = "Karabo's C++ API and Python bindings thereof"
 readme = "README.md"
@@ -38,7 +38,7 @@ classifiers = [
 # For an analysis of this field vs pip's requirements files see:
 # https://packaging.python.org/discussions/install-requires-vs-requirements/
 dependencies = [
-  "karabo-native==3.0.5",
+  "karabo-native==3.0.8",
   ]
 
 
@@ -126,9 +126,9 @@ manylinux-pypy_aarch64-image = "quay.io/pypa/manylinux_2_28_aarch64"
 # Additionally, openssl requires PERL to configure. We need to ensure a full
 # installation is available.
 before-all = "dnf -y install perl gettext"
-before-build = "pip3 install conan==2.19.0 && pip3 install numpy==2.0.1 && python -c 'from prepare_extern import prepare; prepare()' && /project/extern/build.sh /project/extern/build ALL"
+before-build = "pip3 install conan==2.21.0 && pip3 install numpy==2.0.1 && python -c 'from prepare_extern import prepare; prepare()' && /project/extern/build.sh /project/extern/build ALL"
 
 test-requires = ["pytest"]
 # these are minimally required for a C++ server to start
-before-test = "mkdir /karabo && mkdir /karabo/var && mkdir /karabo/var/data && mkdir /karabo/plugins && pip install karabo.native==3.0.5 --index-url 'https://gitlab-ci-token:glcbt-64_L2Hdjy_gxsx7hWFg_pWT@git.xfel.eu/api/v4/projects/5003/packages/pypi/simple' --extra-index-url https://pypi.org"
+before-test = "mkdir /karabo && mkdir /karabo/var && mkdir /karabo/var/data && mkdir /karabo/plugins && pip install karabo.native==3.0.8 --index-url 'https://gitlab-ci-token:glcbt-64_ss7mXyAo4wEHTJpY4ynr@git.xfel.eu/api/v4/projects/5003/packages/pypi/simple' --extra-index-url https://pypi.org"
 test-command = "KARABO=/karabo KARABO_BROKER=amqp://xfel:karabo@exfl-broker-1:5672 pytest {project}/wheel_tests"

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/pyproject.toml.template

@@ -128,7 +128,7 @@ manylinux-pypy_aarch64-image = "quay.io/pypa/manylinux_2_28_aarch64"
 # Additionally, openssl requires PERL to configure. We need to ensure a full
 # installation is available.
 before-all = "dnf -y install perl gettext"
-before-build = "pip3 install conan==2.19.0 && pip3 install numpy==2.0.1 && python -c 'from prepare_extern import prepare; prepare()' && /project/extern/build.sh /project/extern/build ALL"
+before-build = "pip3 install conan==2.21.0 && pip3 install numpy==2.0.1 && python -c 'from prepare_extern import prepare; prepare()' && /project/extern/build.sh /project/extern/build ALL"
 
 test-requires = ["pytest"]
 # these are minimally required for a C++ server to start

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyUtilAlarmElement.cc

@@ -49,7 +49,8 @@ void exportPyUtilAlarmConditionElement(py::module_& m) {
 
     a.def("displayedName", &AlarmConditionElement::displayedName, py::return_value_policy::reference_internal);
 
-    a.def("key", &AlarmConditionElement::key, py::return_value_policy::reference_internal);
+    a.def("key", &AlarmConditionElement::key, py::arg("name"), py::arg("strict") = true,
+          py::return_value_policy::reference_internal);
 
     a.def("tags",
           (AlarmConditionElement & (AlarmConditionElement::*)(std::string const&, std::string const&)) &

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyUtilHash.cc

@@ -461,8 +461,8 @@ void exportPyUtilHash(py::module_& m) {
                 g = h.get('a.b')  # reference to Hash('c', 1)
                 g.set('c', 2)
                 assert(h.get('a.b.c') == 2)
-                del(h)        # delete whole tree
-                print(g)      # SEGFAULT: dangling reference
+                del h         # delete whole tree
+                print(g)      # inner Hash still valid
           )pbdoc");
 
     h.def(

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyUtilSchemaElement.cc

@@ -217,7 +217,8 @@ void exportPyUtilSchemaElement(py::module_& m) {
               .def("description", &NDArrayElement::description, py::return_value_policy::reference_internal)
               .def("displayedName", &NDArrayElement::displayedName, py::return_value_policy::reference_internal)
               .def("init", &NDArrayElement::init, py::return_value_policy::reference_internal)
-              .def("key", &NDArrayElement::key, py::return_value_policy::reference_internal)
+              .def("key", &NDArrayElement::key, py::arg("name"), py::arg("strict") = true,
+                   py::return_value_policy::reference_internal)
               .def("readOnly", &NDArrayElement::readOnly, py::return_value_policy::reference_internal)
               .def("reconfigurable", &NDArrayElement::reconfigurable, py::return_value_policy::reference_internal)
               .def("commit", &NDArrayElement::commit, py::return_value_policy::reference_internal);

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyUtilSchemaElement.hh

@@ -234,31 +234,31 @@ class CommonWrap {
                     KARABO_PYTHON_NUMERIC_ATTRIBUTES(T);                                                      \
     }
 
-#define KARABO_PYTHON_COMMON_ATTRIBUTES(T)                                                                    \
-    .def("observerAccess", &T::observerAccess, py::return_value_policy::reference_internal)                   \
-          .def("operatorAccess", &T::operatorAccess, py::return_value_policy::reference_internal)             \
-          .def("expertAccess", &T::expertAccess, py::return_value_policy::reference_internal)                 \
-          .def("allowedStates", &CommonWrap<T>::allowedStatesPy, py::return_value_policy::reference_internal) \
-          .def("assignmentInternal", &T::assignmentInternal, py::return_value_policy::reference_internal)     \
-          .def("assignmentMandatory", &T::assignmentMandatory, py::return_value_policy::reference_internal)   \
-          .def("assignmentOptional", &T::assignmentOptional, py::return_value_policy::reference_internal)     \
-          .def("alias", &AliasAttributeWrap<T>::aliasPy, py::return_value_policy::reference_internal)         \
-          .def("commit", &T::commit, py::return_value_policy::reference_internal)                             \
-          .def("commit", (T & (T::*)(karabo::data::Schema&))(&T::commit), py::arg("expected"),                \
-               py::return_value_policy::reference_internal)                                                   \
-          .def("description", &T::description, py::return_value_policy::reference_internal)                   \
-          .def("displayedName", &T::displayedName, py::return_value_policy::reference_internal)               \
-          .def("unit", &T::unit, py::return_value_policy::reference_internal)                                 \
-          .def("metricPrefix", &T::metricPrefix, py::return_value_policy::reference_internal)                 \
-          .def("init", &T::init, py::return_value_policy::reference_internal)                                 \
-          .def("key", &T::key, py::return_value_policy::reference_internal)                                   \
-          .def("setSpecialDisplayType", (T & (T::*)(std::string const&))(&T::setSpecialDisplayType),          \
-               py::arg("displayType"), py::return_value_policy::reference_internal)                           \
-          .def("readOnly", &T::readOnly, py::return_value_policy::reference_internal)                         \
-          .def("reconfigurable", &T::reconfigurable, py::return_value_policy::reference_internal)             \
-          .def("tags", (T & (T::*)(std::string const&, std::string const&))(&T::tags), py::arg("tags"),       \
-               py::arg("sep") = " ,;", py::return_value_policy::reference_internal)                           \
-          .def("tags", (T & (T::*)(std::vector<std::string> const&))(&T::tags), py::arg("tags"),              \
+#define KARABO_PYTHON_COMMON_ATTRIBUTES(T)                                                                             \
+    .def("observerAccess", &T::observerAccess, py::return_value_policy::reference_internal)                            \
+          .def("operatorAccess", &T::operatorAccess, py::return_value_policy::reference_internal)                      \
+          .def("expertAccess", &T::expertAccess, py::return_value_policy::reference_internal)                          \
+          .def("allowedStates", &CommonWrap<T>::allowedStatesPy, py::return_value_policy::reference_internal)          \
+          .def("assignmentInternal", &T::assignmentInternal, py::return_value_policy::reference_internal)              \
+          .def("assignmentMandatory", &T::assignmentMandatory, py::return_value_policy::reference_internal)            \
+          .def("assignmentOptional", &T::assignmentOptional, py::return_value_policy::reference_internal)              \
+          .def("alias", &AliasAttributeWrap<T>::aliasPy, py::return_value_policy::reference_internal)                  \
+          .def("commit", &T::commit, py::return_value_policy::reference_internal)                                      \
+          .def("commit", (T & (T::*)(karabo::data::Schema&))(&T::commit), py::arg("expected"),                         \
+               py::return_value_policy::reference_internal)                                                            \
+          .def("description", &T::description, py::return_value_policy::reference_internal)                            \
+          .def("displayedName", &T::displayedName, py::return_value_policy::reference_internal)                        \
+          .def("unit", &T::unit, py::return_value_policy::reference_internal)                                          \
+          .def("metricPrefix", &T::metricPrefix, py::return_value_policy::reference_internal)                          \
+          .def("init", &T::init, py::return_value_policy::reference_internal)                                          \
+          .def("key", &T::key, py::arg("name"), py::arg("strict") = true, py::return_value_policy::reference_internal) \
+          .def("setSpecialDisplayType", (T & (T::*)(std::string const&))(&T::setSpecialDisplayType),                   \
+               py::arg("displayType"), py::return_value_policy::reference_internal)                                    \
+          .def("readOnly", &T::readOnly, py::return_value_policy::reference_internal)                                  \
+          .def("reconfigurable", &T::reconfigurable, py::return_value_policy::reference_internal)                      \
+          .def("tags", (T & (T::*)(std::string const&, std::string const&))(&T::tags), py::arg("tags"),                \
+               py::arg("sep") = " ,;", py::return_value_policy::reference_internal)                                    \
+          .def("tags", (T & (T::*)(std::vector<std::string> const&))(&T::tags), py::arg("tags"),                       \
                py::return_value_policy::reference_internal)
 
 #define KARABO_PYTHON_OPTIONS_NONVECTOR(T)                                                              \
@@ -315,7 +315,8 @@ class CommonWrap {
     .def("observerAccess", &NameElem::observerAccess, py::return_value_policy::reference_internal)                    \
           .def("operatorAccess", &NameElem::operatorAccess, py::return_value_policy::reference_internal)              \
           .def("expertAccess", &NameElem::expertAccess, py::return_value_policy::reference_internal)                  \
-          .def("key", &NameElem::key, py::return_value_policy::reference_internal)                                    \
+          .def("key", &NameElem::key, py::arg("name"), py::arg("strict") = true,                                      \
+               py::return_value_policy::reference_internal)                                                           \
           .def("description", &NameElem::description, py::return_value_policy::reference_internal)                    \
           .def("displayedName", &NameElem::displayedName, py::return_value_policy::reference_internal)                \
           .def("alias", &AliasAttributeWrap<NameElem>::aliasPy, py::return_value_policy::reference_internal)          \

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyUtilSchemaTableElement.cc

@@ -125,7 +125,8 @@ void exportPyUtilSchemaTableElement(py::module_& m) {
               .def("description", &TableElement::description, py::return_value_policy::reference_internal)
               .def("displayedName", &TableElement::displayedName, py::return_value_policy::reference_internal)
               .def("init", &TableElement::init, py::return_value_policy::reference_internal)
-              .def("key", &TableElement::key, py::return_value_policy::reference_internal)
+              .def("key", &TableElement::key, py::arg("name"), py::arg("strict") = true,
+                   py::return_value_policy::reference_internal)
               .def("reconfigurable", &TableElement::reconfigurable, py::return_value_policy::reference_internal)
               .def("tags",
                    (TableElement & (TableElement::*)(std::string const&, std::string const&)) & TableElement::tags,

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyUtilStateElement.cc

@@ -47,7 +47,8 @@ void exportPyUtilStateElement(py::module_& m) {
 
     se.def("displayedName", &StateElement::displayedName, py::return_value_policy::reference_internal);
 
-    se.def("key", &StateElement::key, py::return_value_policy::reference_internal);
+    se.def("key", &StateElement::key, py::arg("name"), py::arg("strict") = true,
+           py::return_value_policy::reference_internal);
 
     se.def("tags", (StateElement & (StateElement::*)(std::string const&, std::string const&)) & StateElement::tags,
            py::arg("tags"), py::arg("sep") = " ,;", py::return_value_policy::reference_internal);

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyXmsImageDataElement.cc

@@ -210,7 +210,8 @@ void exportPyXmsImageDataElement(py::module_& m) {
 
         el.def(py::init<Schema&>(), py::arg("expected"));
 
-        el.def("key", &ImageDataElement::key, py::arg("key"), py::return_value_policy::reference_internal);
+        el.def("key", &ImageDataElement::key, py::arg("key"), py::arg("strict") = true,
+               py::return_value_policy::reference_internal);
 
         el.def("displayedName", &ImageDataElement::displayedName, py::arg("name"),
                py::return_value_policy::reference_internal);

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabind/PyXmsSlotElement.cc

@@ -85,7 +85,8 @@ void exportPyXmsSlotElement(py::module_& m) {
     sl.def("displayedName", &SlotElementBase<SLOT_ELEMENT>::displayedName, py::arg("displayedName"),
            py::return_value_policy::reference_internal);
 
-    sl.def("key", &SlotElementBase<SLOT_ELEMENT>::key, py::arg("name"), py::return_value_policy::reference_internal);
+    sl.def("key", &SlotElementBase<SLOT_ELEMENT>::key, py::arg("name"), py::arg("strict") = true,
+           py::return_value_policy::reference_internal);
 
     sl.def("alias", &wrapper::AliasAttributePy<SLOT_ELEMENT>::setAlias, py::return_value_policy::reference_internal);
 

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/CMakeLists.txt

@@ -66,10 +66,10 @@ endif()
 # Extracts KARABO_VERSION from the appropriate Git tag, writes to
 # a file to be used by the Karabo Framework at build time.
 message(STATUS "Resolving Karabo Version from Git repository")
-set(KARABO_VERSION "3.0.5")
+set(KARABO_VERSION "3.0.8")
 set(KARABO_VERSION_MAJOR "3")
 set(KARABO_VERSION_MINOR "0")
-set(KARABO_VERSION_PATCH "5")
+set(KARABO_VERSION_PATCH "8")
 message(STATUS "Karabo Version: ${KARABO_VERSION}")
 message(STATUS "Karabo Version Major: ${KARABO_VERSION_MAJOR}")
 message(STATUS "Karabo Version Minor: ${KARABO_VERSION_MINOR}")

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/core/Device.cc

@@ -714,23 +714,53 @@ namespace karabo {
             onTimeTick(id, sec, frac, period);
         }
 
-
         void Device::appendSchemaMaxSize(const std::string& path, unsigned int value, bool emitFlag) {
+            internalAppendSchemaMultiMaxSize({path}, {value}, emitFlag);
+        }
+
+        void Device::appendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                              const std::vector<unsigned int>& values) {
+            internalAppendSchemaMultiMaxSize(paths, values, true);
+        }
+
+        void Device::internalAppendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                                      const std::vector<unsigned int>& values, bool emitFlag) {
             using karabo::data::OVERWRITE_ELEMENT;
+
+            if (paths.size() != values.size()) {
+                throw KARABO_PARAMETER_EXCEPTION("Number of paths and values differs.");
+            }
             std::lock_guard<std::mutex> lock(m_objectStateChangeMutex);
-            if (!m_fullSchema.has(path)) {
-                throw KARABO_PARAMETER_EXCEPTION("Path \"" + path + "\" not found in the device schema.");
+            for (const std::string& path : paths) {
+                if (!m_fullSchema.has(path)) {
+                    throw KARABO_PARAMETER_EXCEPTION("Path \"" + path + "\" not found in the device schema.");
+                }
             }
             m_stateDependentSchema.clear();
             // Do not touch static schema - that must be restorable via updateSchema(Schema())
             // OVERWRITE_ELEMENT checks whether max size attribute makes sense for path
-            OVERWRITE_ELEMENT(m_fullSchema).key(path).setNewMaxSize(value).commit();
-            if (m_injectedSchema.has(path)) {
-                OVERWRITE_ELEMENT(m_injectedSchema).key(path).setNewMaxSize(value).commit();
+            size_t index = 0;
+            for (const std::string& path : paths) {
+                const unsigned int value = values[index++]; // postfix!
+                OVERWRITE_ELEMENT(m_fullSchema).key(path).setNewMaxSize(value).commit();
+                if (m_injectedSchema.has(path)) {
+                    OVERWRITE_ELEMENT(m_injectedSchema).key(path).setNewMaxSize(value).commit();
+                }
             }
 
             // Notify the distributed system if needed
+            // (and, as in updateSchema and appendSchema, better before recreating output channels):
             if (emitFlag) emit("signalSchemaUpdated", m_fullSchema, m_deviceId);
+
+            // If the vector was part of an output channel schema, recreate the channel.
+            // The new incarnation of the channel receives the up-to-date schema for validation.
+            for (const std::string& output : getOutputChannelNames()) {
+                for (const std::string& path : paths) {
+                    if (path.starts_with(output)) {
+                        prepareOutputChannel(output);
+                    }
+                }
+            }
         }
 
 

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/core/Device.hh

@@ -811,20 +811,32 @@ namespace karabo {
                                       unsigned long long period) {}
 
             /**
-             * Append Schema to change/set maximum size information for path - if paths does not exist, throw exception
+             * Append Schema to change or set the maximum size for a vector or table property
              *
              * This is similar to the more general appendSchema, but dedicated to a common use case.
              *
-             * Caveat: This does not recreate an output channel if its schema is changed
+             * Use 'appendSchemaMultiMaxSize' if the maximum size of several properties should be changed.
              *
-             * @param path  indicates the parameter which should be a Vector- or TableElement
-             * @param value is the new maximum size of the parameter
+             * @param path  indicates the property which should be a Vector- or TableElement
+             * @param value is the new maximum size of the property
              * @param emitFlag indicates if others should be informed about this Schema update.
-             *                 If this method is called for a bunch of paths, it is recommended to
-             *                 set this to true only for the last call.
+             *                 Should only be set to false if followed by a call to appendSchema(..).
              */
             void appendSchemaMaxSize(const std::string& path, unsigned int value, bool emitFlag = true);
 
+            /**
+             * Append Schema to change or set the maximum size information for several properties
+             *
+             * @param paths  property names of Vector- or TableElements
+             * @param values the new maximum sizes of these properties (same order and length as 'paths')
+             */
+            void appendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                          const std::vector<unsigned int>& values);
+
+           private:
+            void internalAppendSchemaMultiMaxSize(const std::vector<std::string>& paths,
+                                                  const std::vector<unsigned int>& values, bool emitFlag);
+
            protected: // Functions and Classes
             virtual void preReconfigure(karabo::data::Hash& incomingReconfiguration) {}
 

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/core/DeviceClient.cc

@@ -378,7 +378,7 @@ namespace karabo {
                     //   if instance is untracked).
                     if (auto sigSlot = m_signalSlotable.lock()) {
                         const bool wasTracked = sigSlot->eraseTrackedInstance(instanceId);
-                        sigSlot->call(instanceId, "slotDiscover", 0);
+                        sigSlot->call(instanceId, "slotDiscover", getInstanceId());
                         KARABO_LOG_FRAMEWORK_WARN << getInstanceId() << ": Received instance update from '"
                                                   << instanceId << "' although it is not in runtime description"
                                                   << (wasTracked ? " (but was tracked!)" : "")
@@ -1800,8 +1800,8 @@ namespace karabo {
                 if (hash.has("doNotCompressEvents")) {
                     // magic: if the hash contains a change for the expected parameter "doNotCompressElements
                     // we are sending it directly, no throttling.
-                    // Note: Since we updated m_runtimeSystemDescription above, there is no problem if a previous
-                    // time: the next "flushing"  of m_runtimeSystemDescription will send the new value again.
+                    // Note: Since we updated m_runtimeSystemDescription above, there is no problem if the next
+                    // "flushing" of m_runtimeSystemDescription will send the new value again.
                     std::lock_guard<std::mutex> lock(m_devicesChangesMutex);
                     if (m_devicesChangesHandler) {
                         Hash deviceChanges(instanceId, hash);
@@ -1819,18 +1819,20 @@ namespace karabo {
                         std::lock_guard<std::mutex> lock(m_devicesChangesMutex);
                         if (m_devicesChangesHandler) m_devicesChangesHandler(statusChange);
                     }
-                    std::lock_guard<std::mutex> lock(m_signalsChangedMutex);
-                    // Just book keep paths here and call 'notifyDeviceChangedMonitors'
-                    // later with content from m_runtimeSystemDescription.
-                    // Note:
-                    // If there is path "a.b" coming, should we erase possible previous changes to daughters like
-                    // "a.b.c.d"? No - that should better be handled in merging into m_runtimeSystemDescription above
-                    // and then the invalid path "a.b.c.d" should be ignored 'downstream' when sending.
-                    std::set<std::string>& updatedPaths = m_signalsChanged[instanceId];
-                    hash.getPaths(updatedPaths); // extend by new updates
-
-                    // Do not send the same status update again later
-                    if (directlyForwardStatus) updatedPaths.erase(statusNode->getKey());
+                    if (!directlyForwardStatus || hash.size() > 1) { // Anything to throttle?
+                        std::lock_guard<std::mutex> lock(m_signalsChangedMutex);
+                        // Just book keep paths here and call 'notifyDeviceChangedMonitors'
+                        // later with content from m_runtimeSystemDescription.
+                        // Note:
+                        // If there is path "a.b" coming, should we erase possible previous changes to daughters like
+                        // "a.b.c.d"? No - that should better be handled in merging into m_runtimeSystemDescription
+                        // above and then the invalid path "a.b.c.d" should be ignored 'downstream' when sending.
+                        std::set<std::string>& updatedPaths = m_signalsChanged[instanceId];
+                        hash.getPaths(updatedPaths); // extend by new updates
+
+                        // Do not send the same status update again later
+                        if (directlyForwardStatus) updatedPaths.erase(statusNode->getKey());
+                    }
                 }
             } else {
                 // There is a tiny (!) risk here: The last loop of the corresponding thread
@@ -2099,6 +2101,10 @@ namespace karabo {
                  mapIt != mapEnd; ++mapIt) {
                 const std::string& instanceId = mapIt->first;
                 const std::set<std::string>& properties = mapIt->second;
+                if (properties.empty()) { // Shouldn't happen...
+                    KARABO_LOGGING_WARN("Trying to send throttled empty updates for '{}'", instanceId);
+                    continue; // merge(..) below would merge full device config into allUpdates!
+                }
                 // Get path of instance in runtime system description and then its configuration
                 const std::string path(this->findInstanceSafe(instanceId));
                 const data::Hash config(this->getSectionFromRuntimeDescription(path + ".configuration"));

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/data/schema/BaseElement.cc

@@ -23,22 +23,33 @@
 #include "karabo/data/types/Exception.hh"
 #include "karabo/data/types/Hash.hh"
 
-void karabo::data::checkPropertyPath(const std::string& name) {
+void karabo::data::checkPropertyPath(const std::string& name, bool strict) {
     if (name.empty() || name.back() == Hash::k_defaultSep) {
         throw KARABO_PARAMETER_EXCEPTION(("Bad (sub-)key '" + name) += "': empty");
     }
     // '/' is special: only allowed for backward compatibility in metro devices of DA group
-    // `@` is required for mangling with other control systems
     constexpr char allowedCharacters[] =
-          ".0123456789_/@"
+          ".0123456789_/" // In 3.1.X move '/' to tolerated characters?
           "abcdefghijklmnopqrstuvwxyz"
           "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     assert(allowedCharacters[0] == karabo::data::Hash::k_defaultSep);
 
-    const size_t pos = name.find_first_not_of(allowedCharacters);
-    if (pos != std::string::npos) {
-        std::string msg(("Bad (sub-)key '" + name) += "': illegal character at position ");
-        throw KARABO_PARAMETER_EXCEPTION(msg += toString(pos));
+    if (strict) {
+        const size_t pos = name.find_first_not_of(allowedCharacters);
+        if (pos != std::string::npos) {
+            std::string msg(("Bad (sub-)key '" + name) += "': illegal character at position ");
+            throw KARABO_PARAMETER_EXCEPTION(msg += toString(pos));
+        }
+    } else {
+        // If requested to be not strict, we tolerate some characters.
+        // Note we must not tolerate ',', '=', or space for sake of the influxDB line protocol!
+        const std::string toleratedCharacters("@-");
+        const std::string allAllowedCharacters(allowedCharacters + toleratedCharacters);
+        const size_t pos = name.find_first_not_of(allAllowedCharacters);
+        if (pos != std::string::npos) {
+            std::string msg(("Bad (sub-)key '" + name) += "': not tolerated character at position ");
+            throw KARABO_PARAMETER_EXCEPTION(msg += toString(pos));
+        }
     }
     // Now check that leading character of (last part of) name is not a digit
     // (non-last parts are checked when their nodes were added)

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/data/schema/BaseElement.hh

@@ -40,8 +40,9 @@ namespace karabo {
          * Nestes paths (i.e. paths with dots) are allowed.
          *
          * @param name the key to be checked
+         * @param strict specify whether to tolerate more than just letter, digits, underscore
          */
-        void checkPropertyPath(const std::string& name);
+        void checkPropertyPath(const std::string& name, bool strict);
 
         /**
          * The BaseElement class is a base class for various element types: simple, vector, choice, list
@@ -74,13 +75,13 @@ namespace karabo {
              *         .commit();
              * @endcode
              */
-            virtual Derived& key(const std::string& name) {
+            virtual Derived& key(const std::string& name, bool strict = true) {
                 // Check whether full path (that in fact has to be specified here!) or its last
                 // key is empty - empty non-last keys are caught elsewhere.
                 // Also ensure that keys are usable with MDL proxies, i.e. only letters, digits,
                 // underscores - and a digit not as first character.
 
-                checkPropertyPath(name); // throws if not OK
+                checkPropertyPath(name, strict); // throws if not OK
 
                 m_node->m_key = name;
                 return *(static_cast<Derived*>(this));

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/data/schema/CustomNodeElement.hh

@@ -92,6 +92,7 @@ namespace karabo {
             /**
              * The <b>key</b> method serves for setting up a unique name for the element.
              * @param name Unique name for the key
+             * @param strict keep as true to get the strongly recommended strict validation of characters in 'name'
              * @return reference to the Element (to allow method's chaining)
              *
              * <b>Example:</b>
@@ -102,10 +103,10 @@ namespace karabo {
              *         .commit();
              * @endcode
              */
-            Derived& key(const std::string& key) {
+            Derived& key(const std::string& key, bool strict = true) {
                 using namespace karabo::data;
                 m_key = key;
-                NODE_ELEMENT(m_schema).key(m_key).template appendParametersOf<Described>().commit();
+                NODE_ELEMENT(m_schema).key(m_key, strict).template appendParametersOf<Described>().commit();
 
                 return *(static_cast<Derived*>(this));
             }

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/devices/PropertyTest.cc

@@ -1174,7 +1174,11 @@ namespace karabo {
 
 
         void PropertyTest::slotUpdateStatus(const std::string& status, int intProperty) {
-            set(Hash("status", status, "int32PropertyReadOnly", intProperty));
+            Hash update("status", status);
+            if (intProperty >= 0) {
+                update.set("int32PropertyReadOnly", intProperty);
+            }
+            set(update);
         }
 
 

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/tests/core/DeviceClient_Test.cc

@@ -484,7 +484,7 @@ void DeviceClient_Test::testDeviceConfigurationsHandler() {
     for (size_t i = 0; i < numStatusUpdates; ++i) {
         const std::string status("Status " + toString(i));
         CPPUNIT_ASSERT_NO_THROW(
-              m_deviceClient->execute(devId, "slotUpdateStatus", KRB_TEST_MAX_TIMEOUT, status, int(i)));
+              m_deviceClient->execute(devId, "slotUpdateStatus", KRB_TEST_MAX_TIMEOUT, status, static_cast<int>(i)));
     }
     // Since execute is synchronous, all signal updates directly triggered by it have returned
     // to the client and that one has called our handler. But the simultaneous update of
@@ -501,18 +501,20 @@ void DeviceClient_Test::testDeviceConfigurationsHandler() {
     size_t numStatus = 0, numInt32 = 0;
     for (size_t i = 0; i < updates.size(); ++i) {
         const karabo::data::Hash& update = updates[i];
+        const std::string msg((toString(i) += ": ") += toString(update));
+        CPPUNIT_ASSERT_MESSAGE(msg, !update.has("deviceId"));
         if (update.has("status")) {
             // It is throttled, no other keys!
-            CPPUNIT_ASSERT_MESSAGE(toString(update), !update.has("int32PropertyReadOnly"));
+            CPPUNIT_ASSERT_MESSAGE(msg, !update.has("int32PropertyReadOnly"));
 
             const bool hasTimeAttrs = Timestamp::hashAttributesContainTimeInformation(update.getAttributes("status"));
-            CPPUNIT_ASSERT_MESSAGE(toString(update), hasTimeAttrs);
+            CPPUNIT_ASSERT_MESSAGE(msg, hasTimeAttrs);
             ++numStatus;
         } else if (update.has("int32PropertyReadOnly")) {
             lastInt32 = update.get<int>("int32PropertyReadOnly");
             ++numInt32;
         } else { // nothing else expected
-            CPPUNIT_ASSERT_MESSAGE(toString(update), false);
+            CPPUNIT_ASSERT_MESSAGE(msg, false);
         }
     }
     // Are all status updates received?
@@ -522,6 +524,42 @@ void DeviceClient_Test::testDeviceConfigurationsHandler() {
     // Some throttling should have taken place (can we be 100% sure?)
     CPPUNIT_ASSERT_LESS(numStatusUpdates, numInt32);
 
+    // Now check that a single "status" update does not trigger any additional handler call
+    // (as was still in 3.0.7...)
+    auto statusPromise = std::make_shared<std::promise<void>>();
+    auto statusFut = statusPromise->get_future();
+    auto lastCommandPromise = std::make_shared<std::promise<void>>();
+    auto lastCommandFut = lastCommandPromise->get_future();
+    updates.clear();
+    auto newHandler = [&updates, devId, statusPromise, lastCommandPromise](const Hash& changes) {
+        if (changes.has(devId)) {
+            const karabo::data::Hash& devUpdate = changes.get<Hash>(devId);
+            updates.push_back(devUpdate);
+            if (devUpdate.has("status")) {
+                statusPromise->set_value();
+            } else if (devUpdate.has("lastCommand")) {
+                lastCommandPromise->set_value();
+            }
+        }
+    };
+    m_deviceClient->registerDevicesMonitor(newHandler);
+    // -1: Only update "status"
+    CPPUNIT_ASSERT_NO_THROW(
+          m_deviceClient->execute(devId, "slotUpdateStatus", KRB_TEST_MAX_TIMEOUT, "A status update", -1));
+    result = statusFut.wait_for(std::chrono::seconds{KRB_TEST_MAX_TIMEOUT});
+    CPPUNIT_ASSERT_EQUAL(std::future_status::ready, result);
+    statusFut.get();
+    CPPUNIT_ASSERT_NO_THROW(m_deviceClient->execute(devId, "slotResetSchema", KRB_TEST_MAX_TIMEOUT));
+    result = lastCommandFut.wait_for(std::chrono::seconds{KRB_TEST_MAX_TIMEOUT});
+    CPPUNIT_ASSERT_EQUAL(std::future_status::ready, result);
+    lastCommandFut.get();
+    // Two updates: "status" and "lastCommand" (triggered by call of schema slot) and nothing else
+    CPPUNIT_ASSERT_EQUAL_MESSAGE(toString(updates), 2ul, updates.size());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE(toString(updates[0]), 1ul, updates[0].size());
+    CPPUNIT_ASSERT_MESSAGE(toString(updates[0]), updates[0].has("status"));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE(toString(updates[1]), 1ul, updates[1].size());
+    CPPUNIT_ASSERT_MESSAGE(toString(updates[1]), updates[1].has("lastCommand"));
+
     // Reset again
     m_deviceClient->setDeviceMonitorInterval(-1);
     m_deviceClient->registerDevicesMonitor([](const karabo::data::Hash&) {}); // not reset, but now no-op...

{karabo_cpp-3.0.5 → karabo_cpp-3.0.8}/src/karabo/tests/data/schema/Schema_Test.cc

@@ -619,6 +619,10 @@ void Schema_Test::testSlotElement() {
     //                         karabo::data::ParameterException);
     // But this one is forbidden due to interference with GUI client:
     CPPUNIT_ASSERT_THROW(SLOT_ELEMENT(sch).key("clear_namespace"), karabo::data::ParameterException);
+
+    // With the 'strict' flag set to false one can widen a bit the set of allowed characters, e.g. '-'
+    CPPUNIT_ASSERT_THROW(SLOT_ELEMENT(sch).key("slot-some", true), karabo::data::ParameterException);
+    CPPUNIT_ASSERT_NO_THROW(SLOT_ELEMENT(sch).key("slot-some", false).commit());
 }
 
 
@@ -1401,10 +1405,22 @@ void Schema_Test::testInvalidNodes() {
                                  karabo::data::ParameterException);
 
     constexpr char validCharacters[] =
-          "abcdefghijklmnopqrstuvwxyz/" // tolerate `/`
+          "abcdefghijklmnopqrstuvwxyz/" // tolerate `/` (might require strict=false in future)
           "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-          "0123456789_@";
+          "0123456789_";
     CPPUNIT_ASSERT_NO_THROW(INT8_ELEMENT(schema).key(validCharacters).readOnly().commit());
+    CPPUNIT_ASSERT_NO_THROW(INT8_ELEMENT(schema).key(std::string("node.") += validCharacters).readOnly().commit());
+
+    // Check tolerance if requested to be not strict:
+    std::string tolerated(valid);
+    tolerated[1] = '@';
+    CPPUNIT_ASSERT_NO_THROW(INT8_ELEMENT(schema).key(tolerated, false).readOnly().commit());
+    CPPUNIT_ASSERT_THROW(INT8_ELEMENT(schema).key(tolerated), karabo::data::ParameterException);
+
+    // Now with two tolerated characters, one at the end
+    tolerated.back() = '-';
+    CPPUNIT_ASSERT_NO_THROW(INT8_ELEMENT(schema).key(tolerated, false).readOnly().commit());
+    CPPUNIT_ASSERT_THROW(INT8_ELEMENT(schema).key(tolerated), karabo::data::ParameterException);
 }