zstdlib 0.1.0__tar.gz → 0.2.0__tar.gz

{zstdlib-0.1.0 → zstdlib-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zstdlib
-Version: 0.1.0
+Version: 0.2.0
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib

zstdlib-0.2.0/tests/test_enum.py

@@ -0,0 +1,133 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable
+import unittest
+
+from zstdlib.enum import EnumType, Enum, entries, values, auto
+
+
+class TestEnumType(unittest.TestCase):
+
+    def test_valid(self) -> None:
+        class ET1(metaclass=EnumType):
+            arg1: int = 0
+            arg2: int = 1
+
+    def test_empty(self) -> None:
+        class ET1(metaclass=EnumType, empty_ok=True):
+            pass
+
+        with self.assertRaises(ValueError):
+
+            class ET2(metaclass=EnumType):
+                pass
+
+    def test_dupes(self) -> None:
+        class ET1(metaclass=EnumType, dupes_ok=True):
+            a: int = 5
+            b: int = 5
+            c: dict = {}
+
+        with self.assertRaises(ValueError):
+
+            class ET2(metaclass=EnumType):
+                a: int = 5
+                b: int = 5
+
+        with self.assertRaises(TypeError):
+
+            class ET3(metaclass=EnumType):
+                a: dict = {}
+
+    def test_type_check(self) -> None:
+        class ET1(metaclass=EnumType, type_check=set()):
+            a: str = 5  # type: ignore[assignment]
+
+        with self.assertRaises(TypeError):
+
+            class ET2(metaclass=EnumType):
+                a: str = 5  # type: ignore[assignment]
+
+    def test_annotations(self) -> None:
+        with self.assertRaises(ValueError):
+
+            class ET1(metaclass=EnumType):
+                arg1 = 1
+
+        with self.assertRaises(ValueError):
+
+            class ET2(metaclass=EnumType):
+                arg1: int
+
+    def test_instantiation(self) -> None:
+        with self.assertRaises(AttributeError):
+
+            class ET1(metaclass=EnumType):
+                arg1: int = 1
+
+                def __init__(self):
+                    pass
+
+        with self.assertRaises(AttributeError):
+
+            class ET2(metaclass=EnumType):
+                arg1: int = 1
+
+                def __new__(cls):
+                    pass
+
+        class ET3(metaclass=EnumType):
+            arg1: int = 0
+
+        with self.assertRaises(TypeError):
+            ET3()
+
+        with self.assertRaises(TypeError):
+            ET3.__new__({})  # type: ignore[arg-type]
+
+    def test_iter(self) -> None:
+
+        class ET11(metaclass=EnumType):
+            arg1: int = 0
+            arg2: str = "1"
+
+        self.assertEqual(tuple(ET11), ("arg1", "arg2"))
+
+    def test_auto(self) -> None:
+
+        class ET1(metaclass=EnumType):
+            arg1: int = 0
+            arg2 = auto
+            arg3 = auto
+
+        self.assertEqual(3, len(set(values(ET1))))
+
+        with self.assertRaises(TypeError):
+
+            class ET2(metaclass=EnumType):
+                arg1: int = 0
+                arg2: str = auto  # type: ignore[assignment]
+
+
+class TestEnum(unittest.TestCase):
+
+    def test_is(self) -> None:
+        self.assertIsInstance(Enum, EnumType)
+
+
+class TestFunctions(unittest.TestCase):
+    def test_entries(self) -> None:
+        class E1(Enum):
+            arg1: int = 0
+            arg2: str = "1"
+
+        self.assertEqual(entries(E1), {"arg1": (int, 0), "arg2": (str, "1")})
+
+    def test_values(self) -> None:
+        class E1(Enum):
+            arg1: int = 0
+            arg2: str = "1"
+
+        self.assertEqual(values(E1), (0, "1"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{zstdlib-0.1.0 → zstdlib-0.2.0}/zstdlib/__init__.py

@@ -1,7 +1,7 @@
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 from .not_set import NotSetType, NotSet
 from .frozen import Freezable, frozen
 from .singleton import Singleton
-from .enum import Enum
+from .enum import Enum, auto
 from . import log, io

{zstdlib-0.1.0 → zstdlib-0.2.0}/zstdlib/ansi.py

@@ -144,7 +144,7 @@ def _generate_code(
         ints.append(foreground.value)
     if background:
         ints.append(background.value)
-    return f"{_PREFIX}{';'.join(str(i) for i in ints)}m"
+    return f"{_PREFIX}{';'.join(map(str, ints))}m"
 
 
 @cache

zstdlib-0.2.0/zstdlib/enum.py

@@ -0,0 +1,154 @@
+from collections.abc import Iterator
+from typing import Any
+
+
+class _Auto:
+    """A sentinel value for automatic enum values"""
+
+
+# Pass this as a value to have it automatically assigned
+auto = _Auto()
+
+
+class EnumType(type):
+    """
+    Metaclass for uninstantiable Enum classes with required annotations and unique values
+    Enum entry names may not be prefixed with __ or be an EnumType._AutoValue
+    These 'Enum' classes may not be modified after creation
+    Items of annotation types in type_check will be type-checked
+    Duplicate values (as determined by set()) are not allowed unless dupes_ok is True
+    """
+
+    _AUTO_PREFIX = "Enum_Auto_"
+    _TC_DEFAULT: set[type | None] = {int, str, float, bool, complex, bytes, None, type(None)}
+
+    class _AutoValue:
+        """A class representing an automatically assigned enum value"""
+
+        def __init__(self, value: int) -> None:
+            self._value = value
+
+        def __str__(self) -> str:
+            return f"<Auto: {self._value}>"
+
+        def __repr__(self) -> str:
+            return str(self)
+
+    @classmethod
+    def _gen_entries_and_annotations(
+        mcs, attrs: dict, dupes_ok: bool
+    ) -> tuple[dict[str, tuple[type | None, Any]], dict[str, type | None]]:
+        """
+        Generate enum entries from attrs, checking for duplicates and missing annotations
+        Does not check for empty enum or type correctness
+        """
+        seen = set()
+        auto_val = 0
+        _entries = {}
+        _annotations = dict(attrs.get("__annotations__", {}))
+        try:
+            for a_name, value in ((i, k) for i, k in attrs.items() if not i.startswith("__")):
+                if value is auto:
+                    auto_val += 1
+                    value = mcs._AutoValue(auto_val)
+                    if a_name in _annotations:
+                        raise TypeError("Auto enum entries may not be type annotated")
+                    _annotations[a_name] = mcs._AutoValue
+                elif isinstance(value, mcs._AutoValue):
+                    raise ValueError("Enum entries may not be of type EnumType._AutoValue")
+                if not dupes_ok:
+                    if value in seen:
+                        raise ValueError(f"Duplicate enum value: {value}")
+                    seen.add(value)
+                _entries[a_name] = (_annotations[a_name], value)
+        except TypeError:
+            raise TypeError(f"Unhashable enum value: {value}") from None
+        except KeyError:
+            raise ValueError("Non-auto enum entries must be type annotated") from None
+        return _entries, _annotations
+
+    # pylint: disable=too-many-arguments, dangerous-default-value
+    def __new__(
+        mcs,
+        name,
+        bases,
+        attrs,
+        *,
+        empty_ok: bool = False,
+        dupes_ok: bool = False,
+        type_check: set[type | None] = _TC_DEFAULT,
+        **kwargs,
+    ):
+        # Disallow undesired instance methods
+        if bad := attrs.keys() & {"__init__", "__new__", "__entries__"}:
+            raise AttributeError(f"Illegal methods in Enum class: {', '.join(bad)}")
+        # Generate entries
+        _entries, _annotations = mcs._gen_entries_and_annotations(attrs, dupes_ok)
+        # Validate entries
+        if no_value := (_annotations.keys() - _entries.keys()):
+            raise ValueError(f"Entries must have a value: {' '.join(no_value)}")
+        if (not empty_ok) and not _entries:
+            raise ValueError("Enum type may not be empty")
+        if type_check:
+            for a_name, (ann, val) in _entries.items():
+                if ann in type_check and (
+                    (ann is None is not val) or (ann is not None and not isinstance(val, ann))
+                ):
+                    raise TypeError(f"Entry {a_name} is not of type {ann}")
+        # Construct class
+        attrs["__entries__"] = _entries
+        attrs["__annotations__"] = _annotations
+        attrs["__init__"] = attrs["__new__"] = NotImplemented
+        return type.__new__(mcs, name, bases, attrs, **kwargs)
+
+    # Disallow modification
+
+    def __delattr__(cls, *_):
+        raise AttributeError("This class cannot be modified")
+
+    def __setattr__(cls, *_):
+        raise AttributeError("This class cannot be modified")
+
+    # Class methods for the derived types
+
+    def __iter__(cls) -> Iterator[str]:
+        """Iterator over enum keys"""
+        yield from cls.__entries__  # type: ignore
+
+    def _disallow(cls):
+        """Disallow instantiation"""
+        raise AttributeError("This class may not be instantiated")
+
+
+class Enum(metaclass=EnumType, empty_ok=True):
+    """
+    An uninstantiable Enum base type
+    Subclasses must provide type-annotated fields with unique values
+    Fields may not be prefixed with "__"
+    Derived classes will not be modifiable
+    """
+
+
+def entries(enum: Any) -> dict[str, tuple[type | None, Any]]:
+    """
+    :param enum: A class whose metaclass is EnumType
+    :return: A dict mapping names to (type annotation, value) pairs
+    If enum's type is not an EnumType, raises TypeError
+    """
+    if not isinstance(enum, EnumType):
+        raise TypeError("enum must have a metaclass of EnumType")
+    return dict(enum.__entries__)  # type: ignore[attr-defined]
+
+
+def values(enum: Any) -> tuple[Any, ...]:
+    """
+    :param enum: A class whose metaclass is EnumType
+    :return: A tuple of all values of enum
+    If enum's type is not an EnumType, raises TypeError
+    """
+    if not isinstance(enum, EnumType):
+        raise TypeError("enum must have a metaclass of EnumType")
+    return tuple(k[1] for k in enum.__entries__.values())  # type: ignore[attr-defined]
+
+
+__all__ = ("Enum", "EnumType", "entries", "values", "auto")

{zstdlib-0.1.0 → zstdlib-0.2.0}/zstdlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zstdlib
-Version: 0.1.0
+Version: 0.2.0
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib

zstdlib-0.1.0/tests/test_enum.py

@@ -1,137 +0,0 @@
-# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable
-import unittest
-
-from zstdlib.enum import EnumType, Enum
-
-
-class TestEnumType(unittest.TestCase):
-
-    def test_valid(self) -> None:
-        class ET1(metaclass=EnumType):
-            arg1: int = 0
-            arg2: int = 1
-
-    def test_empty(self) -> None:
-        class ET2(metaclass=EnumType, empty_ok=True):
-            pass
-
-        with self.assertRaises(ValueError):
-
-            class ET3(metaclass=EnumType):
-                pass
-
-    def test_dupe(self) -> None:
-        with self.assertRaises(ValueError):
-
-            class ET4(metaclass=EnumType):
-                arg1: int = 0
-                arg2: int = 0
-
-    def test_annotations(self) -> None:
-        with self.assertRaises(ValueError):
-
-            class ET5(metaclass=EnumType):
-                arg1 = 1
-
-        with self.assertRaises(ValueError):
-
-            class ET6(metaclass=EnumType):
-                arg1: int
-
-        with self.assertRaises(TypeError):
-
-            class ET7(metaclass=EnumType):
-                arg1: str = 0  # type: ignore[assignment]
-
-    def test_instantiation(self) -> None:
-        with self.assertRaises(AttributeError):
-
-            class ET8(metaclass=EnumType):
-                arg1: int = 1
-
-                def __init__(self):
-                    pass
-
-        with self.assertRaises(AttributeError):
-
-            class ET9(metaclass=EnumType):
-                arg1: int = 1
-
-                def __new__(cls):
-                    pass
-
-        class ET10(metaclass=EnumType):
-            arg1: int = 0
-
-        with self.assertRaises(TypeError):
-            ET10()
-        with self.assertRaises(TypeError):
-            ET10.__init__({})
-
-
-class TestEnum(unittest.TestCase):
-    def test_valid(self) -> None:
-        class E1(Enum):
-            arg1: int = 0
-            arg2: int = 1
-
-    def test_empty(self) -> None:
-        class E2(Enum, empty_ok=True):
-            pass
-
-        with self.assertRaises(ValueError):
-
-            class E3(Enum):
-                pass
-
-    def test_dupe(self) -> None:
-        with self.assertRaises(ValueError):
-
-            class E4(Enum):
-                arg1: int = 0
-                arg2: int = 0
-
-    def test_annotations(self) -> None:
-        with self.assertRaises(ValueError):
-
-            class E5(Enum):
-                arg1 = 1
-
-        with self.assertRaises(ValueError):
-
-            class E6(Enum):
-                arg1: int
-
-        with self.assertRaises(TypeError):
-
-            class E7(Enum):
-                arg1: str = 0  # type: ignore[assignment]
-
-    def test_instantiation(self) -> None:
-        with self.assertRaises(AttributeError):
-
-            class E8(Enum):
-                arg1: int = 1
-
-                def __init__(self):
-                    pass
-
-        with self.assertRaises(AttributeError):
-
-            class E9(Enum):
-                arg1: int = 1
-
-                def __new__(cls):
-                    pass
-
-        class E10(Enum):
-            arg1: int = 0
-
-        with self.assertRaises(TypeError):
-            E10()
-        with self.assertRaises(TypeError):
-            E10.__init__({})
-
-
-if __name__ == "__main__":
-    unittest.main()

zstdlib-0.1.0/zstdlib/enum.py

@@ -1,53 +0,0 @@
-import collections
-
-
-class EnumType(type):
-    """
-    Metaclass for uninstantiable Enum classes with required annotations and unique values
-    Enum values may not be prefixed with _
-    These 'Enum' classes may not be modified after creation
-    """
-
-    def __new__(mcs, name, bases, attrs, **kwargs):
-        # Disallow instantiation
-        for bad in ("__init__", "__new__"):
-            if bad in attrs:
-                raise AttributeError("Cannot define __init__ or __new__")
-            attrs[bad] = None
-        # Check annotations
-        public = {i: k for i, k in attrs.items() if not i.startswith("__")}
-        annotations = attrs.get("__annotations__", {})
-        eok = kwargs.pop("empty_ok", False)
-        if not public and not annotations:
-            if not eok:
-                raise ValueError("Enum type is empty")
-        if bad := (pub_set := set(public)) - (an_set := set(annotations)):
-            raise ValueError(f"All enum entries must be type annotated: {bad}")
-        if bad := an_set - pub_set:
-            raise ValueError(f"All type annotated entries must have a value: {bad}")
-        for i, typ in annotations.items():
-            if not isinstance(attrs[i], typ):
-                raise TypeError(f"{i} is not of type {typ}")
-        # Disallow duplicate values
-        counts = collections.Counter(public.values())
-        if dups := {i: k for i, k in public.items() if counts[k] > 1}:
-            raise ValueError(f"Duplicate values: {dups}")
-        # Construct class
-        return type.__new__(mcs, name, bases, attrs, **kwargs)
-
-    # Disallow modification
-
-    def __delattr__(cls, *_):
-        raise AttributeError("This class cannot be modified")
-
-    def __setattr__(cls, *_):
-        raise AttributeError("This class cannot be modified")
-
-
-class Enum(metaclass=EnumType, empty_ok=True):
-    """
-    A uninstantiable Enum base type
-    Subclasses must provide type-annotated fields with unique values
-    Fields may not be prefixed with "_"
-    Derived classes will not be modifiable
-    """