Add the upper_scope method to Variable and Rule

Thus, this entails the serialization of the Variable or Rule operand as prefixed
by a dot.

Author: popescu-v

khiops/core/dictionary.py

@@ -81,6 +81,23 @@ def _quote_value(value):
     return quoted_value
 
 
+class _ScopedOperand:
+    def __init__(self, operand):
+        assert type(operand) in (Variable, Rule), type_error_message(
+            "operand", operand, Variable, Rule
+        )
+        self.operand = operand
+
+    def __repr__(self):
+        stream = io.BytesIO()
+        writer = KhiopsOutputWriter(stream)
+        if isinstance(self.operand, Variable):
+            writer.write(_format_name(self.operand.name))
+        else:
+            self.operand.write(writer)
+        return "." + str(stream.getvalue(), encoding="utf8", errors="replace")
+
+
 class DictionaryDomain(KhiopsJSONObject):
     """Main class containing the information of a Khiops dictionary file
 
@@ -1206,6 +1223,10 @@ def __str__(self):
         self.write(writer)
         return str(stream.getvalue(), encoding="utf8", errors="replace")
 
+    def upper_scope(self):
+        """Adds the '.' upper-scope prefix to the serialization of the operand."""
+        return _ScopedOperand(self)
+
     def copy(self):
         """Copies this variable instance
 
@@ -1583,10 +1604,20 @@ def __init__(self, name, *operands):
         if not isinstance(name, str):
             raise TypeError(type_error_message("name", name, str))
         for operand in operands:
-            if not isinstance(operand, (str, int, float, Variable, Rule)):
+            if not isinstance(
+                operand, (str, int, float, Variable, Rule, _ScopedOperand)
+            ):
                 raise TypeError(
                     type_error_message(
-                        f"Operand '{operand}'", operand, str, int, float, Variable, Rule
+                        f"Operand '{operand}'",
+                        operand,
+                        str,
+                        int,
+                        float,
+                        Variable,
+                        Rule,
+                        "upper-scoped Variable",
+                        "upper-scoped Rule",
                     )
                 )
         if not name:
@@ -1602,6 +1633,10 @@ def __repr__(self):
         self.write(writer)
         return str(stream.getvalue(), encoding="utf8", errors="replace")
 
+    def upper_scope(self):
+        """Adds the '.' upper-scope prefix to the serialization of the operand."""
+        return _ScopedOperand(self)
+
     def copy(self):
         """Copies this rule instance
 
@@ -1640,6 +1675,7 @@ def write(self, writer):
                     writer.write(f'"{operand}"')
                 elif isinstance(operand, float) and not math.isfinite(operand):
                     writer.write("#Missing")
+                # int, finite float or _ScopedOperand cases
                 else:
                     writer.write(str(operand))
                 if i < len(self.operands) - 1:

tests/test_core.py

@@ -1977,8 +1977,10 @@ def test_dictionary_rule_construction(self):
             "SomeRule()",
             'SomeRule("some_operand", 2)',
             'SomeRule("some_operand", 2, SomeVariable)',
+            'SomeRule("some_operand", 2, .SomeVariable)',
             'SomeRule("some_operand", #Missing)',
             'SomeRule("some_operand", 2, SomeEmbeddedRule("some_other_operand"))',
+            'SomeRule("some_operand", 2, .SomeEmbeddedRule("some_other_operand"))',
             (
                 'SomeRule("some_operand", 2, SomeEmbeddedRule("some_other_operand", '
                 'SomeOtherRule("some_embedded_operand", #Missing, 3)))'
@@ -2003,6 +2005,16 @@ def test_dictionary_rule_construction(self):
                     ),
                 ),
             ],
+            [
+                kh.Rule(
+                    "SomeRule",
+                    "some_operand",
+                    2,
+                    kh.Variable(
+                        json_data={"name": "SomeVariable", "type": "Categorical"}
+                    ).upper_scope(),
+                ),
+            ],
             [
                 kh.Rule("SomeRule", "some_operand", math.nan),
                 kh.Rule("SomeRule", "some_operand", float("inf")),
@@ -2023,6 +2035,14 @@ def test_dictionary_rule_construction(self):
                     )
                 ),
             ],
+            [
+                kh.Rule(
+                    "SomeRule",
+                    "some_operand",
+                    2,
+                    kh.Rule("SomeEmbeddedRule", "some_other_operand").upper_scope(),
+                ),
+            ],
             [
                 kh.Rule(
                     "SomeRule",