enum: Version 1.3.0.

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

Author: IhorNehrutsa

python-stdlib/enum/enum.md

@@ -170,10 +170,10 @@ print(Color.GREEN.value, type(Color.GREEN.value))
 
 | MicroPython v1.28.0  |  Python 3.12.10  |
 |   :---   |   :---  |
-| [RED: 1, GREEN: 2, BLUE: 3] | [<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>] |
-| GREEN: 2 <class 'EnumValue'> | Color.GREEN <enum 'Color'> |
-| GREEN: 2 | Color.GREEN |
-| GREEN: 2 | Color.GREEN |
+| [Color.RED: 1, Color.GREEN: 2, Color.BLUE: 3] | [<Color.RED: 1>, <Color.GREEN: 2>, <Color.BLUE: 3>] |
+| Color.GREEN: 2 <class 'EnumValue'> | Color.GREEN <enum 'Color'> |
+| Color.GREEN: 2 | Color.GREEN |
+| Color.GREEN: 2 | Color.GREEN |
 | GREEN <class 'str'> | GREEN <class 'str'> |
 | 2 <class 'int'> | 2 <class 'int'> |
 

python-stdlib/enum/enum.py

@@ -1,204 +1,77 @@
 # enum.py
-# version="1.2.6"
+# version="1.3.0"
 
 
-class EnumValue:
-    # An immutable object representing a specific enum member
-    def __init__(self, v, n):
-        object.__setattr__(self, "value", v)
-        object.__setattr__(self, "name", n)
+def _make_enum(v, n, e):
+    T = type(v)
 
-    def __repr__(self):
-        return f"{self.name}: {self.value}"
-
-    def __call__(self):
-        return self.value
-
-    def __setattr__(self, k, v):
+    def _setattr(self, k, v):
         raise AttributeError("EnumValue is immutable")
 
-    # Helper function to extract the raw value
-    def _get_value(self, o):
-        return o.value if isinstance(o, EnumValue) else o
-
-    # Arithmetic and Bitwise operations (Forward)
-    def __add__(self, o):
-        return self.value + self._get_value(o)
-
-    def __sub__(self, o):
-        return self.value - self._get_value(o)
-
-    def __mul__(self, o):
-        return self.value * self._get_value(o)
-
-    def __truediv__(self, o):
-        return self.value / self._get_value(o)
-
-    def __floordiv__(self, o):
-        return self.value // self._get_value(o)
-
-    def __mod__(self, o):
-        return self.value % self._get_value(o)
-
-    def __pow__(self, o):
-        return self.value ** self._get_value(o)
-
-    def __and__(self, o):
-        return self.value & self._get_value(o)
-
-    def __or__(self, o):
-        return self.value | self._get_value(o)
-
-    def __xor__(self, o):
-        return self.value ^ self._get_value(o)
-
-    def __lshift__(self, o):
-        return self.value << self._get_value(o)
-
-    def __rshift__(self, o):
-        return self.value >> self._get_value(o)
-
-    # Arithmetic and Bitwise operations (Reflected)
-    def __radd__(self, o):
-        return self._get_value(o) + self.value
-
-    def __rsub__(self, o):
-        return self._get_value(o) - self.value
-
-    def __rmul__(self, o):
-        return self._get_value(o) * self.value
-
-    def __rtruediv__(self, o):
-        return self._get_value(o) / self.value
-
-    def __rfloordiv__(self, o):
-        return self._get_value(o) // self.value
-
-    def __rand__(self, o):
-        return self._get_value(o) & self.value
-
-    def __ror__(self, o):
-        return self._get_value(o) | self.value
-
-    def __rxor__(self, o):
-        return self._get_value(o) ^ self.value
-
-    def __rlshift__(self, o):
-        return self._get_value(o) << self.value
-
-    def __rrshift__(self, o):
-        return self._get_value(o) >> self.value
-
-    # Unary operators
-    def __neg__(self):
-        return -self.value
-
-    def __pos__(self):
-        return +self.value
-
-    def __abs__(self):
-        return abs(self.value)
-
-    def __invert__(self):
-        return ~self.value
-
-    # Comparison
-    def __eq__(self, o):
-        return self.value == self._get_value(o)
-
-    def __lt__(self, o):
-        return self.value < self._get_value(o)
-
-    def __le__(self, o):
-        return self.value <= self._get_value(o)
-
-    def __gt__(self, o):
-        return self.value > self._get_value(o)
-
-    def __ge__(self, o):
-        return self.value >= self._get_value(o)
-
-    def __ne__(self, o):
-        return self.value != self._get_value(o)
+    # Create class: type(name, bases, dict), which inherits a base type (int, str, etc.)
+    return type("EnumValue", (T,), {
+        "name": n,
+        "value": v,
+        "__repr__": lambda s: f"{e}.{n}: {s.value}",
+        "__str__": lambda s: f"{e}.{n}: {s.value}",
+        "__call__": lambda s: v,
+        "__setattr__": _setattr
+    })(v)
 
 
 class Enum:
     def __new__(cls, name=None, names=None):
         # If a name and names are provided, create a NEW subclass of Enum
         if name and names:
-            # Support Functional API: Enum("Name", {"KEY": VALUE})
+            # Support Functional API: Enum("Name", {"KEY1": VALUE1, "KEY2": VALUE2, ..})
             # Dynamically create: class <name>
-            new_cls = type(name, (cls,), {})
+            new_cls = type(name, (cls,), {"_inited": True})
             for k, v in names.items():
-                new_cls._up(k, v)
-            new_cls._inited = True
+                setattr(new_cls, k, _make_enum(v, k, name))
             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:
+        if name and cls is not Enum:
             return cls._lookup(name)
 
         return super().__new__(cls)
 
     def __init__(self, name=None, names=None):
         if "_inited" not in self.__class__.__dict__:
-            self._scan()
+            self.list()
 
     @classmethod
     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
+        for m in cls.list():
+            if m.value == v or m.name == v:
+                return m
         raise AttributeError(f"{v} is not in {cls.__name__}")
 
     @classmethod
     def __iter__(cls):
-        if "_inited" not in cls.__dict__:
-            cls._scan()
-
-        for k in dir(cls):
-            attr = getattr(cls, k)
-            if isinstance(attr, EnumValue):
-                yield attr
+        return iter(cls.list())
 
     @classmethod
     def list(cls):
         if "_inited" not in cls.__dict__:
-            cls._scan()
-
-        # Returns a list of all members
-        return [getattr(cls, k) for k in dir(cls) if isinstance(getattr(cls, k), EnumValue)]
+            # Copy dict.items() to avoid RuntimeError when changing the dictionary
+            for k, v in list(cls.__dict__.items()):
+                if not k.startswith("_") and not callable(v):
+                    setattr(cls, k, _make_enum(v, k, cls.__name__))
+            cls._inited = True
+        return [m for k in dir(cls) if not k.startswith("_") and hasattr(m := getattr(cls, k), "name")]
 
     @classmethod
-    def _up(cls, k, v):
-        setattr(cls, k, EnumValue(v, k))
-
-    @classmethod
-    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 is_value(cls, v):
+        return any(m.value == v for m in cls.list())
 
     def __repr__(self):
         # Supports the condition: obj == eval(repr(obj))
-        d = {m.name: m.value for m in self}
+        d = {m.name: m.value for m in self.__class__.list()}
         # 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):
@@ -210,7 +83,7 @@ def __delattr__(self, k):
         raise AttributeError("Enum is immutable")
 
     def __len__(self):
-        return sum(1 for _ in self)
+        return len(self.__class__.list())
 
     def __eq__(self, o):
         if not isinstance(o, Enum):
@@ -226,19 +99,26 @@ class Color(Enum):
         GREEN = 2
         BLUE = 3
 
+    # Basic access
+    print(f"RED: repr={repr(Color.RED)}, type={type(Color.RED)}, {Color(1).name} ")
+    print(f"RED: name={Color.RED.name}, value={Color.RED.value}, str={str(Color.RED)}, call={Color.RED()} ")
+    assert Color(1).value == 1 
+    assert Color.BLUE.value >= Color.GREEN.value
+
     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()])
+    print()
 
     # Create instance
     c = Color()
     print(f"Enum c: {c}")
 
     # Basic access
-    print(f"RED: Name={c.RED.name}, Value={c.RED.value}, EnumValue={c.RED}, Call={c.RED()} ")
+    print(f"RED: name={c.RED.name}, value={c.RED.value}, str={str(c.RED)}, call={c.RED()} ")
 
     # Assertions
     assert c.RED.name == "RED"
@@ -247,13 +127,15 @@ 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
+    o = c(1)
+    print(f"c(1) lookup object: {o}, name={o.name}, value={o.value}")
     assert c(1).name == "RED"
     assert c(1).value == 1
     assert c(1) == 1
 
     try:
         c(999)
+        0 / 0
     except AttributeError as e:
         print(f"\nAttributeError: {e}: {c}\n")
 
@@ -282,6 +164,7 @@ class Status(Enum):
     # Immutability Check
     try:
         Status.RUNNING.value = 999
+        0 / 0
     except AttributeError as e:
         print(f"\nImmutability check: Passed (Cannot modify EnumValue): {e}\n")
 
@@ -294,6 +177,7 @@ class Status(Enum):
     # Test: Error handling for invalid lookup
     try:
         Status(999)
+        0 / 0
     except AttributeError as e:
         print(f"\nAttributeError: Invalid lookup check: Caught expected error -> {e}\n")
 
@@ -302,8 +186,8 @@ class Status(Enum):
 
     # Verify that eval(repr(obj)) restores the object
     c_repr = repr(c)
-    c_restored = eval(c_repr)
     print(f"Original: {c_repr}")
+    c_restored = eval(c_repr)
     print(f"Restored: {repr(c_restored)}")
     print(f"Objects are equal: {c == c_restored}")
     assert c == c_restored
@@ -314,6 +198,8 @@ class Status(Enum):
     print(type(state))
     assert state.ON == 1
     assert state.ON.name == "ON"
+    assert state.ON > 0
+    assert state.ON.value | state.OFF.value == 3
 
     # --- 1. Unique Data Types & Class Methods ---
     # Enums can hold more than just integers; here we use strings and add a method.
@@ -361,11 +247,13 @@ class Empty(Enum):
     # Ensuring the Enum structure cannot be tampered with after creation.
     try:
         api_call.NEW_METHOD = "PATCH"
+        0 / 0
     except AttributeError as e:
         print(f"Caught expected mutation error: {e}")
 
     try:
         del api_call.GET
+        0 / 0
     except AttributeError as e:
         print(f"Caught expected deletion error: {e}")
 

python-stdlib/enum/test_enum.py

@@ -1,8 +1,8 @@
 # test_enum.py
-# version="1.2.5"
+# version="1.3.0"
 
 import unittest
-from enum import Enum, EnumValue
+from enum import Enum
 
 
 class TestEnum(unittest.TestCase):
@@ -27,6 +27,9 @@ def test_class_attributes(self):
         """Test basic access to Enum members, names, and values."""
         self.assertEqual(self.color.RED.value, 1)
         self.assertEqual(self.color.RED.name, 'RED')
+        self.assertEqual(str(type(self.color.RED)), "<class 'EnumValue'>")
+        self.assertEqual(type(self.color.RED).__name__, 'EnumValue')
+        EnumValue = type(self.color.RED)
         self.assertIsInstance(self.color.RED, EnumValue)
         self.assertEqual(self.status.IDLE.value, 0)