zstdlib 0.2.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: zstdlib
-Version: 0.2.0
+Version: 0.3.2
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib
 Keywords: remote,pipe
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Requires-Python: >=3.12
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file

{zstdlib-0.2.0 → zstdlib-0.3.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "zstdlib"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.14",
     "Development Status :: 5 - Production/Stable",
     "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
 ]
@@ -14,20 +14,7 @@ keywords = ["remote", "pipe"]
 license = {text = "GPLv3"}
 description = "A set of useful python utilities"
 urls = {Homepage = "https://github.com/zwimer/zstdlib"}
-requires-python = ">= 3.12"
-# dependencies = [
-#     # Client
-#     "zstandard[cffi]",
-#     "pycryptodomex",
-# 	"cryptography",
-#     "requests",
-#     "tqdm",
-#     # Server
-#     "waitress",
-#     "flask",
-#     # Both
-#     "human_readable",
-# ]
+requires-python = ">= 3.14"
 dynamic = ["version"]
 
 [project.readme]
@@ -38,14 +25,14 @@ content-type = "text/markdown"
 include-package-data = true
 license-files = ["LICENSE"]
 
-[tool.setuptools.packages]
-find = {namespaces = false}
+[tool.setuptools.packages.find]
+namespaces = false
 
 [tool.setuptools.package-data]
 zstdlib = ["py.typed"]
 
-[tool.setuptools.dynamic]
-version = {attr = "zstdlib.__version__"}
+[tool.setuptools.dynamic.version]
+attr = "zstdlib.__version__"
 
 # Tools
 
@@ -55,15 +42,15 @@ ignore-paths = '^tests/.*$'
 disable = [
     "unnecessary-lambda-assignment",
     "method-cache-max-size-none",
-	"missing-module-docstring",
-	"too-few-public-methods",
-	"line-too-long",
-	"invalid-name"
+    "missing-module-docstring",
+    "too-few-public-methods",
+    "line-too-long",
+    "invalid-name"
 ]
 
 [tool.black]
 line-length = 110
-target-version = ["py312", "py313"]
+target-version = ["py314"]
 
 [tool.ruff]
 line-length = 110

{zstdlib-0.2.0 → zstdlib-0.3.2}/tests/test_frozen.py

@@ -1,4 +1,5 @@
 # pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable,attribute-defined-outside-init
+from sys import version_info
 import unittest
 
 from zstdlib.frozen import Freezable, frozen
@@ -104,10 +105,15 @@ class TestFrozen(unittest.TestCase):
         f1 = F1()
         self.assertEqual(f1.__init__.__doc__.strip(), "init doc")
         self.assertEqual(f1.__init__.__name__, "__init__")
-        self.assertEqual(f1.__init__.__qualname__, "TestFrozen.test_metadata.<locals>.F2.__init__")
+        self.assertEqual(f1.__init__.__qualname__, "TestFrozen.test_metadata.<locals>.F1.__init__")
         self.assertTupleEqual(f1.__init__.__defaults__, (1,))
         self.assertDictEqual(f1.__init__.__kwdefaults__, {"b": False})
-        self.assertDictEqual(f1.__init__.__annotations__, {"a": int, "b": bool, "return": None})
+        if version_info <= (3, 13) or hasattr(f1.__init__, "__annotations__"):
+            self.assertDictEqual(f1.__init__.__annotations__, {"a": int, "b": bool, "return": None})
+        else:  # annotations changed in 3.14, .__annotations__ *might* not exist
+            from annotationlib import get_annotations
+
+            self.assertDictEqual(get_annotations(f1.__init__), {"a": int, "b": bool, "return": None})
 
     def test_frozen_custom(self):
         @frozen("custom")

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

@@ -1,4 +1,4 @@
-__version__ = "0.2.0"
+__version__ = "0.3.2"
 
 from .not_set import NotSetType, NotSet
 from .frozen import Freezable, frozen

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

@@ -39,15 +39,43 @@ class RawColor:
         self.background = background
         self.value = self.color.value + (10 if self.background else 0) + (60 if self.bright else 0)
 
+    @classmethod
+    @cache
+    def _parse_color(cls, item: str) -> str:
+        """Construct a color following the rules defined by Color"""
+        item = item.lower()
+        if "bright_bg" in item:
+            raise ValueError("bg_ must precede bright_ in color specification")
+        pat = f"(:?bright_)?({'|'.join(list(PureColor.__members__))})"
+        shx = re.findall(f"(bg_){pat}", item)
+        if len(shx) > 1:
+            raise ValueError(f"Multiple background colors specified in {item}")
+        bg = None
+        if len(shx) == 1:
+            item = item.replace("".join(shx[0]), "")
+            bg = cls(shx[0][-1], bright="bright_" in shx[0], background=True)
+        shx = re.findall(pat, item)
+        if len(shx) > 1:
+            raise ValueError(f"Multiple foreground colors specified in {item}")
+        fg = None
+        if len(shx) == 1:
+            item = item.replace("".join(shx[0]), "")
+            fg = cls(shx[0][-1], bright="bright_" in shx[0])
+        # Determine modifiers and construct the color
+        attrs = [i for i in item.split("_") if i]
+        if any(bad := [i for i in attrs if i not in MODIFIERS]):
+            raise ValueError(f"Unknown modifiers(s): {', '.join(bad)}")
+        return _generate_code(fg, bg, {i: True for i in MODIFIERS if i in attrs})
+
 
 class _ColorMeta(type):
     """
     A metaclass that implements __getattr__ at the class level for Color
     """
 
-    def __getattr__(cls, item: str) -> "Color":
+    def __getattr__(cls, item: str) -> Color:
         try:
-            return cls(code=_parse_color(item))
+            return cls(code=RawColor._parse_color(item))
         except ValueError as e:
             raise AttributeError(str(e)) from e
 
@@ -91,7 +119,7 @@ class Color(metaclass=_ColorMeta):
         elif isinstance(fmt, RawColor):
             self.code = f"{_PREFIX}{fmt.value}m"
         else:
-            self.code = _parse_color(fmt) if isinstance(fmt, str) else fmt.code
+            self.code = RawColor._parse_color(fmt) if isinstance(fmt, str) else fmt.code
 
     def __call__(self, string: str) -> str:
         """
@@ -145,34 +173,3 @@ def _generate_code(
     if background:
         ints.append(background.value)
     return f"{_PREFIX}{';'.join(map(str, ints))}m"
-
-
-@cache
-def _parse_color(item: str) -> str:
-    """
-    Construct a color following the rules defined by Color
-    This method is not a classmethod since python3.13 deprecates mixing classmethod and cache
-    """
-    item = item.lower()
-    if "bright_bg" in item:
-        raise ValueError("bg_ must precede bright_ in color specification")
-    pat = f"(:?bright_)?({'|'.join(list(PureColor.__members__))})"
-    shx = re.findall(f"(bg_){pat}", item)
-    if len(shx) > 1:
-        raise ValueError(f"Multiple background colors specified in {item}")
-    bg: RawColor | None = None
-    if len(shx) == 1:
-        item = item.replace("".join(shx[0]), "")
-        bg = RawColor(shx[0][-1], bright="bright_" in shx[0], background=True)
-    shx = re.findall(pat, item)
-    if len(shx) > 1:
-        raise ValueError(f"Multiple foreground colors specified in {item}")
-    fg: RawColor | None = None
-    if len(shx) == 1:
-        item = item.replace("".join(shx[0]), "")
-        fg = RawColor(shx[0][-1], bright="bright_" in shx[0])
-    # Determine modifiers and construct the color
-    attrs = [i for i in item.split("_") if i]
-    if any(bad := [i for i in attrs if i not in MODIFIERS]):
-        raise ValueError(f"Unknown modifiers(s): {', '.join(bad)}")
-    return _generate_code(fg, bg, {i: True for i in MODIFIERS if i in attrs})

{zstdlib-0.2.0 → zstdlib-0.3.2}/zstdlib/enum.py

@@ -1,5 +1,6 @@
 from collections.abc import Iterator
 from typing import Any
+import annotationlib
 
 
 class _Auto:
@@ -17,6 +18,7 @@ class EnumType(type):
     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
+    If dupe-checking is enabled, values must be hashable
     """
 
     _AUTO_PREFIX = "Enum_Auto_"
@@ -36,38 +38,46 @@ class EnumType(type):
 
     @classmethod
     def _gen_entries_and_annotations(
-        mcs, attrs: dict, dupes_ok: bool
-    ) -> tuple[dict[str, tuple[type | None, Any]], dict[str, type | None]]:
+        mcs,
+        attrs: dict,
+        dupes_ok: bool,
+        ans: dict[str, type | None],
+    ) -> dict[str, tuple[type | None, Any]]:
         """
         Generate enum entries from attrs, checking for duplicates and missing annotations
         Does not check for empty enum or type correctness
+        Updates ans with new annotations
         """
         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}")
+        ret = {}
+        for a_name, value in ((i, k) for i, k in attrs.items() if not i.startswith("__")):
+            # If auto, ensure not annotated, then annotate
+            if value is auto:
+                auto_val += 1
+                value = mcs._AutoValue(auto_val)
+                if a_name in ans:
+                    raise TypeError("Auto enum entries may not be type annotated")
+                ans[a_name] = mcs._AutoValue
+            # If annotated as auto, complain
+            elif isinstance(value, mcs._AutoValue):
+                raise ValueError("Enum entries may not be of type EnumType._AutoValue")
+            # Dupe check, requires hash-able values
+            if not dupes_ok:
+                if value in seen:
+                    raise ValueError(f"Duplicate enum value: {value}")
+                try:
                     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
+                except TypeError:
+                    raise TypeError(f"Unhashable enum value cannot be dupe checked: {value}") from None
+            # Save annotation and value to entries
+            try:
+                ret[a_name] = (ans[a_name], value)
+            except KeyError:
+                raise ValueError("Non-auto enum entries must be type annotated") from None
+        return ret
+
+    # pylint: disable=too-many-arguments, dangerous-default-value, too-many-locals
     def __new__(
         mcs,
         name,
@@ -82,24 +92,26 @@ class EnumType(type):
         # 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)
+        # Generate entries and annotations
+        ans = annotationlib.get_annotations(super().__new__(mcs, name, bases, attrs))
+        entries_ = mcs._gen_entries_and_annotations(attrs, dupes_ok, ans)
         # Validate entries
-        if no_value := (_annotations.keys() - _entries.keys()):
+        if no_value := (ans.keys() - entries_.keys()):
             raise ValueError(f"Entries must have a value: {' '.join(no_value)}")
-        if (not empty_ok) and not _entries:
+        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():
+            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["__entries__"] = entries_  # For our usage later
         attrs["__init__"] = attrs["__new__"] = NotImplemented
-        return type.__new__(mcs, name, bases, attrs, **kwargs)
+        ret = type.__new__(mcs, name, bases, attrs, **kwargs)
+        super().__setattr__(ret, "__annotations__", ans)  # Since we disable this method, use super()
+        return ret
 
     # Disallow modification
 

{zstdlib-0.2.0 → zstdlib-0.3.2}/zstdlib/log/cute.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 from logging import CRITICAL, ERROR, WARNING, INFO, DEBUG, Formatter
 from collections import defaultdict
 from typing import TYPE_CHECKING

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

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: zstdlib
-Version: 0.2.0
+Version: 0.3.2
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib
 Keywords: remote,pipe
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Requires-Python: >=3.12
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file