python-stdlib\enum: version 1.2.1.

Gemini was used

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

Author: IhorNehrutsa

python-stdlib/enum/enum.py

@@ -1,269 +1,157 @@
-_Err = "no such attribute: "
+# enum.py
+# version="1.2.1"
 
 
-class ValueWrapper:
-    """Universal wrapper for accessing values via .value or calling ()"""
-    __slots__ = ('_v', )
-
-    def __init__(self, v):
-        self._v = v
-
-    @property
-    def value(self):
-        return self._v
-
-    def __call__(self):
-        return self._v
+class EnumValue:
+    def __init__(self, value, name):
+        object.__setattr__(self, 'value', value)
+        object.__setattr__(self, 'name', name)
 
     def __repr__(self):
-        return repr(self._v)
-
-    def __str__(self):
-        return str(self._v)
-
-    # Type conversion
-    def __int__(self):
-        return int(self._v)
-
-    def __float__(self):
-        return float(self._v)
-
-    def __index__(self):
-        return int(self._v)
-
-    def __bool__(self):
-        return bool(self._v)
-
-    # Helper function to extract the raw value
-    def _get_v(self, other):
-        return other._v if isinstance(other, ValueWrapper) else other
-
-    # Arithmetic and Bitwise operations (Forward)
-    def __add__(self, other):
-        return self._v + self._get_v(other)
-
-    def __sub__(self, other):
-        return self._v - self._get_v(other)
-
-    def __mul__(self, other):
-        return self._v * self._get_v(other)
-
-    def __truediv__(self, other):
-        return self._v / self._get_v(other)
-
-    def __floordiv__(self, other):
-        return self._v // self._get_v(other)
-
-    def __mod__(self, other):
-        return self._v % self._get_v(other)
-
-    def __pow__(self, other):
-        return self._v**self._get_v(other)
-
-    def __and__(self, other):
-        return self._v & self._get_v(other)
-
-    def __or__(self, other):
-        return self._v | self._get_v(other)
-
-    def __xor__(self, other):
-        return self._v ^ self._get_v(other)
-
-    def __lshift__(self, other):
-        return self._v << self._get_v(other)
-
-    def __rshift__(self, other):
-        return self._v >> self._get_v(other)
-
-    # Arithmetic and Bitwise operations (Reflected)
-    def __radd__(self, other):
-        return self._get_v(other) + self._v
-
-    def __rsub__(self, other):
-        return self._get_v(other) - self._v
-
-    def __rmul__(self, other):
-        return self._get_v(other) * self._v
-
-    def __rtruediv__(self, other):
-        return self._get_v(other) / self._v
-
-    def __rfloordiv__(self, other):
-        return self._get_v(other) // self._v
-
-    def __rand__(self, other):
-        return self._get_v(other) & self._v
-
-    def __ror__(self, other):
-        return self._get_v(other) | self._v
+        return str(self.value)
 
-    def __rxor__(self, other):
-        return self._get_v(other) ^ self._v
-
-    def __rlshift__(self, other):
-        return self._get_v(other) << self._v
-
-    def __rrshift__(self, other):
-        return self._get_v(other) >> self._v
-
-    # Unary operators
-    def __neg__(self):
-        return -self._v
-
-    def __pos__(self):
-        return +self._v
-
-    def __abs__(self):
-        return abs(self._v)
-
-    def __invert__(self):
-        return ~self._v
+    def __call__(self):
+        return self.value
 
-    # Comparison
     def __eq__(self, other):
-        return self._v == self._get_v(other)
+        return self.value == (other.value if isinstance(other, EnumValue) else other)
 
-    def __lt__(self, other):
-        return self._v < self._get_v(other)
-
-    def __le__(self, other):
-        return self._v <= self._get_v(other)
-
-    def __gt__(self, other):
-        return self._v > self._get_v(other)
-
-    def __ge__(self, other):
-        return self._v >= self._get_v(other)
-
-    def __ne__(self, other):
-        return self._v != self._get_v(other)
-
-
-def enum(**kw_args):  # `**kw_args` kept backwards compatible as in the Internet examples
-    return Enum(kw_args)
+    def __setattr__(self, key, value):
+        raise AttributeError("EnumValue is immutable")
 
 
-class Enum(dict):
-    def __init__(self, arg=None, **kwargs):
-        super().__init__()
-        # Use __dict__ directly for internal flags
-        # to avoid cluttering the dictionary keyspace
-        super().__setattr__('_is_loading', True)
+class Enum:
+    def __new__(cls, *args, **kwargs):
+        if len(args) > 0:
+            raise TypeError(f"{cls.__name__}() kwargs allowed only, not {args} args")
+        return super(Enum, cls).__new__(cls)
 
+    def __init__(self, **kwargs):
         # 1. Collect class-level attributes (constants)
         self._scan_class_attrs()
         # 2. Add arguments from the constructor
-        if arg: self.append(arg)
-        if kwargs: self.append(kwargs)
+        if kwargs:
+            self.append(**kwargs)
 
-        super().__setattr__('_is_loading', False)
+    def _update(self, key, value):
+        setattr(self.__class__, key, EnumValue(value, key))
 
     def _scan_class_attrs(self):
-        cls = self.__class__
-        # Define attributes to skip (internal or explicitly requested)
-        skipped = getattr(cls, '__skipped__', ())
+        # Converts static class attributes into EnumValue objects
+        # List of methods and internal names that should not be converted
+        ignored = ('is_value', 'append')
 
-        for key in dir(cls):
-            # Skip internal names, methods, and excluded attributes
-            if key.startswith('_') or key in ('append', 'is_value', 'key_from_value'):
-                continue
-            if key in skipped:
+        for key in dir(self.__class__):
+            # Skip internal names and methods
+            if key.startswith('_') or key in ignored:
                 continue
 
-            val = getattr(cls, key)
-            # Only wrap non-callable attributes (constants)
-            if not callable(val):
-                self[key] = ValueWrapper(val)
-
-    def append(self, arg=None, **kwargs):
-        if isinstance(arg, dict):
-            for k, v in arg.items():
-                self[k] = ValueWrapper(v)
-        else:
-            self._arg = arg  # for __str__()
-        if kwargs:
-            for k, v in kwargs.items():
-                self[k] = ValueWrapper(v)
+            value = getattr(self.__class__, key)
+            # Convert only constants, not methods
+            if not callable(value) and not isinstance(value, EnumValue):
+                self._update(key, value)
+
+    def is_value(self, value):
+        # Оптимізація: ітеруємося по self (де вже є __iter__), а не через dir()
+        return any(member.value == value for member in self)
+
+    def append(self, **kwargs):
+        forbidden = ('is_value', 'append', '_update', '_scan_class_attrs')
+        for key, value in kwargs.items():
+            if key in forbidden or key.startswith('_'):
+                raise NameError(f"Cannot add enum member with reserved name: {key}")
+            if hasattr(self.__class__, key):
+                existing = getattr(self.__class__, key)
+                if isinstance(existing, EnumValue):
+                    raise AttributeError(f"Enum member '{key}' already exists and is immutable")
+            self._update(key, value)
         return self
 
-    def __getattr__(self, key):
-        if key in self:
-            return self[key]
-        raise AttributeError(_Err + key)
+    def __repr__(self):
+        # Implementation of the principle: obj == eval(repr(obj))
+        # Use !r to correctly represent values ​​(e.g., quotes for strings)
+        members = [f"{k}={getattr(self.__class__, k).value!r}" for k in dir(self.__class__) if not k.startswith('_') and isinstance(getattr(self.__class__, k), EnumValue)]
+        # Return a string like: Color(RED=1, GREEN=2, BLUE=3)
+        return f"{type(self).__name__}({', '.join(members)})"
+
+    def __call__(self, value):
+        for member in self:
+            if member.value == value:
+                return member
+        raise ValueError(f"no such value: {value}")
 
     def __setattr__(self, key, value):
-        if self._is_loading or key.startswith('_'):
-            # Record directly into memory as a regular variable
-            super().__setattr__(key, value)
-        else:
-            # Handle as an Enum element (wrap in ValueWrapper)
-            self[key] = ValueWrapper(value)
+        if hasattr(self, key) and isinstance(getattr(self, key), EnumValue):
+            raise AttributeError(f"Enum member '{key}' is immutable")
+        super().__setattr__(key, value)
 
-    def is_value(self, value):
-        return any(v._v == value for v in self.values())
-
-    def key_from_value(self, value):
-        for k, v in self.items():
-            if v._v == value: return f"{self.__class__.__name__}.{k}"
-        raise ValueError(_Err + str(value))
-
-    def __dir__(self):
-        # 1. Dictionary keys (your data: X1, X2, etc.)
-        data_keys = list(self.keys())
-        # 2. Class attributes (your methods: append, is_value, etc.)
-        class_stuff = list(dir(self.__class__))
-        # 3. Parent class attributes (for completeness)
-        parent_attrs = list(dir(super()))
-        # Combine and remove duplicates using set for clarity
-        #return list(set(data_keys + class_stuff + parent_attrs))
-        return list(set(data_keys + class_stuff))
+    def __delattr__(self, key):
+        if hasattr(self, key) and isinstance(getattr(self, key), EnumValue):
+            raise AttributeError("Enum members cannot be deleted")
+        super().__delattr__(key)
+
+    def __len__(self):
+        return sum(1 for _ in self)
+
+    def __iter__(self):
+        for key in dir(self.__class__):
+            attr = getattr(self.__class__, key)
+            if isinstance(attr, EnumValue):
+                yield attr
+
+
+def enum(**kwargs):  # `**kwargs` kept backwards compatible as in the Internet examples
+    return Enum(**kwargs)
 
-    def __call__(self, value):
-        if self.is_value(value):
-            return value
-        raise ValueError(_Err + f"{value}")
 
+if __name__ == '__main__':
+    # --- Usage Example ---
 
-if __name__ == "__main__":
-    # --- Usage Examples ---
+    # 1. Creation via class
+    class Color(Enum):
+        RED = 1
+        GREEN = 2
 
-    # 1. GPIO and Hardware Configuration
-    class Pins(Enum):
-        LED = 2
-        BUTTON = 4
-        __skipped__ = ('RESERVED_PIN', )
-        RESERVED_PIN = 0
+    # Create instance
+    c = Color()
+    print(f"Enum repr: {c}")
 
-    pins = Pins(SDA=21, SCL=22)
-    print(f"I2C SDA Pin: {pins.SDA}")
-    print(f"Is 21 a valid pin? {pins.is_value(21)}")
+    # 2. Strict __init__ control check
+    try:
+        c_bad = Color('BLACK')
+    except TypeError as e:
+        print(f"\nTypeError: Strict Init Check: {e}\n")
 
-    # 2. Math and Logic
-    brightness = Enum(MIN=0, STEP=25, MAX=255)
-    print(f"Next level: {brightness.MIN + brightness.STEP // 2}")
-    print(f"Calculation: {brightness.MIN + 2 * brightness.STEP}")
+    # 3. Dynamic addition
+    c.append(BLUE=3)
+    print(f"c after append: {c}")
 
-    # Direct arithmetic without .value
-    print(f"Complex math: {100 + brightness.STEP}")
+    print('dir(c):', dir(c))
 
-    # 3. State Machine (Dynamic Expansion)
-    status = Enum(IDLE=0, CONNECTING=1)
-    status.append(CONNECTED=2, ERROR=3)
-    status.DISCONNECTING = 4
+    # 4. Immutability and name protection check
+    try:
+        c.append(append=True)
+    except NameError as e:
+        print(f"\nNameError: Reserved name protection: {e}\n")
 
-    for name, val in status.items():
-        print(f"Status {name} has code {val}")
+    # 5. Basic access
+    print(f"RED: Name={c.RED.name}, Value={c.RED.value}, EnumValue={c.RED}, Call={c.RED()} ")
 
-    # 4. Working with different types
-    commands = Enum(START="CMD_START", STOP="CMD_STOP", REBOOT_CODE=0xDEADBEEF, IS_ACTIVE=True)
+    # 6. Assertions
+    assert c.RED == 1
+    assert c.RED.value == 1
+    assert c.RED.name == 'RED'
 
-    if commands.IS_ACTIVE:
-        print(f"Running command: {commands.START}")
+    # 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
 
-    # 5. Class Config and dir()
-    class WebConfig(Enum):
-        PORT = 80
-        TIMEOUT = 5.0
+    # 8. Iteration
+    print("Values list:", [member.value for member in c])
+    print("Names list:", [member.name for member in c])
 
-    config = WebConfig({'IP': '192.168.1.1'})
-    print(f"Available keys in config: {list(config.keys())}")
+    try:
+        c(7)
+    except ValueError as e:
+        print(f"\nValueError: {c} {e}\n")

python-stdlib/enum/manifest.py

@@ -1,3 +1,3 @@
-metadata(version="1.1.0")
+metadata(version="1.2.0")
 
 module("enum.py")