zstdlib 0.3.0__tar.gz → 0.4.0__tar.gz

{zstdlib-0.3.0 → zstdlib-0.4.0}/PKG-INFO

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

{zstdlib-0.3.0 → zstdlib-0.4.0}/pyproject.toml

@@ -50,14 +50,15 @@ disable = [
 
 [tool.black]
 line-length = 110
-target-version = ["py313"]   # py314 when available
+target-version = ["py314"]
 
 [tool.ruff]
 line-length = 110
 [tool.ruff.lint]
-ignore=["E731"]
+ignore=["E731", "I001"]
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401", "F403"]
+"tests/*" = ["DTZ005"]
 
 [tool.bandit]
 skips = ["B101", "B104", "B201"]

{zstdlib-0.3.0 → zstdlib-0.4.0}/tests/log/base.py

@@ -1,8 +1,8 @@
 from logging.handlers import QueueHandler
 from contextlib import contextmanager
 from collections.abc import Callable
+from typing import ClassVar, Any
 from threading import Lock
-from typing import Any
 import logging
 import queue
 
@@ -20,12 +20,12 @@ class LeftBase:
     A base class for tests that hijack loggers
     """
 
-    _hijacked: set[logging.Logger] = set()  # Set of all loggers that have ever been hijacked
-    _qmap: dict[logging.Logger, queue.Queue[logging.LogRecord]] = {}
-    _lb_old: dict[logging.Logger, list[logging.Handler]] = {}
+    _hijacked: ClassVar[set[logging.Logger]] = set()  # Set of all loggers that have ever been hijacked
+    _qmap: ClassVar[dict[logging.Logger, queue.Queue[logging.LogRecord]]] = {}
+    _lb_old: ClassVar[dict[logging.Logger, list[logging.Handler]]] = {}
     _lb_lock = Lock()
 
-    messages: dict[logging.Logger, list[str]] = {}
+    messages: ClassVar[dict[logging.Logger, list[str]]] = {}
 
     @classmethod
     def hijack(cls, name: str, reuse: bool = False, fmt: logging.Formatter | None = None):

{zstdlib-0.3.0 → zstdlib-0.4.0}/tests/log/test_cute.py

@@ -106,7 +106,7 @@ class TestCuteFormatter(LeftBase, unittest.TestCase):
             try:
                 raise ValueError(name)
             except ValueError:
-                log.error("test", exc_info=True)
+                log.exception("test")
         spt = self.messages[log][0].split("\n")
         self.assertGreater(len(spt), 2)
         self.assertEqual("Traceback (most recent call last):", spt[1].strip())

{zstdlib-0.3.0 → zstdlib-0.4.0}/tests/test_enum.py

@@ -24,7 +24,7 @@ class TestEnumType(unittest.TestCase):
         class ET1(metaclass=EnumType, dupes_ok=True):
             a: int = 5
             b: int = 5
-            c: dict = {}
+            c: dict = {}  # noqa: RUF012
 
         with self.assertRaises(ValueError):
 
@@ -35,7 +35,7 @@ class TestEnumType(unittest.TestCase):
         with self.assertRaises(TypeError):
 
             class ET3(metaclass=EnumType):
-                a: dict = {}
+                a: dict = {}  # noqa: RUF012
 
     def test_type_check(self) -> None:
         class ET1(metaclass=EnumType, type_check=set()):

{zstdlib-0.3.0 → zstdlib-0.4.0}/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, 0.1) 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.3.0 → zstdlib-0.4.0}/zstdlib/__init__.py

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

{zstdlib-0.3.0 → zstdlib-0.4.0}/zstdlib/ansi.py

@@ -3,7 +3,6 @@ from functools import cache
 from typing import Self
 import re
 
-
 MODIFIERS = ("bold", "dim", "italic", "underline", "blinking", "inverse", "hidden", "strikethrough")
 
 _PREFIX = "\033["
@@ -31,7 +30,7 @@ class RawColor:
     A class that represents a color with all possible modifiers
     """
 
-    __slots__ = ("color", "bright", "background", "value")
+    __slots__ = ("background", "bright", "color", "value")
 
     def __init__(self, color: PureColor | str | int, *, bright: bool = False, background: bool = False):
         self.color = PureColor(getattr(PureColor, color) if isinstance(color, str) else color)
@@ -39,15 +38,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 +118,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:
         """
@@ -117,7 +144,7 @@ class Color(metaclass=_ColorMeta):
         """
         :return: The ansi color code this object represents
         """
-        return f"<Color {repr(self.code)}>"
+        return f"<Color {self.code!r}>"
 
     @classmethod
     def factory(
@@ -145,34 +172,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.3.0 → zstdlib-0.4.0}/zstdlib/enum.py

@@ -1,5 +1,5 @@
 from collections.abc import Iterator
-from typing import ForwardRef, Any
+from typing import ClassVar, Any
 import annotationlib
 
 
@@ -22,7 +22,7 @@ class EnumType(type):
     """
 
     _AUTO_PREFIX = "Enum_Auto_"
-    _TC_DEFAULT: set[type | None] = {int, str, float, bool, complex, bytes, None, type(None)}
+    _TC_DEFAULT: ClassVar[set[type | None]] = {int, str, float, bool, complex, bytes, None, type(None)}
 
     class _AutoValue:
         """A class representing an automatically assigned enum value"""
@@ -41,7 +41,7 @@ class EnumType(type):
         mcs,
         attrs: dict,
         dupes_ok: bool,
-        ans: dict[str, type | ForwardRef],
+        ans: dict[str, type | None],
     ) -> dict[str, tuple[type | None, Any]]:
         """
         Generate enum entries from attrs, checking for duplicates and missing annotations
@@ -163,4 +163,4 @@ def values(enum: Any) -> tuple[Any, ...]:
     return tuple(k[1] for k in enum.__entries__.values())  # type: ignore[attr-defined]
 
 
-__all__ = ("Enum", "EnumType", "entries", "values", "auto")
+__all__ = ("Enum", "EnumType", "auto", "entries", "values")

{zstdlib-0.3.0 → zstdlib-0.4.0}/zstdlib/frozen.py

@@ -1,6 +1,5 @@
 from collections.abc import Callable
 
-
 _FN_ATTRS = (
     "__annotations__",
     "__type_params__",

{zstdlib-0.3.0 → zstdlib-0.4.0}/zstdlib/io.py

@@ -1,19 +1,10 @@
-from io import (
-    IOBase,
-    TextIOBase as _PyRawTextIOBase,
-    RawIOBase as _PyRawIOBase,
-    BufferedIOBase as _PyBufferedIOBase,
-)
+from io import BufferedIOBase, TextIOBase, RawIOBase, IOBase
+from weakref import WeakKeyDictionary
 from threading import RLock
 from itertools import chain
 from typing import Self
-import weakref
 
-
-__all__ = ("TextIO", "BinaryIO", "io")
-
-type _BinaryBase = _PyRawIOBase | _PyBufferedIOBase
-type _TextBase = _PyRawTextIOBase
+__all__ = ("BinaryIO", "TextIO", "io")
 
 
 class ProtectedFile:
@@ -52,8 +43,8 @@ class _IOWrapperBase[T: (str, bytes)]:
     Note: This class takes ownership of the input object, do not use it elsewhere
     """
 
-    __slots__ = ("lock", "f", "_buffer", "_eof")
-    _instances: weakref.WeakKeyDictionary[IOBase, Self] = weakref.WeakKeyDictionary()
+    __slots__ = ("_buffer", "_eof", "f", "lock")
+    _instances: WeakKeyDictionary[IOBase, Self] = WeakKeyDictionary()
     _wr_lock = RLock()
 
     def __new__(cls, f: IOBase, binary: bool) -> Self:
@@ -189,8 +180,8 @@ class _IOWrapperBase[T: (str, bytes)]:
 
 def _mode(f: IOBase, binary: bool | None) -> bool:
     mode = getattr(f, "mode", "")
-    binary = binary or "b" in mode or isinstance(f, (_PyRawIOBase, _PyBufferedIOBase))
-    text = (binary is False) or (mode and "b" not in mode) or isinstance(f, _PyRawTextIOBase)
+    binary = binary or "b" in mode or isinstance(f, (RawIOBase, BufferedIOBase))
+    text = (binary is False) or (mode and "b" not in mode) or isinstance(f, TextIOBase)
     if not text and not binary:
         raise TypeError("Cannot determine if IO object is text or binary")
     if text and binary:

{zstdlib-0.3.0 → zstdlib-0.4.0}/zstdlib/log/cute.py

@@ -1,7 +1,6 @@
-from __future__ import annotations
 from logging import CRITICAL, ERROR, WARNING, INFO, DEBUG, Formatter
+from typing import TYPE_CHECKING, ClassVar
 from collections import defaultdict
-from typing import TYPE_CHECKING
 from zlib import adler32
 from copy import copy
 
@@ -16,9 +15,9 @@ class CuteFormatter(Formatter):
     A log formatter that can print log messages with colors.
     """
 
-    __slots__ = ("colored", "_color", "_cmap", "_lvl_cmap", "_dim_level", "_name_width")
-    DEFAULT_CUTE_WIDTHS: dict[str, int] = {"cute_levelname": 8, "cute_time": 23, "cute_name": 12}
-    DEFAULT_LEVEL_COLORS: dict[int, Color] = {
+    __slots__ = ("_cmap", "_color", "_dim_level", "_lvl_cmap", "_name_width", "colored")
+    DEFAULT_CUTE_WIDTHS: ClassVar[dict[str, int]] = {"cute_levelname": 8, "cute_time": 23, "cute_name": 12}
+    DEFAULT_LEVEL_COLORS: ClassVar[dict[int, Color]] = {
         INFO: Color.blue,
         WARNING: Color.yellow,
         ERROR: Color.red,
@@ -32,9 +31,9 @@ class CuteFormatter(Formatter):
         *args,
         colored: bool = True,
         dim_level: int = DEBUG,
-        colors: dict[str, Color] = {},
-        level_colors: dict[int, Color] = {},
-        cute_widths: dict[str, int] = {},
+        colors: dict[str, Color] | None = None,
+        level_colors: dict[int, Color] | None = None,
+        cute_widths: dict[str, int] | None = None,
         **kwargs,
     ):
         """
@@ -52,6 +51,9 @@ class CuteFormatter(Formatter):
         :param cute_widths: The widths of the cute_ columns in the log message
         :param kwargs: Passed to logging.Formatter
         """
+        colors = {} if colors is None else colors
+        level_colors = {} if level_colors is None else level_colors
+        cute_widths = {} if cute_widths is None else cute_widths
         super().__init__(fmt, *args, **kwargs)
         self._dim_level: int = dim_level
         self._cmap: dict[str, Color] = dict(colors)

{zstdlib-0.3.0 → zstdlib-0.4.0}/zstdlib/log/trace.py

@@ -46,7 +46,7 @@ def _define_logging_trace(method: str, value: int) -> None:
         has no handlers, call basicConfig() to add a console handler with a
         pre-defined format.
         """
-        logging.log(value, msg, *args, **kwargs)
+        logging.log(value, msg, *args, **kwargs)  # noqa: LOG015
 
     setattr(logging, method, trace)
 

{zstdlib-0.3.0 → zstdlib-0.4.0}/zstdlib/singleton.py

@@ -1,9 +1,8 @@
-from typing import TypeVar, Self, Any, cast
+from typing import ClassVar, TypeVar, Self, Any, cast
 from collections import defaultdict
 from threading import RLock
 from functools import cache
 
-
 T = TypeVar("T")
 
 
@@ -26,9 +25,9 @@ class _SingletonType(type):
     """
 
     _disallow_init_subclass = False  # If True, disallow __init_subclass__ in __new__'s attrs
-    _instances: dict[type, Any] = {}  # Fully constructed and initialized singleton types
+    _instances: ClassVar[dict[type, Any]] = {}  # Fully constructed and initialized singleton types
     # Lock is preferred to RLock, but could deadlock if user write a constructor that invokes itself
-    _cls_locks: dict[type, RLock] = defaultdict(RLock)
+    _cls_locks: ClassVar[dict[type, RLock]] = defaultdict(RLock)
     _lock = RLock()
 
     def __new__(mcs, name, bases, attrs, **kwargs):

{zstdlib-0.3.0 → zstdlib-0.4.0}/zstdlib.egg-info/PKG-INFO

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