Accept a more specific variable rule in Dictionary.add_variable_from_spec instead of a verbatim string

Author: Thierry RAMORASOAVINA

doc/samples/samples.rst

@@ -93,6 +93,12 @@ Samples
     third_dictionary.add_variable_from_spec(name="StreetNumber", type="Numerical")
     third_dictionary.add_variable_from_spec(name="StreetName", type="Categorical")
     third_dictionary.add_variable_from_spec(name="id_city", type="Categorical")
+    # Add a variable with a rule
+    third_dictionary.add_variable_from_spec(
+        name="computed",
+        type="Numerical",
+        rule=kh.Rule("Ceil", kh.Rule("Product", 3, kh.Rule("Random()"))),
+    )
 
     # Add the variables used in a multi-table context in the first dictionary.
     # They link the root dictionary to the additional ones

khiops/core/dictionary.py

@@ -86,17 +86,17 @@ def _check_name(name):
     The Khiops core forbids a name
         - with a length outside the [1,128] interval
         - containing a simple (Unix) carriage-return (\n)
-        - with leading and trailing spaces
+        - with leading and trailing spaces.
     This function must check at least these constraints.
 
     Parameters
     ----------
         name : str
-            Name to be validated
+            Name to be validated.
     Raises
     ------
         `ValueError`
-            If the provided name does not comply with the formatting constraints
+            If the provided name does not comply with the formatting constraints.
     """
     # Check that the type of name is string or bytes
     if not is_string_like(name):
@@ -108,7 +108,7 @@ def _check_name(name):
     else:
         assert isinstance(name, bytes)
         contains_carriage_return = b"\n" in name
-    if not len(name) <= 128 or contains_carriage_return or name != name.strip():
+    if len(name) > 128 or contains_carriage_return or name != name.strip():
         raise ValueError(
             f"Variable name '{name}' cannot be accepted "
             "(invalid length or characters)"
@@ -846,19 +846,19 @@ def add_variable_from_spec(
         Parameters
         ----------
         name : str
-            Variable name
+            Variable name.
         type : str
-            Variable type, See `Variable`
+            Variable type, See `Variable`.
         label : str, default ""
             Label of the variable.
         used : bool, default ``True``
             Usage status of the variable.
         object_type : str, optional
-            Object type. Ignored if variable type not in ["Entity", "Table"]
+            Object type. Ignored if variable type not in ["Entity", "Table"].
         structure_type : str, optional
-            Structure type. Ignored if variable type is not "Structure"
-        rule : str, optional
-            Variable rule (in verbatim).
+            Structure type. Ignored if variable type is not "Structure".
+        rule : `Rule`, optional
+            Variable rule.
         meta_data : dict, optional
             A Python dictionary which holds the metadata specification.
             The dictionary keys are str. The values can be str, bool, float or int.
@@ -870,8 +870,8 @@ def add_variable_from_spec(
               with the formatting constraints.
             - If there is already a variable with the same name.
             - If the given variable type is unknown.
-            - If a native type is given 'object_type' or 'structure_type'
-            - If the 'meta_data' is not a dictionary
+            - If a native type is given 'object_type' or 'structure_type'.
+            - If the 'meta_data' is not a dictionary.
         """
         # Values and Types checks
         if not name:
@@ -890,12 +890,11 @@ def add_variable_from_spec(
                 )
         if _is_object_type(type) and object_type is None:
             raise ValueError(f"'object_type' must be provided for type '{type}'")
+        if type == "Structure" and structure_type is None:
+            raise ValueError(f"'structure_type' must be provided for type '{type}'")
         if meta_data is not None:
             if not is_dict_like(meta_data):
                 raise TypeError(type_error_message("meta_data", meta_data, "dict-like"))
-        if label is not None:
-            if not is_string_like(label):
-                raise TypeError(type_error_message("label", label, "string-like"))
         if object_type is not None:
             if not is_string_like(object_type):
                 raise TypeError(
@@ -907,8 +906,8 @@ def add_variable_from_spec(
                     type_error_message("structure_type", structure_type, "string-like")
                 )
         if rule is not None:
-            if not is_string_like(rule):
-                raise TypeError(type_error_message("rule", rule, "string-like"))
+            if not isinstance(rule, Rule):
+                raise TypeError(type_error_message("rule", rule, Rule))
 
         # Variable initialization
         variable = Variable()
@@ -924,7 +923,7 @@ def add_variable_from_spec(
         if structure_type is not None:
             variable.structure_type = structure_type
         if rule is not None:
-            variable.rule = Rule(verbatim=rule)
+            variable.set_rule(rule)
         self.add_variable(variable)
 
     def remove_variable(self, variable_name):

khiops/samples/samples.ipynb

@@ -105,6 +105,12 @@
     "third_dictionary.add_variable_from_spec(name=\"StreetNumber\", type=\"Numerical\")\n",
     "third_dictionary.add_variable_from_spec(name=\"StreetName\", type=\"Categorical\")\n",
     "third_dictionary.add_variable_from_spec(name=\"id_city\", type=\"Categorical\")\n",
+    "# Add a variable with a rule\n",
+    "third_dictionary.add_variable_from_spec(\n",
+    "    name=\"computed\",\n",
+    "    type=\"Numerical\",\n",
+    "    rule=kh.Rule(\"Ceil\", kh.Rule(\"Product\", 3, kh.Rule(\"Random()\"))),\n",
+    ")\n",
     "\n",
     "# Add the variables used in a multi-table context in the first dictionary.\n",
     "# They link the root dictionary to the additional ones\n",

khiops/samples/samples.py

@@ -107,6 +107,12 @@ def create_dictionary_domain():
     third_dictionary.add_variable_from_spec(name="StreetNumber", type="Numerical")
     third_dictionary.add_variable_from_spec(name="StreetName", type="Categorical")
     third_dictionary.add_variable_from_spec(name="id_city", type="Categorical")
+    # Add a variable with a rule
+    third_dictionary.add_variable_from_spec(
+        name="computed",
+        type="Numerical",
+        rule=kh.Rule("Ceil", kh.Rule("Product", 3, kh.Rule("Random()"))),
+    )
 
     # Add the variables used in a multi-table context in the first dictionary.
     # They link the root dictionary to the additional ones

tests/test_core.py

@@ -1882,8 +1882,15 @@ def test_dictionary_accessors(self):
                     dictionary.add_variable_from_spec(
                         name="fresh_one", type="Entity", object_type={}
                     )
-                # rule must be a str
-                with self.assertRaisesRegex(TypeError, "'rule'.*string-like"):
+                # a structure type must have a structure_type parameter
+                with self.assertRaisesRegex(
+                    ValueError, "'structure_type' must be provided"
+                ):
+                    dictionary.add_variable_from_spec(
+                        name="fresh_one", type="Structure"
+                    )
+                # rule must be Rule object
+                with self.assertRaisesRegex(TypeError, "'rule'.*Rule"):
                     dictionary.add_variable_from_spec(
                         name="fresh_one", type="Categorical", rule={}
                     )
@@ -1892,17 +1899,23 @@ def test_dictionary_accessors(self):
                     dictionary.add_variable_from_spec(
                         name="fresh_one", type="Categorical", meta_data="str"
                     )
-                # successful adding (with meta-data)
+                # successful adding (with meta-data and rule)
                 dictionary.add_variable_from_spec(
                     name="fresh_one",
                     type="Categorical",
                     meta_data={"a": 1, "b": 2},
+                    rule=kh.Rule("Ceil", kh.Rule("Product", 3, kh.Rule("Random()"))),
                 )
                 self.assertEqual(
                     2,
                     dictionary.get_variable("fresh_one").get_value("b"),
                     "Variable meta-data must be set correctly",
                 )
+                self.assertEqual(
+                    "Ceil(Product(3, Random()))",
+                    repr(dictionary.get_variable("fresh_one").get_rule()),
+                    "Variable rule must be set correctly",
+                )
 
                 # Test Dictionary variable block accessors
                 # Create a simple block