zstdlib 0.6.0__tar.gz → 0.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zstdlib
-Version: 0.6.0
+Version: 0.8.0
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib
@@ -11,6 +11,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: osascript2
 Dynamic: license-file
 
 # zstdlib

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

@@ -5,16 +5,19 @@ 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"
 urls = {Homepage = "https://github.com/zwimer/zstdlib"}
 requires-python = ">= 3.14"
 dynamic = ["version"]
+dependencies = [
+	"osascript2"  # For macOS
+]
 
 [project.readme]
 file = "README.md"
@@ -39,12 +42,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,13 +57,40 @@ 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", "S603",
+	"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"]
+skips = ["B101", "B104", "B201", "B404", "B603"]
 
 [tool.vulture]
 ignore_names = []

{zstdlib-0.6.0 → zstdlib-0.8.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,13 @@ class LeftBase:
     messages: ClassVar[dict[logging.Logger, list[str]]] = {}
 
     @classmethod
-    def hijack(cls, name: str, reuse: bool = False, fmt: logging.Formatter | None = None):
-        """
-        :return: A logger configured to write to an internal queue
+    def hijack(
+        cls, name: str, reuse: bool = False, fmt: logging.Formatter | None = None
+    ) -> AbstractContextManager[logging.Logger]:
+        """Create a hijacked logger
+
+        Returns:
+            A logger configured to write to an internal queue
         """
         log = logging.getLogger(name)
         q: queue.Queue[logging.LogRecord] = queue.Queue()
@@ -48,9 +50,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.8.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.8.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.8.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.8.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.8.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.8.0/tests/test_lazy.py

@@ -0,0 +1,25 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring
+import unittest
+
+from zstdlib.lazy import Str
+
+
+def _append(buf: list[str], *, obj: str) -> str:
+    buf.append(obj)
+    return str(len(buf))
+
+
+class TestLazy(unittest.TestCase):
+
+    def test_str(self) -> None:
+        buf: list[str] = []
+        obj = "apples"
+        x = Str(_append, buf, obj=obj)
+        self.assertEqual(buf, [])
+        one = str(x)  # Invoke Lazy Str
+        self.assertEqual(one, "1")
+        self.assertEqual(buf, [obj])
+
+
+if __name__ == "__main__":
+    unittest.main()

{zstdlib-0.6.0 → zstdlib-0.8.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.8.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.8.0}/zstdlib/__init__.py

@@ -1,11 +1,11 @@
-__version__ = "0.6.0"
+__version__ = "0.8.0"
 
 from .not_set import NotSetType, NotSet
 from .frozen import Freezable, frozen
 from .singleton import Singleton
 from .signal_cm import signal_cm
 from .enum import Enum, auto
-from . import log, io
+from . import macos, lazy, log, io
 
 __all__ = (
     "Enum",
@@ -16,6 +16,8 @@ __all__ = (
     "auto",
     "frozen",
     "io",
+    "lazy",
     "log",
+    "macos",
     "signal_cm",
 )