jetpytools 2.0.2__tar.gz → 2.1.1__tar.gz

{jetpytools-2.0.2 → jetpytools-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 2.0.2
+Version: 2.1.1
 Summary: Collection of stuff that's useful in general python programming
 Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools
 Project-URL: Contact, https://discord.gg/XTpc6Fa9eB

{jetpytools-2.0.2 → jetpytools-2.1.1}/jetpytools/_metadata.py

@@ -1,6 +1,6 @@
 """Collection of stuff that's useful in general python programming"""
 
-__version__ = "2.0.2"
+__version__ = "2.1.1"
 
 __author_name__, __author_email__ = "Jaded Encoding Thaumaturgy", "jaded.encoding.thaumaturgy@gmail.com"
 __maintainer_name__, __maintainer_email__ = __author_name__, __author_email__

jetpytools-2.1.1/jetpytools/enums/base.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from abc import ABCMeta
+from enum import Enum, EnumMeta, ReprEnum
+from enum import property as enum_property
+from typing import TYPE_CHECKING, Any, Self
+
+from ..exceptions import CustomTypeError, NotFoundEnumValueError
+from ..types import FuncExcept, copy_signature
+
+__all__ = ["CustomEnum", "CustomIntEnum", "CustomStrEnum", "EnumABCMeta"]
+
+
+class EnumABCMeta(EnumMeta, ABCMeta):
+    """Metaclass combining EnumMeta and ABCMeta to support abstract enumerations."""
+
+    @copy_signature(EnumMeta.__new__)
+    def __new__(mcls, *args: Any, **kwargs: Any) -> Any:
+        enum_cls = super().__new__(mcls, *args, **kwargs)
+
+        if len(enum_cls) == 0:
+            return enum_cls
+
+        if enum_cls.__abstractmethods__:
+            raise CustomTypeError(
+                "Can't instantiate abstract class {cls_name} without an implementation "
+                "for abstract method{plural} {methods}.",
+                enum_cls,
+                cls_name=enum_cls.__name__,
+                plural="s" if len(enum_cls.__abstractmethods__) > 1 else "",
+                methods=", ".join(f"'{n}'" for n in sorted(enum_cls.__abstractmethods__)),
+            )
+
+        return enum_cls
+
+
+class CustomEnum(Enum):
+    """Base class for custom enums."""
+
+    @classmethod
+    def from_param(cls, value: Any, func_except: FuncExcept | None = None) -> Self:
+        """
+        Return the enum value from a parameter.
+
+        :param value:               Value to instantiate the enum class.
+        :param func_except:         Exception function.
+
+        :return:                    Enum value.
+
+        :raises NotFoundEnumValue:   Variable not found in the given enum.
+        """
+        func_except = func_except or cls.from_param
+
+        try:
+            return cls(value)
+        except (ValueError, TypeError):
+            pass
+
+        if isinstance(func_except, tuple):
+            func_name, var_name = func_except
+        else:
+            func_name, var_name = func_except, repr(cls)
+
+        raise NotFoundEnumValueError(
+            'The given value for "{var_name}" argument must be a valid {enum_name}, not "{value}"!\n'
+            "Valid values are: [{readable_enum}].",
+            func_name,
+            var_name=var_name,
+            enum_name=cls,
+            value=value,
+            readable_enum=(f"{name} ({value!r})" for name, value in cls.__members__.items()),
+            reason=value,
+        ) from None
+
+
+class CustomIntEnum(int, CustomEnum, ReprEnum):
+    """Base class for custom int enums."""
+
+    if TYPE_CHECKING:
+        _value_: int
+
+        @enum_property
+        def value(self) -> int: ...
+
+
+class CustomStrEnum(str, CustomEnum, ReprEnum):
+    """Base class for custom str enums."""
+
+    if TYPE_CHECKING:
+        _value_: str
+
+        @enum_property
+        def value(self) -> str: ...

jetpytools-2.0.2/jetpytools/enums/base.py

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, Self
-
-from ..exceptions import CustomValueError, NotFoundEnumValue
-from ..types import FuncExcept
-
-__all__ = ["CustomEnum", "CustomIntEnum", "CustomStrEnum"]
-
-
-class CustomEnum(Enum):
-    """Base class for custom enums."""
-
-    @classmethod
-    def _missing_(cls, value: Any) -> Self | None:
-        return cls.from_param(value)
-
-    @classmethod
-    def from_param(cls, value: Any, func_except: FuncExcept | None = None) -> Self | None:
-        """
-        Return the enum value from a parameter.
-
-        :param value:               Value to instantiate the enum class.
-        :param func_except:         Exception function.
-
-        :return:                    Enum value.
-
-        :raises NotFoundEnumValue:   Variable not found in the given enum.
-        """
-
-        if value is None:
-            return None
-
-        if func_except is None:
-            func_except = cls.from_param
-
-        if isinstance(value, cls):
-            return value
-
-        if value is cls:
-            raise CustomValueError("You must select a member, not pass the enum!", func_except)
-
-        try:
-            return cls(value)
-        except Exception:
-            pass
-
-        if isinstance(func_except, tuple):
-            func_name, var_name = func_except
-        else:
-            func_name, var_name = func_except, str(cls)
-
-        raise NotFoundEnumValue(
-            'The given value for "{var_name}" argument must be a valid {enum_name}, not "{value}"!\n'
-            "Valid values are: [{readable_enum}].",
-            func_name,
-            var_name=var_name,
-            enum_name=cls,
-            value=value,
-            readable_enum=iter([f"{x.name} ({x.value})" for x in cls]),
-            reason=value,
-        )
-
-
-class CustomIntEnum(int, CustomEnum):
-    """Base class for custom int enums."""
-
-
-class CustomStrEnum(str, CustomEnum):
-    """Base class for custom str enums."""