Add support for reference rules

A reference rule has the form ``(Op1, Op2, ..., Opn)`` and is serialized
as ``[Op1, Op2, ..., Opn]``. Its name does not matter.

Author: popescu-v

khiops/core/dictionary.py

@@ -1581,11 +1581,6 @@ class Rule:
               parenthesized block (...)
             - ``operands`` is empty
 
-        It is intepreted as a reference rule if and only if:
-
-            - the first condition above does *not* apply
-            - the second condition above applies
-
     operands : tuple of operands
         Each operand can have one of the following types:
 
@@ -1596,11 +1591,10 @@ class Rule:
             - ``Variable``
             - ``Rule``
 
-        If no operand is specified, then the rule is:
-
-            - a standard rule if ``name`` is the verbatim representation of an
-              entire rule
-            - a reference rule if ``name`` does not satisfy the condition above
+    is_reference : bool, default ``False``
+        If set to ``True``, then the rule is serialized as a reference rule:
+        ``Rule(Operand1, Operand2, ...)`` is serialized as
+        ``[Operand1, Operand2, ...]``.
 
     Attributes
     ----------
@@ -1615,9 +1609,15 @@ class Rule:
             - float
             - ``Variable``
             - ``Rule``
+
+    is_reference : bool
+        The reference status of the rule.
+
+        .. note::
+            This attribute cannot be changed on a `Rule` instance.
     """
 
-    def __init__(self, name, *operands):
+    def __init__(self, name, *operands, is_reference=False):
         """See class docstring"""
         # Check input parameters
         if not is_string_like(name):
@@ -1639,12 +1639,19 @@ def __init__(self, name, *operands):
                         "upper-scoped Rule",
                     )
                 )
-        if not name:
+        if not isinstance(is_reference, bool):
+            raise TypeError(type_error_message("is_reference", is_reference, bool))
+        if not is_reference and not name:
             raise ValueError("'name' must be a non-empty string")
 
         # Initialize attributes
         self.name = name
         self.operands = operands
+        self._is_reference = is_reference
+
+    @property
+    def is_reference(self):
+        return self._is_reference
 
     def __repr__(self):
         stream = io.BytesIO()
@@ -1673,21 +1680,24 @@ def write(self, writer):
         ----------
         writer : `.KhiopsOutputWriter`
             Output writer.
+
+        .. note::
+            If ``self.is_reference`` is set, then ``self.name`` is not included in the serialization.
         """
         # Check the type of the writer
         if not isinstance(writer, KhiopsOutputWriter):
             raise TypeError(type_error_message("writer", writer, KhiopsOutputWriter))
 
         # Write standard rule
-        rule_pattern = r"^[A-Z]([a-zA-Z]*)\(.*\)"
+        rule_pattern = r"^[A-Z]([a-zA-Z]*)\(?.*\)?$"
         rule_regex = re.compile(rule_pattern)
         bytes_rule_regex = re.compile(bytes(rule_pattern, encoding="ascii"))
         if self.operands:
-            if isinstance(self.name, str):
-                writer.write(f"{_format_name(self.name)}(")
+            if self.is_reference:
+                writer.write("[")
             else:
-                assert isinstance(self.name, bytes)
-                writer.write(f"{_format_name(self.name).decode('ascii')}(")
+                writer.write(_format_name(self.name))
+                writer.write("(")
 
             # Write operand, according to its type
             # Variable operands have their name written only
@@ -1705,7 +1715,10 @@ def write(self, writer):
                     writer.write(str(operand))
                 if i < len(self.operands) - 1:
                     writer.write(", ")
-            writer.write(")")
+            if self.is_reference:
+                writer.write("]")
+            else:
+                writer.write(")")
         # Write verbatim-given rule
         elif (
             isinstance(self.name, str)
@@ -1714,11 +1727,6 @@ def write(self, writer):
             and bytes_rule_regex.match(self.name)
         ):
             writer.write(self.name)
-        # Write rule as a reference rule
-        else:
-            writer.write("[")
-            writer.write(self.name)
-            writer.write("]")
 
 
 class MetaData:

tests/test_core.py

@@ -1978,8 +1978,8 @@ def test_dictionary_accessors(self):
     def test_dictionary_rule_construction(self):
         """Tests the Rule construction and serialization"""
         rule_verbatims = [
-            "SomeRule()",
-            b"SomeRule()",
+            "SomeRule",
+            b"SomeRule",
             'SomeRule("some_operand", 2)',
             b'SomeRule("some_operand", 2)',
             'SomeRule("some""operand", 2)',
@@ -2000,17 +2000,19 @@ def test_dictionary_rule_construction(self):
                 'SomeRule("some_operand", 2, SomeEmbeddedRule("some_other_operand", '
                 'SomeOtherRule("some_embedded_operand", #Missing, 3)))'
             ),
-            "[SomeReferenceRule]",
-            b"[SomeReferenceRule]",
+            '["some_reference_operand"]',
+            b'["some_reference_operand"]',
+            '["some_reference_operand", SomeReferenceVariable]',
+            b'["some_reference_operand", SomeReferenceVariable]',
             (
                 b'SomeRule("som\xe9_operand", 2, '
                 b'SomeEmbeddedRule("som\xe9_other_operand"))'
             ),
         ]
 
         rules = [
-            [kh.Rule("SomeRule()")],
-            [kh.Rule(b"SomeRule()")],
+            [kh.Rule("SomeRule")],
+            [kh.Rule(b"SomeRule")],
             [
                 kh.Rule("SomeRule", "some_operand", 2),
                 kh.Rule('SomeRule("some_operand", 2)'),
@@ -2156,7 +2158,34 @@ def test_dictionary_rule_construction(self):
                     ),
                 )
             ],
-            [kh.Rule("SomeReferenceRule")],
+            [kh.Rule("", "some_reference_operand", is_reference=True)],
+            [kh.Rule(b"", b"some_reference_operand", is_reference=True)],
+            [
+                kh.Rule(
+                    "",
+                    "some_reference_operand",
+                    kh.Variable(
+                        json_data={
+                            "name": "SomeReferenceVariable",
+                            "type": "Categorical",
+                        }
+                    ),
+                    is_reference=True,
+                )
+            ],
+            [
+                kh.Rule(
+                    b"",
+                    b"some_reference_operand",
+                    kh.Variable(
+                        json_data={
+                            "name": b"SomeReferenceVariable",
+                            "type": "Categorical",
+                        }
+                    ),
+                    is_reference=True,
+                )
+            ],
         ]
 
         for rule_list, rule_verbatim in zip(rules, rule_verbatims):