karabo.cpp 3.0.5__tar.gz → 3.0.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karabo.cpp
-Version: 3.0.5
+Version: 3.0.7
 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.7
 Description-Content-Type: text/markdown
 
 # Karabo SCADA Framework - C++ API and Service Devices

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

@@ -3,7 +3,7 @@ requires = ["scikit-build-core"]
 build-backend = "scikit_build_core.build"
 
 [project]
-version = "3.0.5"
+version = "3.0.7"
 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.7",
   ]
 
 
@@ -130,5 +130,5 @@ before-build = "pip3 install conan==2.19.0 && pip3 install numpy==2.0.1 && pytho
 
 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.7 --index-url 'https://gitlab-ci-token:glcbt-64_rQzK5PzG5pw-grW5ESAR@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.7}/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.7}/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.7}/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.7}/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.7}/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.7}/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.7}/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.7}/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.7}/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.7")
 set(KARABO_VERSION_MAJOR "3")
 set(KARABO_VERSION_MINOR "0")
-set(KARABO_VERSION_PATCH "5")
+set(KARABO_VERSION_PATCH "7")
 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.7}/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.7}/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.7}/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!)" : "")

{karabo_cpp-3.0.5 → karabo_cpp-3.0.7}/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.7}/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.7}/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.7}/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);
 }
 
 

{karabo_cpp-3.0.5 → karabo_cpp-3.0.7}/src/karabo/xms/SlotElement.hh

@@ -118,18 +118,18 @@ namespace karabo {
 
             virtual void beforeAddition() override = 0;
 
-            Derived& key(const std::string& name) override {
+            Derived& key(const std::string& name, bool strict = true) override {
                 if (name.find('_') != std::string::npos) {
                     if (name == "clear_namespace") {
                         throw KARABO_PARAMETER_EXCEPTION(
-                              "Slot 'clear_namespace' prohibited since reserved got internal usage in GUI client.");
+                              "Slot 'clear_namespace' prohibited since reserved for internal usage in GUI client.");
                     }
                     KARABO_LOG_FRAMEWORK_WARN_C("SlotElementBase")
                           << "Slot '" << name
                           << "' contains a '_'. This might lead to unexpected behaviour since the `_` is internally "
                              "used for slots inside a nodes";
                 }
-                return karabo::data::BaseElement<Derived>::key(name);
+                return karabo::data::BaseElement<Derived>::key(name, strict);
             }
         };