zstdlib 0.6.0__tar.gz → 0.7.0__tar.gz

{zstdlib-0.6.0 → zstdlib-0.7.0}/PKG-INFO

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

{zstdlib-0.6.0 → zstdlib-0.7.0}/pyproject.toml

@@ -5,10 +5,10 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "zstdlib"
 classifiers = [
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.14",
-    "Development Status :: 5 - Production/Stable",
-    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+	"Programming Language :: Python :: 3",
+	"Programming Language :: Python :: 3.14",
+	"Development Status :: 5 - Production/Stable",
+	"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
 ]
 license = {text = "GPLv3"}
 description = "A set of useful python utilities"
@@ -39,12 +39,12 @@ attr = "zstdlib.__version__"
 ignore-paths = '^tests/.*$'
 [tool.pylint."MESSAGES CONTROL"]
 disable = [
-    "unnecessary-lambda-assignment",
-    "method-cache-max-size-none",
-    "missing-module-docstring",
-    "too-few-public-methods",
-    "line-too-long",
-    "invalid-name"
+	"unnecessary-lambda-assignment",
+	"method-cache-max-size-none",
+	"missing-module-docstring",
+	"too-few-public-methods",
+	"line-too-long",
+	"invalid-name"
 ]
 
 [tool.black]
@@ -54,10 +54,37 @@ target-version = ["py314"]
 [tool.ruff]
 line-length = 110
 [tool.ruff.lint]
-ignore=["E731", "I001"]
+ignore=[
+	"ANN401",
+	"D10", "D2", "D403", "D415",
+	"E731",
+	"I001",
+	"PLR0913", "PLR2004",
+	"S101",
+	"TID252",
+]
+extend-select = [
+	"ANN",
+	"ARG",
+	"ASYNC",
+	"C4",
+	"D",
+	"DTZ",
+	"PERF",
+	"PGH",
+	"PIE",
+	"PL",
+	"PTH",
+	"RET",
+	"S",
+	"SIM",
+	"TID"
+]
+[tool.ruff.lint.pydocstyle]
+convention = "google"
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401", "F403"]
-"tests/*" = ["DTZ005"]
+"tests/*" = ["DTZ005", "PGH003", "PLW0108"]
 
 [tool.bandit]
 skips = ["B101", "B104", "B201"]

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/log/base.py

@@ -1,6 +1,6 @@
+from contextlib import AbstractContextManager, contextmanager
+from collections.abc import Callable, Iterator
 from logging.handlers import QueueHandler
-from contextlib import contextmanager
-from collections.abc import Callable
 from typing import ClassVar, Any
 from threading import Lock
 import logging
@@ -8,7 +8,7 @@ import queue
 
 
 @contextmanager
-def _cml(logger: logging.Logger, exit_func: Callable[[], Any]):
+def _cml(logger: logging.Logger, exit_func: Callable[[], Any]) -> Iterator[logging.Logger]:
     try:
         yield logger
     finally:
@@ -16,9 +16,7 @@ def _cml(logger: logging.Logger, exit_func: Callable[[], Any]):
 
 
 class LeftBase:
-    """
-    A base class for tests that hijack loggers
-    """
+    """A base class for tests that hijack loggers"""
 
     _hijacked: ClassVar[set[logging.Logger]] = set()  # Set of all loggers that have ever been hijacked
     _qmap: ClassVar[dict[logging.Logger, queue.Queue[logging.LogRecord]]] = {}
@@ -28,9 +26,12 @@ class LeftBase:
     messages: ClassVar[dict[logging.Logger, list[str]]] = {}
 
     @classmethod
-    def hijack(cls, name: str, reuse: bool = False, fmt: logging.Formatter | None = None):
+    def hijack(
+        cls, name: str, reuse: bool = False, fmt: logging.Formatter | None = None
+    ) -> AbstractContextManager[logging.Logger]:
         """
-        :return: A logger configured to write to an internal queue
+        Returns:
+            A logger configured to write to an internal queue
         """
         log = logging.getLogger(name)
         q: queue.Queue[logging.LogRecord] = queue.Queue()
@@ -48,9 +49,10 @@ class LeftBase:
 
     @classmethod
     def _restore(cls, logger: logging.Logger) -> None:
-        """
-        Restore the logger and read all messages from the queue
-        :return: The messages stored by the logger queue
+        """Restore the logger and read all messages from the queue
+
+        Returns:
+            The messages stored by the logger queue
         """
         if len(logger.handlers) != 1 or not isinstance(qh := logger.handlers[0], QueueHandler):
             raise RuntimeError("Logger not hijacked")

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/log/test_trace.py

@@ -11,8 +11,7 @@ from .base import LeftBase
 class TestTrace(LeftBase, unittest.TestCase):
 
     def test_trace(self) -> None:
-        """
-        Avoid splitting up into multiple functions since trace.install() affects global state
+        """Avoid splitting up into multiple functions since trace.install() affects global state
         Keeping this as one function ensures that the tests are run in order
         """
         # Test bad installs

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/test_ansi.py

@@ -51,6 +51,15 @@ class TestAnsiColor(unittest.TestCase):
         self.assertEqual(f"\033[31;42m{msg}\033[0m", Color.red_bg_green(msg))
         self.assertEqual(f"\033[1;3;32;101m{msg}\033[0m", Color.bg_bright_red_bold_italic_green(msg))
 
+    def test_hash(self) -> None:
+        c1 = Color("black")
+        c2 = Color("black")
+        other = Color("blue")
+        self.assertEqual(c1, c2)
+        self.assertNotEqual(c1, other)
+        self.assertEqual(hash(c1), hash(c2))
+        self.assertNotEqual(hash(c1), hash(other))
+
 
 if __name__ == "__main__":
     unittest.main()

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/test_enum.py

@@ -1,4 +1,5 @@
 # pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable
+from typing import Self
 import unittest
 
 from zstdlib.enum import EnumType, Enum, entries, values, auto
@@ -63,7 +64,7 @@ class TestEnumType(unittest.TestCase):
             class ET1(metaclass=EnumType):
                 arg1: int = 1
 
-                def __init__(self):
+                def __init__(self) -> None:
                     pass
 
         with self.assertRaises(AttributeError):
@@ -71,8 +72,8 @@ class TestEnumType(unittest.TestCase):
             class ET2(metaclass=EnumType):
                 arg1: int = 1
 
-                def __new__(cls):
-                    pass
+                def __new__(cls) -> Self:
+                    return super().__new__(cls)
 
         class ET3(metaclass=EnumType):
             arg1: int = 0

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/test_frozen.py

@@ -1,5 +1,5 @@
-# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable,attribute-defined-outside-init
-from sys import version_info
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring
+from annotationlib import get_annotations
 import unittest
 
 from zstdlib.frozen import Freezable, frozen
@@ -7,22 +7,24 @@ from zstdlib.frozen import Freezable, frozen
 
 class TestFreezable(unittest.TestCase):
 
-    def test_unfrozen(self):
+    def test_unfrozen(self) -> None:
         class F1(Freezable):
-            pass
+            def __init__(self, a: int) -> None:
+                super().__init__()
+                self.a = a
 
-        f1 = F1()
-        f1.a = 1
+        f1 = F1(1)
         self.assertEqual(f1.a, 1)
         del f1.a
         self.assertIs(getattr(f1, "a", None), None)
 
-    def test_frozen(self):
+    def test_frozen(self) -> None:
         class F1(Freezable):
-            pass
+            def __init__(self, a: int) -> None:
+                super().__init__()
+                self.a = a
 
-        f1 = F1()
-        f1.a = 1
+        f1 = F1(1)
         f1.freeze()
         self.assertEqual(f1.a, 1)
         with self.assertRaises(AttributeError):
@@ -31,12 +33,13 @@ class TestFreezable(unittest.TestCase):
             del f1.a
         f1.freeze()  # Should not raise an error
 
-    def test_thaw(self):
+    def test_thaw(self) -> None:
         class F1(Freezable):
-            pass
+            def __init__(self, a: int) -> None:
+                super().__init__()
+                self.a = a
 
-        f1 = F1()
-        f1.a = 1
+        f1 = F1(1)
         f1.freeze()
         self.assertEqual(f1.a, 1)
         f1.thaw()
@@ -45,12 +48,13 @@ class TestFreezable(unittest.TestCase):
         del f1.a
         self.assertIs(getattr(f1, "a", None), None)
 
-    def test_permanent_freeze(self):
+    def test_permanent_freeze(self) -> None:
         class F1(Freezable):
-            pass
+            def __init__(self, a: int) -> None:
+                super().__init__()
+                self.a = a
 
-        f1 = F1()
-        f1.a = 1
+        f1 = F1(1)
         f1.freeze()  # To ensure that .freeze(permanent=True) works when already frozen too
         f1.freeze(permanent=True)
         f1.freeze(permanent=True)  # Should not raise an error
@@ -60,7 +64,7 @@ class TestFreezable(unittest.TestCase):
         with self.assertRaises(AttributeError):
             f1.a = 1
 
-    def test_properties(self):
+    def test_properties(self) -> None:
 
         class F1(Freezable):
             pass
@@ -78,10 +82,10 @@ class TestFreezable(unittest.TestCase):
 
 class TestFrozen(unittest.TestCase):
 
-    def test_frozen(self):
+    def test_frozen(self) -> None:
         @frozen
         class F1:
-            def __init__(self):
+            def __init__(self) -> None:
                 self.a = 1
                 self.b = 1
                 del self.b
@@ -94,34 +98,28 @@ class TestFrozen(unittest.TestCase):
         with self.assertRaises(AttributeError):
             del f1.a
 
-    def test_metadata(self):
+    def test_metadata(self) -> None:
         @frozen
         class F1:
             def __init__(self, a: int = 1, *, b: bool = False) -> None:
-                """
-                init doc
-                """
+                """init doc"""
 
         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>.F1.__init__")
-        self.assertTupleEqual(f1.__init__.__defaults__, (1,))
-        self.assertDictEqual(f1.__init__.__kwdefaults__, {"b": False})
-        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):
+        f1_init = f1.__init__  # type: ignore[misc]
+        self.assertEqual(f1_init.__doc__.strip(), "init doc")
+        self.assertEqual(f1_init.__name__, "__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(get_annotations(f1_init), {"a": int, "b": bool, "return": None})
+
+    def test_frozen_custom(self) -> None:
         @frozen("custom")
         class F1:
-            def __init__(self):
+            def __init__(self) -> None:
                 self.a = 1
 
-            def custom(self):
+            def custom(self) -> None:
                 self.a = 2
 
         f1 = F1()

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/test_io.py

@@ -1,3 +1,4 @@
+from typing import Any
 import tempfile
 import unittest
 
@@ -5,16 +6,14 @@ from zstdlib.io import ProtectedFile, BinaryIO, TextIO, io
 
 
 class RamFile(tempfile.SpooledTemporaryFile):
-    """
-    A file-like object that stores its contents in memory.
-    """
+    """A file-like object that stores its contents in memory."""
 
-    rollover = None  # type: ignore
+    rollover = NotImplemented  # Disallow rollover
 
-    def __init__(self, *args, mode: str = "w+", **kwargs):
+    def __init__(self, *args: Any, mode: str = "w+", **kwargs: Any) -> None:
         super().__init__(10**9, *args, mode=mode, **kwargs)
 
-    def load(self, x):
+    def load(self, x: str) -> None:
         self.write(x)
         self.flush()
         self.seek(self.tell() - len(x))
@@ -22,7 +21,7 @@ class RamFile(tempfile.SpooledTemporaryFile):
 
 class TestIO(unittest.TestCase):
 
-    def test_init(self):
+    def test_init(self) -> None:
         with RamFile(mode="wb+") as fb, RamFile() as fs:
             ts = TextIO(fs)
             tb = BinaryIO(fb)
@@ -33,7 +32,7 @@ class TestIO(unittest.TestCase):
             self.assertIs(ts, io(fs))
             self.assertIs(tb, io(fb))
 
-    def test_protected_file(self):
+    def test_protected_file(self) -> None:
         with RamFile() as f:
             p = ProtectedFile(f)
             self.assertIs(f, p.raw)
@@ -42,13 +41,13 @@ class TestIO(unittest.TestCase):
                 with self.assertRaises(AttributeError):
                     getattr(p, i)
 
-    def test_unread(self):
+    def test_unread(self) -> None:
         with RamFile() as raw:
             f = io(raw)
-            f.unread("hello")
+            f.unread("hello")  # type: ignore[arg-type]  # STF types as bytes regardless of mode :/
             self.assertEqual("hello", f._buffer)
 
-    def test_read(self):
+    def test_read(self) -> None:
         with RamFile() as raw:
             raw.load("foobaz")
             f = io(raw)
@@ -56,18 +55,18 @@ class TestIO(unittest.TestCase):
             self.assertEqual("fo", f.read(2))
             self.assertEqual("o", f.read(1))
             # Test read of buffer
-            f.unread("bar")
+            f.unread("bar")  # type: ignore[arg-type]  # STF types as bytes regardless of mode :/
             self.assertEqual("b", f.read(1))
             # Test read of file + buffer
-            f.unread("foob")
+            f.unread("foob")  # type: ignore[arg-type]  # STF types as bytes regardless of mode :/
             self.assertEqual("foobar", f.read(6))
-            f.unread("foobar")
+            f.unread("foobar")  # type: ignore[arg-type]  # STF types as bytes regardless of mode :/
             self.assertEqual("foobarbaz", f.read())
 
-    def test_peek(self):
+    def test_peek(self) -> None:
         with RamFile() as raw:
             f = io(raw)
-            f.unread("foo")
+            f.unread("foo")  # type: ignore[arg-type]  # STF types as bytes regardless of mode :/
             # Test peek of buffer
             for i in range(3):
                 self.assertEqual("fo", f.peek(2))
@@ -78,7 +77,7 @@ class TestIO(unittest.TestCase):
                 self.assertEqual("ba", f.peek(2))
             self.assertEqual("bar", f.read())
             # Test peek of both
-            f.unread("baz")
+            f.unread("baz")  # type: ignore[arg-type]  # STF types as bytes regardless of mode :/
             raw.load("qux")
             for i in range(3):
                 for k in range(5):

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/test_not_set.py

@@ -4,7 +4,7 @@ from zstdlib import NotSetType, NotSet
 
 
 class TestNotSet(unittest.TestCase):
-    def test_not_set(self):
+    def test_not_set(self) -> None:
         self.assertIsInstance(NotSetType, type)
         self.assertIsInstance(NotSet, NotSetType)
         self.assertIsNot(None, NotSet)

{zstdlib-0.6.0 → zstdlib-0.7.0}/tests/test_singleton.py

@@ -2,6 +2,7 @@
 from collections.abc import Callable
 from threading import Thread, Lock
 from datetime import datetime
+from typing import Any
 from time import sleep
 import unittest
 
@@ -32,12 +33,12 @@ class TestSingleton(unittest.TestCase):
         with self.assertRaises(TypeError):  # Not ok to define __init_subclass__ in Singleton
 
             class ST3(Singleton):
-                def __init_subclass__(cls, **kwargs):
+                def __init_subclass__(cls, **_: Any) -> None:
                     pass
 
-    def test_instance(self):
+    def test_instance(self) -> None:
         class ST(Singleton):
-            def __init__(self, _):
+            def __init__(self, _: Any) -> None:
                 pass
 
         self.assertTrue(issubclass(NoInstanceError, TypeError))
@@ -47,11 +48,10 @@ class TestSingleton(unittest.TestCase):
         self.assertIs(ST.instance(), obj)
 
         with self.assertRaises(TypeError):
-            ST.instance(4)
+            ST.instance(4)  # type: ignore[call-arg]
 
-    def test_multi_thread(self):
-        """
-        Ensure that Singleton is thread safe and that constructing an object doesn't delay other threads
+    def test_multi_thread(self) -> None:
+        """Ensure that Singleton is thread safe and that constructing an object doesn't delay other threads
         Technically this is more of a heuristic, but failing is extremely unlikely if this is thread safe
         Verifies that classes can construct concurrently, thread-safely, and only one instance is created
         """
@@ -96,11 +96,11 @@ class TestSingleton(unittest.TestCase):
 
         # Verify concurrent construction of ST1 and ST2
         class Fast(Singleton):
-            def __init__(self):
+            def __init__(self) -> None:
                 sleep(0.3)
 
         class Slow(Singleton):
-            def __init__(self):
+            def __init__(self) -> None:
                 sleep(0.8)
 
         run_all(simple("f1", Slow, 0), simple("f2", Fast, 0.2))
@@ -120,7 +120,7 @@ class TestSingleton(unittest.TestCase):
         class ST(Singleton):
             first = True
 
-            def __init__(self):
+            def __init__(self) -> None:
                 if self.first:
                     self.first = False
                     sleep(0.4)

{zstdlib-0.6.0 → zstdlib-0.7.0}/zstdlib/__init__.py

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

{zstdlib-0.6.0 → zstdlib-0.7.0}/zstdlib/ansi.py

@@ -10,9 +10,7 @@ _PREFIX = "\033["
 
 @unique
 class PureColor(Enum):
-    """
-    An enum of ansi color values
-    """
+    """An enum of ansi color values"""
 
     black = 30
     red = auto()
@@ -26,13 +24,13 @@ class PureColor(Enum):
 
 
 class RawColor:
-    """
-    A class that represents a color with all possible modifiers
-    """
+    """A class that represents a color with all possible modifiers"""
 
     __slots__ = ("background", "bright", "color", "value")
 
-    def __init__(self, color: PureColor | str | int, *, bright: bool = False, background: bool = False):
+    def __init__(
+        self, color: PureColor | str | int, *, bright: bool = False, background: bool = False
+    ) -> None:
         self.color = PureColor(getattr(PureColor, color) if isinstance(color, str) else color)
         self.bright = bright
         self.background = background
@@ -68,9 +66,7 @@ class RawColor:
 
 
 class _ColorMeta(type):
-    """
-    A metaclass that implements __getattr__ at the class level for Color
-    """
+    """A metaclass that implements __getattr__ at the class level for Color"""
 
     def __getattr__(cls, item: str) -> Color:
         try:
@@ -80,8 +76,7 @@ class _ColorMeta(type):
 
 
 class Color(metaclass=_ColorMeta):
-    """
-    Represents an Ansi color code; calling this on a string will apply the code to the string
+    """Represents an Ansi color code; calling this on a string will apply the code to the string
     Can be constructed via .factory; alternatively calling Color.<name> or Color(<name>) will
     automatically construct a color. Colors are constructed with attributes determined by
     splitting <name> on "_". Colors may be made bright by prepending "bright_" to the color name
@@ -104,10 +99,11 @@ class Color(metaclass=_ColorMeta):
     RESET: str = f"{_PREFIX}0m"
 
     def __init__(self, fmt: Self | RawColor | str = "", *, code: str = "") -> None:
-        """
-        Create a Color based on either the format or code, exactly one must be passed
-        :param fmt: A Color, RawColor, or string representation of this desired color
-        :param code: The ansi color code this object represents
+        """Create a Color based on either the format or code, exactly one must be passed
+
+        Args:
+            fmt: A Color, RawColor, or string representation of this desired color
+            code: The ansi color code this object represents
         """
         if fmt != "" and code != "":
             raise ValueError("code and fmt may not both be passed")
@@ -122,13 +118,15 @@ class Color(metaclass=_ColorMeta):
 
     def __call__(self, string: str) -> str:
         """
-        :return: The string color codes with the given ansi code
+        Returns:
+            The string color codes with the given ansi code
         """
         return f"{self.code}{string}{self.RESET}"
 
     def __add__(self, other: Self) -> Self:
         """
-        :return: A new color made by concatenating these two
+        Returns:
+            A new color made by concatenating these two
         """
         if not isinstance(other, type(self)):
             raise TypeError("Cannot add non-Color to Color")
@@ -136,22 +134,32 @@ class Color(metaclass=_ColorMeta):
 
     def __eq__(self, other: object) -> bool:
         """
-        :return: Whether the two colors are equal
+        Returns:
+            Whether the two colors are equal
         """
         return isinstance(other, type(self)) and self.code == other.code
 
+    def __hash__(self) -> int:
+        """
+        Returns:
+            A hash of the current color
+        """
+        return hash((type(self), self.code))
+
     def __repr__(self) -> str:
         """
-        :return: The ansi color code this object represents
+        Returns:
+            The ansi color code this object represents
         """
         return f"<Color {self.code!r}>"
 
     @classmethod
     def factory(
-        cls, *, foreground: RawColor | None = None, background: RawColor | None = None, **modifiers
+        cls, *, foreground: RawColor | None = None, background: RawColor | None = None, **modifiers: bool
     ) -> Self:
         """
-        :return: The Ansi given the chosen color and various modifiers
+        Returns:
+            The Ansi given the chosen color and various modifiers
         """
         return cls(code=_generate_code(foreground, background, modifiers))
 
@@ -160,7 +168,8 @@ def _generate_code(
     foreground: RawColor | None, background: RawColor | None, modifiers: dict[str, bool]
 ) -> str:
     """
-    :return: The Ansi given the chosen color and various modifiers
+    Returns:
+        The Ansi given the chosen color and various modifiers
     """
     if any(bad := [i for i in modifiers if i not in MODIFIERS]):
         raise ValueError(f"Unknown modifier(s): {bad}")