Add support for byte-formatted Rule

Author: popescu-v

khiops/core/dictionary.py

@@ -88,13 +88,19 @@ def __init__(self, operand):
         )
         self.operand = operand
 
-    def __repr__(self):
-        stream = io.BytesIO()
-        writer = KhiopsOutputWriter(stream)
+    def write(self, writer):
+        assert isinstance(writer, KhiopsOutputWriter), type_error_message(
+            "writer", writer, KhiopsOutputWriter
+        )
         if isinstance(self.operand, Variable):
             writer.write(_format_name(self.operand.name))
         else:
             self.operand.write(writer)
+
+    def __repr__(self):
+        stream = io.BytesIO()
+        writer = KhiopsOutputWriter(stream)
+        self.write(writer)
         return "." + str(stream.getvalue(), encoding="utf8", errors="replace")
 
 
@@ -1556,7 +1562,7 @@ class Rule:
 
     Parameters
     ----------
-    name : str
+    name : str or bytes
         Name or verbatim of the rule. It is intepreted as the verbatim
         representation of an entire rule if and only if:
 
@@ -1573,6 +1579,7 @@ class Rule:
         Each operand can have one of the following types:
 
             - str
+            - bytes
             - int
             - float
             - ``Variable``
@@ -1586,12 +1593,13 @@ class Rule:
 
     Attributes
     ----------
-    name : str
+    name : str or bytes
         Name of the rule.
     operands : tuple of operands
         Each operand has one of the following types:
 
             - str
+            - bytes
             - int
             - float
             - ``Variable``
@@ -1601,17 +1609,17 @@ class Rule:
     def __init__(self, name, *operands):
         """See class docstring"""
         # Check input parameters
-        if not isinstance(name, str):
-            raise TypeError(type_error_message("name", name, str))
+        if not is_string_like(name):
+            raise TypeError(type_error_message("name", name, "string-like"))
         for operand in operands:
-            if not isinstance(
-                operand, (str, int, float, Variable, Rule, _ScopedOperand)
+            if not is_string_like(operand) and not isinstance(
+                operand, (int, float, Variable, Rule, _ScopedOperand)
             ):
                 raise TypeError(
                     type_error_message(
                         f"Operand '{operand}'",
                         operand,
-                        str,
+                        "string-like",
                         int,
                         float,
                         Variable,
@@ -1660,9 +1668,15 @@ def write(self, writer):
             raise TypeError(type_error_message("writer", writer, KhiopsOutputWriter))
 
         # Write standard rule
-        rule_regex = re.compile(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:
-            writer.write(f"{_format_name(self.name)}(")
+            if isinstance(self.name, str):
+                writer.write(f"{_format_name(self.name)}(")
+            else:
+                assert isinstance(self.name, bytes)
+                writer.write(f"{_format_name(self.name).decode('ascii')}(")
 
             # Write operand, according to its type
             # Variable operands have their name written only
@@ -1673,6 +1687,8 @@ def write(self, writer):
                     writer.write(_format_name(operand.name))
                 elif isinstance(operand, str):
                     writer.write(f'"{operand}"')
+                elif isinstance(operand, bytes):
+                    writer.write(f'"{operand.decode("ascii")}"')
                 elif isinstance(operand, float) and not math.isfinite(operand):
                     writer.write("#Missing")
                 # int, finite float or _ScopedOperand cases
@@ -1682,11 +1698,17 @@ def write(self, writer):
                     writer.write(", ")
             writer.write(")")
         # Write verbatim-given rule
-        elif rule_regex.match(self.name):
+        elif isinstance(self.name, str) and rule_regex.match(self.name):
             writer.write(self.name)
+        elif isinstance(self.name, bytes) and bytes_rule_regex.match(self.name):
+            writer.write(self.name.decode(encoding="ascii"))
         # Write rule as a reference rule
         else:
-            writer.write(f"[{self.name}]")
+            if isinstance(self.name, str):
+                writer.write(f"[{self.name}]")
+            else:
+                assert isinstance(self.name, bytes)
+                writer.write(f"[{self.name.decode('ascii')}]")
 
 
 class MetaData:

tests/test_core.py

@@ -1975,25 +1975,36 @@ def test_dictionary_rule_construction(self):
         """Tests the Rule construction and serialization"""
         rule_verbatims = [
             "SomeRule()",
+            b"SomeRule()",
             'SomeRule("some_operand", 2)',
+            b'SomeRule("some_operand", 2)',
             'SomeRule("some_operand", 2, SomeVariable)',
             'SomeRule("some_operand", 2, .SomeVariable)',
+            b'SomeRule("some_operand", 2, .SomeVariable)',
             'SomeRule("some_operand", #Missing)',
+            b'SomeRule("some_operand", #Missing)',
             'SomeRule("some_operand", 2, SomeEmbeddedRule("some_other_operand"))',
+            b'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)))'
             ),
             "[SomeReferenceRule]",
+            b"[SomeReferenceRule]",
         ]
 
         rules = [
             [kh.Rule("SomeRule()")],
+            [kh.Rule(b"SomeRule()")],
             [
                 kh.Rule("SomeRule", "some_operand", 2),
                 kh.Rule('SomeRule("some_operand", 2)'),
             ],
+            [
+                kh.Rule(b"SomeRule", b"some_operand", 2),
+                kh.Rule(b'SomeRule("some_operand", 2)'),
+            ],
             [
                 kh.Rule('SomeRule("some_operand", 2, SomeVariable)'),
                 kh.Rule(
@@ -2015,12 +2026,28 @@ def test_dictionary_rule_construction(self):
                     ).upper_scope(),
                 ),
             ],
+            [
+                kh.Rule(
+                    b"SomeRule",
+                    b"some_operand",
+                    2,
+                    kh.Variable(
+                        json_data={"name": b"SomeVariable", "type": b"Categorical"}
+                    ).upper_scope(),
+                ),
+            ],
             [
                 kh.Rule("SomeRule", "some_operand", math.nan),
                 kh.Rule("SomeRule", "some_operand", float("inf")),
                 kh.Rule("SomeRule", "some_operand", float("-inf")),
                 kh.Rule('SomeRule("some_operand", #Missing)'),
             ],
+            [
+                kh.Rule(b"SomeRule", b"some_operand", math.nan),
+                kh.Rule(b"SomeRule", b"some_operand", float("inf")),
+                kh.Rule(b"SomeRule", b"some_operand", float("-inf")),
+                kh.Rule(b'SomeRule("some_operand", #Missing)'),
+            ],
             [
                 kh.Rule(
                     "SomeRule",
@@ -2035,6 +2062,20 @@ def test_dictionary_rule_construction(self):
                     )
                 ),
             ],
+            [
+                kh.Rule(
+                    b"SomeRule",
+                    b"some_operand",
+                    2,
+                    kh.Rule(b"SomeEmbeddedRule", b"some_other_operand"),
+                ),
+                kh.Rule(
+                    (
+                        b'SomeRule("some_operand", 2, '
+                        b'SomeEmbeddedRule("some_other_operand"))'
+                    )
+                ),
+            ],
             [
                 kh.Rule(
                     "SomeRule",
@@ -2060,7 +2101,11 @@ def test_dictionary_rule_construction(self):
 
         for rule_list, rule_verbatim in zip(rules, rule_verbatims):
             for rule in rule_list:
-                self.assertEqual(repr(rule), rule_verbatim)
+                if isinstance(rule_verbatim, str):
+                    self.assertEqual(repr(rule), rule_verbatim)
+                else:
+                    self.assertTrue(isinstance(rule_verbatim, bytes))
+                    self.assertEqual(bytes(repr(rule), encoding="ascii"), rule_verbatim)
 
     def test_dictionary_extract_data_paths(self):
         """Tests the extract_data_paths Dictionary method"""