enum: Fix obj==eval(repr(obj)).

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

Author: IhorNehrutsa

python-stdlib/enum/enum.py

@@ -1,147 +1,120 @@
 # enum.py
-# version="1.2.4"
+# version="1.2.5"
 
 
 class EnumValue:
     # An immutable object representing a specific enum member
-    def __init__(self, value, name):
-        object.__setattr__(self, "value", value)
-        object.__setattr__(self, "name", name)
+    def __init__(self, v, n):
+        object.__setattr__(self, "value", v)
+        object.__setattr__(self, "name", n)
 
     def __repr__(self):
         return f"{self.name}: {self.value}"
 
     def __call__(self):
         return self.value
 
-    def __eq__(self, other):
-        if isinstance(other, EnumValue):
-            return self.value == other.value
-        return self.value == other
+    def __eq__(self, o):
+        return self.value == (o.value if isinstance(o, EnumValue) else o)
 
-    def __setattr__(self, key, value):
+    def __setattr__(self, k, v):
         raise AttributeError("EnumValue is immutable")
 
 
 class Enum:
     def __new__(cls, name=None, names=None):
-        # Scenario 1: Reverse lookup by value (e.g., Status(1))
-        if name is not None and names is None:
-            if cls is not Enum:
-                return cls._lookup(name)
-
-        # Scenario 2: Functional API (e.g., Enum("Color", {"RED": 1}))
-        return super(Enum, cls).__new__(cls)
+        # If a name and names are provided, create a NEW subclass of Enum
+        if name and names:
+            # Support Functional API: Enum("Name", {"KEY": VALUE})
+            # Dynamically create: class <name>
+            new_cls = type(name, (cls, ), {})
+            for k, v in names.items():
+                new_cls._up(k, v)
+            new_cls._inited = True
+            return super().__new__(new_cls)
+
+        # Reverse lookup by value or name (e.g., Color(1) or Color("RED"))
+        if name and not names and cls is not Enum:
+            return cls._lookup(name)
+
+        return super().__new__(cls)
 
     def __init__(self, name=None, names=None):
-        if hasattr(self, "_initialized"):
-            return
-
-        # 1. Convert class-level attributes (constants) to EnumValue objects
-        self._scan_class_attrs()
-
-        # 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)
+        if "_inited" not in self.__class__.__dict__:
+            self._scan()
 
     @classmethod
-    def _lookup(cls, value):
-        # Finds an EnumValue by its raw value
-        for key in dir(cls):
-            if key.startswith("_"):
-                continue
-            attr = getattr(cls, key)
-            if isinstance(attr, EnumValue) and (attr.value == value or attr.name == value):
-                return attr
-            if not callable(attr) and attr == value:
-                # Wrap static numbers found in class definition
-                return EnumValue(attr, key)
-        raise AttributeError(f"{value} is not in {cls.__name__}")
+    def _lookup(cls, v):
+        if "_inited" not in cls.__dict__:
+            cls._scan()
+
+        # Finds an EnumValue by its raw value or name
+        for k in dir(cls):
+            a = getattr(cls, k)
+            if isinstance(a, EnumValue) and (a.value == v or a.name == v):
+                return a
+        raise AttributeError(f"{v} is not in {cls.__name__}")
 
     @classmethod
     def __iter__(cls):
-        if "_initialized" not in cls.__dict__:
-            cls._scan_class_attrs()
-            setattr(cls, "_initialized", True)
-
-        for key in dir(cls):
-            if key.startswith("_"):
-                continue
-            attr = getattr(cls, key)
+        if "_inited" not in cls.__dict__:
+            cls._scan()
+
+        for k in dir(cls):
+            attr = getattr(cls, k)
             if isinstance(attr, EnumValue):
                 yield attr
 
     @classmethod
     def list(cls):
-        if "_initialized" not in cls.__dict__:
-            cls._scan_class_attrs()
-            setattr(cls, "_initialized", True)
+        if "_inited" not in cls.__dict__:
+            cls._scan()
 
         # Returns a list of all members
-        return [getattr(cls, key) for key in dir(cls) if isinstance(getattr(cls, key), EnumValue)]
+        return [getattr(cls, k) for k in dir(cls) if isinstance(getattr(cls, k), EnumValue)]
 
     @classmethod
-    def _update(cls, key, value):
-        setattr(cls, key, EnumValue(value, key))
+    def _up(cls, k, v):
+        setattr(cls, k, EnumValue(v, k))
 
     @classmethod
-    def _scan_class_attrs(cls):
-        # Converts static class attributes into EnumValue objects
-        # List of methods and internal names that should not be converted
-        ignored = ("is_value", "list")
-        for key in dir(cls):
-            # Skip internal names and methods
-            if key.startswith("_") or key in ignored:
-                continue
-
-            value = getattr(cls, key)
-            # Convert only constants, not methods
-            if not callable(value) and not isinstance(value, EnumValue):
-                cls._update(key, value)
-
-    def is_value(self, value):
-        return any(member.value == value for member in self)
+    def _scan(cls):
+        # Convert class-level attributes (constants) to EnumValue objects
+        for k, v in list(cls.__dict__.items()):
+            if not k.startswith("_") and not callable(v) and not isinstance(v, EnumValue):
+                cls._up(k, v)
+        cls._inited = True
+
+    def is_value(self, v):
+        return any(m.value == v for m in self)
 
     def __repr__(self):
         # Supports the condition: obj == eval(repr(obj))
-        members = {member.name: member.value for member 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):
-        if not hasattr(self, "_initialized"):
-            self._scan_class_attrs()
-            object.__setattr__(self, "_initialized", True)
-
-        for member in self:
-            if member.value == value or member.name == value:
-                return member
-        raise AttributeError(f"{value} is not in {self.__class__.__name__}")
-
-    def __setattr__(self, key, value):
-        if hasattr(self, "_initialized"):
-            raise AttributeError(f"Enum '{self.__class__.__name__}' is static")
-        super().__setattr__(key, value)
-
-    def __delattr__(self, key):
-        if hasattr(self, key) and isinstance(getattr(self, key), EnumValue):
-            raise AttributeError("Enum members cannot be deleted")
-        super().__delattr__(key)
+        d = {m.name: m.value for m in self}
+        # Return a string like: Enum(name='Name', names={'KEY1': VALUE1, 'KEY2': VALUE2, ..})
+        return f"Enum(name='{self.__class__.__name__}', names={d})"
+
+    def __call__(self, v):
+        if "_inited" in self.__class__.__dict__:
+            self._scan()
+
+        return self._lookup(v)
+
+    def __setattr__(self, k, v):
+        if "_inited" in self.__class__.__dict__:
+            raise AttributeError(f"Enum '{self.__class__.__name__}' is immutable")
+        super().__setattr__(k, v)
+
+    def __delattr__(self, k):
+        raise AttributeError("Enum is immutable")
 
     def __len__(self):
         return sum(1 for _ in self)
 
-    def __eq__(self, other):
-        if not isinstance(other, Enum):
+    def __eq__(self, o):
+        if not isinstance(o, Enum):
             return False
-        return self.list() == other.list()
+        return self.list() == o.list()
 
 
 if __name__ == "__main__":
@@ -151,15 +124,14 @@ class Color(Enum):
         RED = 1
         GREEN = 2
         BLUE = 3
-        
+
     print("Color.list():", Color.list())
-    print("Color().list():", Color().list())
-    
+
     # Iteration
     print("Members list:", [member for member in Color()])
     print("Names list:", [member.name for member in Color()])
     print("Values list:", [member.value for member in Color()])
-    
+
     # Create instance
     c = Color()
     print(f"Enum c: {c}")
@@ -174,15 +146,11 @@ class Color(Enum):
     assert c.RED() == 1
 
     # Reverse Lookup via instance call
-    print(f"c(1) lookup object: {c(1)}, Name={c(1).name}, value={c(1).value}")  # RED
+    print(f"c(1) lookup object: {c(1)}, name={c(1).name}, value={c(1).value}")  # RED
     assert c(1).name == "RED"
     assert c(1).value == 1
     assert c(1) == 1
 
-    # Iteration
-    print("Values list:", [member.value for member in c])
-    print("Names list:", [member.name for member in c])
-
     try:
         c(999)
     except AttributeError as e:
@@ -200,14 +168,15 @@ class Status(Enum):
     received_byte = 1
     status = Status(received_byte)
     print(f"Lookup check: Received {received_byte} -> {status}")
+    assert status == received_byte
     assert status == Status.RUNNING
     assert status.name == "RUNNING"
+    assert status.value == received_byte
 
     # Test: Comparisons
     print(f"Comparison check: {status} == 1 is {status == 1}")
     assert status == 1
     assert status != 0
-    assert status == Status.RUNNING
 
     # Immutability Check
     try:
@@ -228,19 +197,75 @@ class Status(Enum):
         print(f"\nAttributeError: Invalid lookup check: Caught expected error -> {e}\n")
 
     # --- Example 3: Functional API and serialization ---
-    print("\n--- Functional API and Eval Check ---")
+    print("--- 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
+    c_repr = repr(c)
+    c_restored = eval(c_repr)
+    print(f"Original: {c_repr}")
+    print(f"Restored: {repr(c_restored)}")
+    print(f"Objects are equal: {c == c_restored}")
+    assert c == c_restored
 
     # Direct creation using the Enum base class
     state = eval("Enum(name='State', names={'ON':1, 'OFF':2})")
     print(f"Functional Enum instance (state): {state}")
+    print(type(state))
     assert state.ON == 1
     assert state.ON.name == "ON"
 
+    # --- 1. Unique Data Types & Class Methods ---
+    # Enums can hold more than just integers; here we use strings and add a method.
+    class HttpMethod(Enum):
+        GET = "GET"
+        POST = "POST"
+        DELETE = "DELETE"
+
+        def is_safe(self):
+            # Demonstrates that custom logic can coexist with Enum members
+            return self.list()[0] == self.GET  # Simplistic example check
+
+    api_call = HttpMethod()
+    print(f"Member with string value: {api_call.GET}")
+    assert api_call.GET == "GET"
+
+    # --- 2. Advanced Reverse Lookup Scenarios ---
+    # Demonstrates lookup by both name string and raw value string.
+    print(f"Lookup by value 'POST': {api_call('POST')}")
+    print(f"Lookup by name 'DELETE': {api_call('DELETE')}")
+    assert api_call("GET").name == "GET"
+
+    # --- 3. Empty Enum Handling ---
+    # Verifies behavior when no members are defined.
+    class Empty(Enum):
+        pass
+
+    empty_inst = Empty()
+    print(f"Empty Enum list: {empty_inst.list()}")
+    assert len(empty_inst) == 0
+
+    # --- 4. Deep Functional API & Serialization ---
+    # Testing complex name strings and verifying the 'eval' round-trip for functional enums.
+    complex_enum = Enum(name='Config', names={'MAX_RETRY': 5, 'TIMEOUT_SEC': 30})
+
+    # Verify serialization maintains the dynamic class name
+    repr_str = repr(complex_enum)
+    restored = eval(repr_str)
+
+    print(f"Restored Functional Enum: {restored}")
+    assert restored.MAX_RETRY == 5
+    assert type(restored).__name__ == 'Config'
+
+    # --- 5. Immutability & Integrity Guard ---
+    # Ensuring the Enum structure cannot be tampered with after creation.
+    try:
+        api_call.NEW_METHOD = "PATCH"
+    except AttributeError as e:
+        print(f"Caught expected mutation error: {e}")
+
+    try:
+        del api_call.GET
+    except AttributeError as e:
+        print(f"Caught expected deletion error: {e}")
+
     print("\nAll tests passed successfully!")