Put rule getters and setters on variable and variable blocks

Thus, rules are treated in the same way as the other Variable
/ VariableBlock fields.

Author: popescu-v

doc/samples/samples.rst

@@ -658,8 +658,7 @@ Samples
     dictionary.add_variable(fold_index_variable)
 
     # Create fold indexing rule and set it on `fold_index_variable`
-    dictionary.set_variable_rule(
-        fold_index_variable.name,
+    dictionary.get_variable(fold_index_variable.name).set_rule(
         kh.Rule("Ceil", kh.Rule("Product", fold_number, kh.Rule("Random()"))),
     )
 
@@ -670,8 +669,7 @@ Samples
         is_in_train_dataset_variable.type = "Numerical"
         is_in_train_dataset_variable.used = False
         dictionary.add_variable(is_in_train_dataset_variable)
-        dictionary.set_variable_rule(
-            is_in_train_dataset_variable.name,
+        dictionary.get_variable(is_in_train_dataset_variable.name).set_rule(
             kh.Rule("NEQ", fold_index_variable, fold_index),
         )
 

khiops/core/dictionary.py

@@ -905,38 +905,6 @@ def remove_variable_block(
 
         return removed_block
 
-    def set_variable_rule(self, variable_name, rule):
-        """Sets a rule on a specified variable in the dictionary
-
-        Parameters
-        ----------
-        variable_name : str
-            Name of the variable the rule is set on.
-        rule : `Rule`
-            The rule to be set on the variable whose name is ``variable_name``.
-
-        Raises
-        ------
-        `TypeError`
-            If ``rule`` is not of type `Rule`
-            If ``variable_name`` is not of type `str`
-
-        `ValueError`
-            If ``variable_name`` is the empty string
-
-        `KeyError`
-            If no variable of name ``variable_name`` exists in the dictionary
-        """
-        if not is_string_like(variable_name):
-            raise TypeError(
-                type_error_message("variable_name", variable_name, "string-like")
-            )
-        if not variable_name:
-            raise ValueError("'variable_name' must not be empty")
-        if not isinstance(rule, Rule):
-            raise TypeError(type_error_message("rule", rule, Rule))
-        self.get_variable(variable_name).rule = repr(rule)
-
     def set_variable_block_rule(self, variable_block_name, rule):
         """Sets a rule on a specified variable block in the dictionary
 
@@ -1331,6 +1299,27 @@ def full_type(self):
             full_type += f"({self.structure_type})"
         return full_type
 
+    def get_rule(self):
+        """Gets `Rule` from a specified variable"""
+        return Rule(name=self.rule)
+
+    def set_rule(self, rule):
+        """Sets a rule on a specified variable in the dictionary
+
+        Parameters
+        ----------
+        rule : `Rule`
+            The rule to be set on the variable.
+
+        Raises
+        ------
+        `TypeError`
+            If ``rule`` is not of type `Rule`
+        """
+        if not isinstance(rule, Rule):
+            raise TypeError(type_error_message("rule", rule, Rule))
+        self.rule = repr(rule)
+
     def write(self, writer):
         """Writes the domain to a file writer in ``.kdic`` format
 
@@ -1506,6 +1495,27 @@ def get_value(self, key):
         """
         return self.meta_data.get_value(key)
 
+    def get_rule(self):
+        """Gets `Rule` from a specified variable block"""
+        return Rule(name=self.rule)
+
+    def set_rule(self, rule):
+        """Sets a rule on a specified variable block in the dictionary
+
+        Parameters
+        ----------
+        rule : `Rule`
+            The rule to be set on the variable block
+
+        Raises
+        ------
+        `TypeError`
+            If ``rule`` is not of type `Rule`
+        """
+        if not isinstance(rule, Rule):
+            raise TypeError(type_error_message("rule", rule, Rule))
+        self.rule = repr(rule)
+
     def write(self, writer):
         """Writes the variable block to a file writer in ``.kdic`` format
 

khiops/samples/samples.ipynb

@@ -878,8 +878,7 @@
     "dictionary.add_variable(fold_index_variable)\n",
     "\n",
     "# Create fold indexing rule and set it on `fold_index_variable`\n",
-    "dictionary.set_variable_rule(\n",
-    "    fold_index_variable.name,\n",
+    "dictionary.get_variable(fold_index_variable.name).set_rule(\n",
     "    kh.Rule(\"Ceil\", kh.Rule(\"Product\", fold_number, kh.Rule(\"Random()\"))),\n",
     ")\n",
     "\n",
@@ -890,8 +889,7 @@
     "    is_in_train_dataset_variable.type = \"Numerical\"\n",
     "    is_in_train_dataset_variable.used = False\n",
     "    dictionary.add_variable(is_in_train_dataset_variable)\n",
-    "    dictionary.set_variable_rule(\n",
-    "        is_in_train_dataset_variable.name,\n",
+    "    dictionary.get_variable(is_in_train_dataset_variable.name).set_rule(\n",
     "        kh.Rule(\"NEQ\", fold_index_variable, fold_index),\n",
     "    )\n",
     "\n",

khiops/samples/samples.py

@@ -731,8 +731,7 @@ def train_predictor_with_cross_validation():
     dictionary.add_variable(fold_index_variable)
 
     # Create fold indexing rule and set it on `fold_index_variable`
-    dictionary.set_variable_rule(
-        fold_index_variable.name,
+    dictionary.get_variable(fold_index_variable.name).set_rule(
         kh.Rule("Ceil", kh.Rule("Product", fold_number, kh.Rule("Random()"))),
     )
 
@@ -743,8 +742,7 @@ def train_predictor_with_cross_validation():
         is_in_train_dataset_variable.type = "Numerical"
         is_in_train_dataset_variable.used = False
         dictionary.add_variable(is_in_train_dataset_variable)
-        dictionary.set_variable_rule(
-            is_in_train_dataset_variable.name,
+        dictionary.get_variable(is_in_train_dataset_variable.name).set_rule(
             kh.Rule("NEQ", fold_index_variable, fold_index),
         )
 

tests/test_core.py

@@ -1881,7 +1881,7 @@ def test_dictionary_accessors(self):
                 # Set the block as non-native add, and remove it
                 dictionary_copy.add_variable_block(block)
                 block_rule = kh.Rule("SomeBlockCreatingRule()")
-                dictionary_copy.set_variable_block_rule(block.name, block_rule)
+                dictionary_copy.get_variable_block(block.name).set_rule(block_rule)
                 self.assertEqual(block, dictionary_copy.get_variable_block(block.name))
                 removed_block = dictionary_copy.remove_variable_block(
                     block.name,
@@ -1936,11 +1936,15 @@ def test_dictionary_accessors(self):
                         2,
                         kh.Rule("SomeEmbeddedRule()"),
                     )
-                    dictionary_copy.set_variable_rule(variable_name, some_rule)
+                    dictionary_copy.get_variable(variable_name).set_rule(some_rule)
                     self.assertEqual(
                         dictionary_copy.get_variable(variable_name).rule,
                         repr(some_rule),
                     )
+                    self.assertEqual(
+                        repr(dictionary_copy.get_variable(variable_name).get_rule()),
+                        repr(some_rule),
+                    )
                     self.assertEqual(
                         repr(dictionary_copy.get_variable_rule(variable_name)),
                         repr(some_rule),
@@ -1957,8 +1961,8 @@ def test_dictionary_accessors(self):
                         2,
                         kh.Rule("SomeEmbeddedRule()"),
                     )
-                    dictionary_copy.set_variable_block_rule(
-                        variable_block_name, some_rule
+                    dictionary_copy.get_variable_block(variable_block_name).set_rule(
+                        some_rule
                     )
                     self.assertEqual(
                         dictionary_copy.get_variable_block(variable_block_name).rule,