Enum: Use Functional API CPython instead of kwargs.

Signed-off-by: Ihor Nehrutsa <Ihor.Nehrutsa@gmail.com>

Author: IhorNehrutsa

python-stdlib/enum/enum.py

@@ -1,5 +1,5 @@
 # enum.py
-# version="1.2.2"
+# version="1.2.3"
 
 
 class EnumValue:
@@ -9,10 +9,10 @@ def __init__(self, value, name):
         object.__setattr__(self, 'name', name)
 
     def __repr__(self):
-        return f"<{self.name}: {self.value}>"
+        return f"{self.name}: {self.value}"
 
-    def __str__(self):
-        return str(self.value)
+#     def __str__(self):
+#         return str(self.value)
 
     def __call__(self):
         return self.value
@@ -22,34 +22,35 @@ def __eq__(self, other):
             return self.value == other.value
         return self.value == other
 
-    def __int__(self):
-        return self.value
+#     def __int__(self):
+#         return self.value
 
     def __setattr__(self, key, value):
         raise AttributeError("EnumValue is immutable")
 
 
 class Enum:
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, name=None, names=None):
         # Scenario 1: Reverse lookup by value (e.g., Status(1))
-        if len(args) == 1:
+        if name is not None and names is None:
             if cls is not Enum:
-                return cls._lookup(args[0])
-            return super(Enum, cls).__new__(cls)
-
-        # Scenario 2: Restriction on multiple positional arguments
-        elif len(args) > 1:
-            raise TypeError(f"{cls.__name__}() takes at most 1 positional argument ({len(args)} given)")
+                return cls._lookup(name)
 
-        # Scenario 3: Creating an instance (e.g. Color() або Color(BLUE=3))
+        # Scenario 2: Functional API (e.g., Enum('Color', {'RED': 1}))
         return super(Enum, cls).__new__(cls)
 
-    def __init__(self, **kwargs):
+    def __init__(self, name=None, names=None):
         # 1. Convert class-level attributes (constants) to EnumValue objects
         self._scan_class_attrs()
-        # 2. Add dynamic arguments from constructor
-        if kwargs:
-            self.append(**kwargs)
+
+        # Support Functional API: Enum('Name', {'KEY': VALUE})
+        if name is not None and isinstance(names, dict):
+            for key, value in names.items():
+                # Prevent addition if the key already exists
+                if not hasattr(self, key):
+                    self._update(key, value)
+
+        object.__setattr__(self, '_initialized', True)
 
     @classmethod
     def _lookup(cls, value):
@@ -63,7 +64,6 @@ def _lookup(cls, value):
             if not callable(attr) and attr == value:
                 # Wrap static numbers found in class definition
                 return EnumValue(attr, key)
-                return attr
 
         raise AttributeError(f"{value} is not in {cls.__name__} enum")
 
@@ -77,7 +77,7 @@ def _update(self, key, value):
     def _scan_class_attrs(self):
         # Converts static class attributes into EnumValue objects
         # List of methods and internal names that should not be converted
-        ignored = ('append', 'is_value', 'list_members')
+        ignored = ('is_value', 'list_members')
         for key in dir(self.__class__):
             # Skip internal names and methods
             if key.startswith('_') or key in ignored:
@@ -91,17 +91,13 @@ def _scan_class_attrs(self):
     def is_value(self, value):
         return any(member.value == value for member in self)
 
-    def append(self, **kwargs):
-        # Adds new members dynamically.
-        for key, value in kwargs.items():
-            if hasattr(self, key):
-                raise AttributeError(f"Enum key '{key}' is immutable")
-            self._update(key, value)
-
     def __repr__(self):
-        members = [f"{m.name}={m.value}" for m in self]
-        # Return a string like: Color(RED=1, GREEN=2, BLUE=3)
-        return f"{self.__class__.__name__}({', '.join(members)})"
+        # Supports the condition: obj == eval(repr(obj))
+        members = {m.name: m.value for m in self}
+        if self.__class__.__name__ == 'Enum':
+            return f"Enum(name='Enum', names={members})"
+        # Return a string like: Name(names={'KEY1': VALUE1, 'KEY2': VALUE2, ..})
+        return f"{self.__class__.__name__}(names={members})"
 
     def __call__(self, value):
         for member in self:
@@ -110,8 +106,8 @@ def __call__(self, value):
         raise ValueError(f"no such value: {value}")
 
     def __setattr__(self, key, value):
-        if hasattr(self, key) and isinstance(getattr(self, key), EnumValue):
-            raise AttributeError(f"Enum member '{key}' is immutable")
+        if hasattr(self, '_initialized'):
+            raise AttributeError(f"Enum '{self.__class__.__name__}' is static")
         super().__setattr__(key, value)
 
     def __delattr__(self, key):
@@ -128,58 +124,49 @@ def __iter__(self):
             if isinstance(attr, EnumValue):
                 yield attr
 
-
-def enum(**kwargs):  # `**kwargs` kept backwards compatible as in the Internet examples
-    return Enum(**kwargs)
+    def __eq__(self, other):
+        if not isinstance(other, Enum):
+            return False
+        return self.list_members() == other.list_members()
 
 
 if __name__ == '__main__':
     # --- Usage Example 1 ---
-    # 1. Creation via class
+    # Standard Class Definition
     class Color(Enum):
-        RED = 1
-        GREEN = 2
+        RED = 'red'
+        GREEN = 'green'
 
-    # 2. Create instance
+    # Create instance
     c = Color()
     print(f"Enum repr c: {c}")
 
-    # 3. Dynamic addition
-    c.append(BLUE=3)
-    print(f"c after append: {c}")
-
-    print('dir(c):', dir(c))
-
-    # 4. Immutability and name protection check
-    try:
-        c.append(append=True)
-    except AttributeError as e:
-        print(f"\nAttributeError: Reserved name protection: {e}\n")
-
-    # 5. Basic access
+    # Basic access
     print(f"RED: Name={c.RED.name}, Value={c.RED.value}, EnumValue={c.RED}, Call={c.RED()} ")
 
-    # 6. Assertions
-    assert c.RED == 1
-    assert c.RED.value == 1
+    # Assertions
     assert c.RED.name == 'RED'
+    assert c.RED.value == 'red'
+    assert c.RED == 'red'
+    assert c.RED() == 'red'
 
-    # 7. Reverse lookup
-    print(f"c(1) lookup object: {c(1)}, Name={c(1).name}")  # RED
-    assert c(1).name == 'RED'
-    assert c(1) == 1
+    # Reverse Lookup via instance call
+    print(f"c('red') lookup object: {c('red')}, Name={c('red').name}, value={c('red').value}")  # RED
+    assert c('red').name == 'RED'
+    assert c('red').value == 'red'
+    assert c('red') == 'red'
 
-    # 8. Iteration
+    # Iteration
     print("Values list:", [member.value for member in c])
     print("Names list:", [member.name for member in c])
 
     try:
-        c(7)
+        c(999)
     except ValueError as e:
         print(f"\nValueError: {c} {e}\n")
 
     # --- Usage Example 2 ---
-    # 1. Define an Enum class
+    # Define an Enum class
     class Status(Enum):
         IDLE = 0
         RUNNING = 1
@@ -189,38 +176,48 @@ class Status(Enum):
     # This simulates receiving a byte from the  hardware
     received_byte = 1
     status = Status(received_byte)
-    print(f"Lookup check: Received {received_byte} -> {status!r}")
+    print(f"Lookup check: Received {received_byte} -> {status}")
     assert status == Status.RUNNING
     assert status.name == "RUNNING"
 
-    # 3. Test: Comparisons
+    # Test: Comparisons
     print(f"Comparison check: {status} == 1 is {status == 1}")
     assert status == 1
     assert status != 0
     assert status == Status.RUNNING
 
-    # 4. Test: Immutability
+    # Immutability Check
     try:
-        Status.RUNNING.value = 99
+        Status.RUNNING.value = 999
     except AttributeError as e:
         print(f"\nImmutability check: Passed (Cannot modify EnumValue): {e}\n")
 
-    # 5. Test: Dynamic Append
-    powers = Enum()
-    powers.append(LOW=10, HIGH=100)
-    print(f"Dynamic Enum check: {powers}")
-    assert powers.LOW == 10
-
-    # 6. Test: Iteration
+    # Test: Iteration
     print("Iteration check: ", end="")
     for m in Status():
         print(f"{m.name}, ", end="")
     print("-> Passed")
 
-    # 7. Test: Error handling for invalid lookup
+    # Test: Error handling for invalid lookup
     try:
-        Status(99)
+        Status(999)
     except AttributeError as e:
         print(f"\nAttributeError: Invalid lookup check: Caught expected error -> {e}\n")
 
+    # --- Example 3: Functional API and serialization ---
+    print("\n--- Functional API and Eval Check ---")
+
+    # Verify that eval(repr(obj)) restores the object
+    c2 = eval(repr(c))
+    print(f"Original: {repr(c)}")
+    print(f"Restored: {repr(c2)}")
+    print(f"Objects are equal: {c == c2}")
+    assert c == c2
+
+    # Direct creation using the Enum base class
+    state = eval("Enum(name='State', names={'ON':1, 'OFF':2})")
+    print(f"Functional Enum instance (state): {state}")
+    assert state.ON == 1
+    assert state.ON.name == 'ON'
+
     print("\nAll tests passed successfully!")

python-stdlib/enum/test_enum.py

@@ -1,7 +1,8 @@
+# test_enum.py
 # version="1.2.1"
 
 import unittest
-from enum import Enum, EnumValue, enum
+from enum import Enum, EnumValue
 
 
 class TestEnum(unittest.TestCase):
@@ -21,18 +22,6 @@ def test_class_attributes(self):
         self.assertEqual(self.color.RED.name, 'RED')
         self.assertIsInstance(self.color.RED, EnumValue)
 
-    def test_init_kwargs(self):
-        """Тест додавання значень через конструктор __init__(**kwargs)"""
-        c = self.ColorClass(YELLOW=4, BLACK=0)
-        self.assertEqual(c.YELLOW.value, 4)
-        self.assertEqual(c.BLACK.name, 'BLACK')
-
-    def test_append(self):
-        """Тест методу append(**kwargs) та ланцюжкового виклику"""
-        self.color.append(MAGENTA=5).append(CYAN=6)
-        self.assertEqual(self.color.MAGENTA.value, 5)
-        self.assertEqual(self.color.CYAN.name, 'CYAN')
-
     def test_comparison(self):
         """Тест порівняння EnumValue з числами та іншими об'єктами"""
         self.assertTrue(self.color.RED == 1)
@@ -80,14 +69,6 @@ def test_enum_value_immutability(self):
     def test_len(self):
         """Тест магічного методу __len__"""
         self.assertEqual(len(self.color), 3)
-        self.color.append(WHITE=7)
-        self.assertEqual(len(self.color), 4)
-
-    def test_backwards_compatible_function(self):
-        """Тест глобальної функції enum(**kwargs)"""
-        e = enum(A=10, B=20)
-        self.assertEqual(e.A.value, 10)
-        self.assertEqual(e.B.name, 'B')
 
     def test_call_method(self):
         """Тест виклику об'єкта як функції c.RED() -> 1"""