zstdlib 0.0.1__tar.gz → 0.0.3__tar.gz

{zstdlib-0.0.1/zstdlib.egg-info → zstdlib-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zstdlib
-Version: 0.0.1
+Version: 0.0.3
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib
@@ -12,3 +12,6 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+
+# zstdlib
+A set of useful python utilities

zstdlib-0.0.3/README.md

@@ -0,0 +1,2 @@
+# zstdlib
+A set of useful python utilities

{zstdlib-0.0.1 → zstdlib-0.0.3}/pyproject.toml

@@ -49,11 +49,16 @@ version = {attr = "zstdlib.__version__"}
 
 # Tools
 
+[tool.pylint.MASTER]
+ignore-paths = '^tests/.*$'
 [tool.pylint."MESSAGES CONTROL"]
 disable = [
+    "unnecessary-lambda-assignment",
+    "method-cache-max-size-none",
 	"missing-module-docstring",
-	"invalid-name",
-	"line-too-long"
+	"too-few-public-methods",
+	"line-too-long",
+	"invalid-name"
 ]
 
 [tool.black]
@@ -71,6 +76,6 @@ ignore=["E731"]
 skips = ["B101", "B104", "B201"]
 
 [tool.vulture]
-ignore_names = ["cli", "_help", "_show_version", "_channel", "strict_slashes"]
+ignore_names = []
 min_confidence = 70
 paths = ["zstdlib"]

zstdlib-0.0.3/tests/log/base.py

@@ -0,0 +1,69 @@
+from logging.handlers import QueueHandler
+from contextlib import contextmanager
+from collections.abc import Callable
+from threading import Lock
+from typing import Any
+import logging
+import queue
+
+
+@contextmanager
+def _cml(logger: logging.Logger, exit_func: Callable[[], Any]):
+    try:
+        yield logger
+    finally:
+        exit_func()
+
+
+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]] = {}
+    _lb_lock = Lock()
+
+    messages: 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
+        """
+        log = logging.getLogger(name)
+        q: queue.Queue[logging.LogRecord] = queue.Queue()
+        with cls._lb_lock:
+            if not reuse and log in cls._hijacked:
+                raise RuntimeError("Logger already hijacked")
+            cls._hijacked.add(log)
+            cls._lb_old[log] = log.handlers
+            cls._qmap[log] = q
+        log.handlers = [QueueHandler(q)]
+        if fmt is not None:
+            log.handlers[0].setFormatter(fmt)
+        log.setLevel(1)  # Not 0 to ensure that the parent logger level is not used
+        return _cml(log, lambda: cls._restore(log))
+
+    @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
+        """
+        if len(logger.handlers) != 1 or not isinstance(qh := logger.handlers[0], QueueHandler):
+            raise RuntimeError("Logger not hijacked")
+        # Restore old logger and extract q
+        with cls._lb_lock:
+            if logger not in cls._hijacked:
+                raise RuntimeError("Logger not hijacked")
+            logger.handlers = cls._lb_old.pop(logger)
+            q = cls._qmap.pop(logger)
+        # Read queue
+        qh.flush()
+        messages = []
+        while not q.empty():
+            messages.append(q.get(False).msg)
+        with cls._lb_lock:
+            cls.messages[logger] = messages

zstdlib-0.0.3/tests/log/test_cute.py

@@ -0,0 +1,98 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable
+import unittest
+
+from zstdlib.log import CuteFormatter
+from zstdlib.ansi import Color
+
+from .base import LeftBase
+
+
+class TestCuteFormatter(LeftBase, unittest.TestCase):
+
+    def test_hardcoded_colors(self) -> None:
+        color = Color.strikethrough_green
+        name = "TestCuteFormatter.test_hardcoded_colors"
+        with self.hijack(name, fmt=CuteFormatter(colors={name: color})) as log:
+            log.debug("test")
+        msg = self.messages[log][0].rsplit("|", 1)[-1]
+        self.assertEqual(f" {color.code}test{Color.RESET}", msg)
+
+    def test_name_width(self) -> None:
+        width = 123
+        color = Color.red
+        name = "TestCuteFormatter.name_width"
+        with self.hijack(name, fmt=CuteFormatter(colors={name: color}, name_width=width)) as log:
+            log.debug("test")
+        lvl, _, nam, msg = self.messages[log][0].split("|")
+        self.assertEqual("DEBUG", lvl.strip())
+        self.assertEqual(f" {color(name.ljust(width))} ", nam)
+        self.assertEqual(f" {color('test')}", msg)
+
+    def test_no_color(self) -> None:
+        name = "TestCuteFormatter.test_no_color"
+        with self.hijack(name, fmt=CuteFormatter(colored=False)) as log:
+            log.debug("test")
+        lvl, _, nam, msg = self.messages[log][0].split("|")
+        self.assertEqual("DEBUG", lvl.strip())
+        self.assertEqual(name, nam.strip())
+        self.assertEqual(" test", msg)
+
+    def test_edit_colors(self) -> None:
+        name = "TestCuteFormatter.edit_colors"
+        cf = CuteFormatter(colored=False)
+        color = Color.strikethrough_red
+        with self.hijack(name, fmt=cf) as log:
+            log.critical("test")
+        msg = self.messages[log][0].rsplit("|", 1)[-1]
+        self.assertEqual(" test", msg)
+        with self.hijack(name, reuse=True, fmt=cf) as log:
+            cf.colored = True
+            cf.update({name: color})
+            log.critical("test")
+        msg = self.messages[log][0].rsplit("|", 1)[-1]
+        self.assertEqual(f" {color.code}test{Color.RESET}", msg)
+
+    def test_level_color(self) -> None:
+        name = "TestCuteFormatter.test_level_color"
+        msg = "test"
+        levels = (5, 10, 20, 30, 40, 50, 60)
+        with self.hijack(name, fmt=CuteFormatter()) as log:
+            for i in levels:
+                log.log(i, msg)
+        self.assertEqual(len(levels), len(self.messages[log]))
+        l_name = lambda idx: self.messages[log][idx].split("|")[0].strip()
+        self.assertEqual(Color.dim("Level 5".ljust(8)), l_name(0))
+        self.assertEqual("DEBUG", l_name(1))
+        self.assertEqual(Color.blue("INFO".ljust(8)), l_name(2))
+        self.assertEqual(Color.yellow("WARNING".ljust(8)), l_name(3))
+        self.assertEqual(Color.red("ERROR".ljust(8)), l_name(4))
+        self.assertEqual(Color.bright_red_bg_yellow("CRITICAL".ljust(8)), l_name(5))
+        self.assertEqual(Color.bright_red_bg_yellow("Level 60".ljust(8)), l_name(6))
+
+    def test_exception(self) -> None:
+        name = "TestCuteFormatter.test_exception"
+        with self.hijack(name, fmt=CuteFormatter()) as log:
+            try:
+                raise ValueError(name)
+            except ValueError:
+                log.error("test", exc_info=True)
+        spt = self.messages[log][0].split("\n")
+        self.assertGreater(len(spt), 2)
+        self.assertEqual("Traceback (most recent call last):", spt[1].strip())
+        self.assertEqual("raise ValueError(name)", spt[-2].strip())
+        self.assertEqual(f"ValueError: {name}", spt[-1].strip())
+
+    def test_multi_color(self) -> None:
+        base = "TestCuteFormatter.test_multi_color."
+        cf = CuteFormatter()
+        messages: set[str] = set()
+        for i in range(100):
+            with self.hijack(f"{base}{i}", fmt=cf) as log:
+                log.info(base)
+            messages.add(self.messages[log][0].rsplit("|", 1)[-1].strip())
+        cols = ("red", "green", "yellow", "blue", "magenta", "cyan", "default")
+        self.assertSetEqual({getattr(Color, i)(base) for i in cols}, messages)
+
+
+if __name__ == "__main__":
+    unittest.main()

zstdlib-0.0.3/tests/log/test_trace.py

@@ -0,0 +1,74 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring
+import unittest
+import logging
+
+from zstdlib.log import trace
+
+from .base import LeftBase
+
+
+# mypy: disable_error_code="attr-defined"
+class TestTrace(LeftBase, unittest.TestCase):
+
+    def test_trace(self) -> None:
+        """
+        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
+        with self.assertRaises(ValueError):
+            trace.install(value=-1)
+        with self.assertRaises(ValueError):
+            trace.install(value=logging.DEBUG + 1)
+        logging.TRACE = None
+        with self.assertRaises(AttributeError):
+            trace.install()
+        del logging.TRACE
+        logging.trace = None
+        with self.assertRaises(AttributeError):
+            trace.install()
+        del logging.trace
+        logging.getLoggerClass().trace = None
+        with self.assertRaises(AttributeError):
+            trace.install()
+        del logging.getLoggerClass().trace
+        trace._State.start = True  # pylint: disable=protected-access
+        with self.assertRaises(RuntimeError):
+            trace.install()
+        trace._State.start = False  # pylint: disable=protected-access
+        # Good install
+        trace.install(value=5)
+        # Attribute check
+        self.assertTrue(hasattr(logging, "TRACE"))
+        self.assertTrue(hasattr(logging, "trace"))
+        self.assertTrue(hasattr(logging.getLogger(), "trace"))
+        self.assertEqual(logging.TRACE, 5)
+        self.assertEqual(logging.getLevelName(logging.TRACE), "TRACE")  # type: ignore[call-overload]
+        # Root check
+        with self.hijack("") as log:
+            old = log.getEffectiveLevel()
+            # pylint: disable=not-callable
+            logging.trace("test1")  # type: ignore[misc]
+            log.setLevel(logging.DEBUG)
+            # pylint: disable=not-callable
+            logging.trace("test2")  # type: ignore[misc]
+            log.setLevel(old)
+        self.assertEqual(self.messages[log], ["test1"])
+        # Logger check
+        with self.hijack("TestTrace.t1") as log:
+            old = log.getEffectiveLevel()
+            # pylint: disable=not-callable
+            log.trace("test3")
+            log.setLevel(logging.DEBUG)
+            # pylint: disable=not-callable
+            log.trace("test4")
+            log.setLevel(old)
+        self.assertEqual(self.messages[log], ["test3"])
+        # Test re-installation
+        with self.assertRaises(RuntimeError):
+            trace.install(value=5)
+        trace.install(value=5, force=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

zstdlib-0.0.3/tests/test_ansi.py

@@ -0,0 +1,56 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring
+import unittest
+
+from zstdlib.ansi import PureColor, RawColor, Color
+
+
+class TestAnsiColor(unittest.TestCase):
+
+    def test_raw_color(self) -> None:
+        msg = "Hello, World!"
+        for i, k in PureColor.__members__.items():
+            self.assertEqual(f"\033[{k.value}m{msg}\033[0m", getattr(Color, i)(msg))
+
+    def test_bright_background_color(self) -> None:
+        msg = "Hello, World!"
+        for i, k in PureColor.__members__.items():
+            self.assertEqual(f"\033[{k.value+70}m{msg}\033[0m", getattr(Color, f"bg_bright_{i}")(msg))
+
+    def test_init(self) -> None:
+        msg = "Hello, World!"
+        cname = "black"
+        c = RawColor(getattr(PureColor, cname))
+        self.assertEqual(f"\033[{c.value}m{msg}\033[0m", getattr(Color, cname)(msg))  # Sanity check
+        self.assertEqual(f"\033[{c.value}m{msg}\033[0m", Color(c)(msg))
+        self.assertEqual(f"\033[{c.value}m{msg}\033[0m", Color(c)(msg))
+        self.assertEqual(f"\033[{c.value}m{msg}\033[0m", Color(Color(c))(msg))
+        self.assertEqual(f"\033[{c.value}m{msg}\033[0m", Color(code=Color(c).code)(msg))
+        # Errors
+        with self.assertRaises(ValueError):
+            _ = Color("blue_blue")
+        with self.assertRaises(ValueError):
+            _ = Color("bg_blue_bg_bright_blue")
+        with self.assertRaises(ValueError):
+            _ = Color(fmt="1", code="1")
+        with self.assertRaises(ValueError):
+            _ = Color(code="1")
+        with self.assertRaises(ValueError):
+            _ = Color("bright_bg_red")
+        # Error converted
+        with self.assertRaises(AttributeError):
+            _ = Color.bright_bg_red
+
+    def test_modifiers(self) -> None:
+        msg = "Hello, World!"
+        self.assertEqual(f"\033[1;34m{msg}\033[0m", Color.bold_blue(msg))  # Small modifier
+        self.assertEqual(f"\033[9;32m{msg}\033[0m", Color.strikethrough_green(msg))  # Large modifier
+        self.assertEqual(f"\033[2;9;31m{msg}\033[0m", Color.strikethrough_dim_red(msg))
+        self.assertEqual(f"\033[3;4;5;39m{msg}\033[0m", Color.underline_italic_blinking_default(msg))
+        # Test no colors / multiple colors
+        self.assertEqual(f"\033[1m{msg}\033[0m", Color.bold(msg))
+        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))
+
+
+if __name__ == "__main__":
+    unittest.main()

zstdlib-0.0.3/tests/test_enum.py

@@ -0,0 +1,137 @@
+# 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(NotImplementedError):
+            ET10()
+        with self.assertRaises(NotImplementedError):
+            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(NotImplementedError):
+            E10()
+        with self.assertRaises(NotImplementedError):
+            E10.__init__({})
+
+
+if __name__ == "__main__":
+    unittest.main()

zstdlib-0.0.3/tests/test_frozen.py

@@ -0,0 +1,80 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable,attribute-defined-outside-init
+import unittest
+
+from zstdlib.frozen import Freezable, frozen
+
+
+class TestFreezable(unittest.TestCase):
+
+    def test_unfrozen(self):
+        class F1(Freezable):
+            pass
+
+        f1 = F1()
+        f1.a = 1
+        self.assertEqual(f1.a, 1)
+        del f1.a
+        self.assertIs(getattr(f1, "a", None), None)
+
+    def test_frozen(self):
+        class F1(Freezable):
+            pass
+
+        f1 = F1()
+        f1.a = 1
+        f1.freeze()
+        self.assertEqual(f1.a, 1)
+        with self.assertRaises(AttributeError):
+            f1.a = 2
+        with self.assertRaises(AttributeError):
+            del f1.a
+
+    def test_thaw(self):
+        class F1(Freezable):
+            pass
+
+        f1 = F1()
+        f1.a = 1
+        f1.freeze()
+        self.assertEqual(f1.a, 1)
+        f1.thaw()
+        f1.a = 2
+        self.assertEqual(f1.a, 2)
+        del f1.a
+        self.assertIs(getattr(f1, "a", None), None)
+
+    def test_permanent_freeze(self):
+        class F1(Freezable):
+            pass
+
+        f1 = F1()
+        f1.a = 1
+        f1.freeze(permanent=True)
+        self.assertEqual(f1.a, 1)
+        with self.assertRaises(RuntimeError):
+            f1.thaw()
+        with self.assertRaises(AttributeError):
+            f1.a = 1
+
+
+class TestFrozen(unittest.TestCase):
+
+    def test_frozen(self):
+        @frozen
+        class F1:
+            def __init__(self):
+                self.a = 1
+                self.b = 1
+                del self.b
+
+        f1 = F1()
+        self.assertEqual(f1.a, 1)
+        self.assertIs(getattr(f1, "b", None), None)
+        with self.assertRaises(AttributeError):
+            f1.a = 1
+        with self.assertRaises(AttributeError):
+            del f1.a
+
+
+if __name__ == "__main__":
+    unittest.main()

zstdlib-0.0.3/tests/test_singleton.py

@@ -0,0 +1,126 @@
+# pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable
+from threading import Thread, Lock
+from time import sleep
+import unittest
+
+from zstdlib.singleton import SingletonType, Singleton
+
+
+class TestSingletonType(unittest.TestCase):
+
+    def test_valid(self) -> None:
+        class ST1(metaclass=SingletonType):
+            pass
+
+        self.assertIs(ST1(), ST1())
+
+        class ST2(metaclass=SingletonType):
+            pass
+
+        self.assertIsNot(ST1(), ST2())
+
+    def test_subclass(self) -> None:
+        class ST3(metaclass=SingletonType):
+            pass
+
+        with self.assertRaises(NotImplementedError):
+
+            class ST4(ST3):
+                pass
+
+    def test_multi_thread(self):
+        """
+        Ensure that SingletonType is thread safe and that constructing an object doesn't delay other threads
+        Technically this is more of a heuristic, but it failing is extremely unlikely
+        """
+
+        class ST5(metaclass=SingletonType):
+            def __init__(self):
+                sleep(0.2)
+
+        class ST6(metaclass=SingletonType):
+            def __init__(self):
+                sleep(0.8)
+
+        lock = Lock()
+        events = []
+        results = []
+
+        def t1() -> None:
+            """
+            Construct an ST6 immediately
+            """
+            with lock:
+                pass
+            events.append("START: ST6()")
+            results.append(ST6())
+            events.append("END: ST6()")
+
+        def t2() -> None:
+            """
+            Construct an ST6 after the first ST6 has started construction but before it has finished
+            """
+            with lock:
+                pass
+            sleep(0.2)
+            events.append("START: ST6()")
+            results.append(ST6())
+            events.append("END: ST6()")
+
+        def t3() -> None:
+            """
+            Construct ST5's after both ST6s have started construction, finishing before either end
+            """
+            with lock:
+                pass
+            sleep(0.4)
+            # Loop Enough times that ST6 wil be complete if it ST5 actually constructed each time
+            for i in range(10):
+                events.append("START: ST5()")
+                results.append(ST5())
+                events.append("END: ST5()")
+
+        threads = (Thread(target=t1), Thread(target=t2), Thread(target=t3))
+        with lock:
+            for i in threads:
+                i.start()
+            # Give threads a moment to construct then let them go
+            sleep(0.2)
+        for i in threads:
+            i.join()
+        # Check results
+        wanted = ["START: ST6()"] * 2 + ["START: ST5()", "END: ST5()"] * 10 + ["END: ST6()"] * 2
+        self.assertEqual(events, wanted)
+        # Check constructed objects
+        self.assertEqual(len(results), 2 + 10)
+        for i in range(9):
+            self.assertIs(results[0], results[i + 1])
+        self.assertIsNot(results[0], results[-1])
+        self.assertIs(results[-1], results[-2])
+
+
+class TestSingleton(unittest.TestCase):
+
+    def test_valid(self):
+        class S1(Singleton):
+            pass
+
+        self.assertIs(S1(), S1())
+
+        class S2(Singleton):
+            pass
+
+        self.assertIsNot(S1(), S2())
+
+    def test_subclass(self):
+        class S3(Singleton):
+            pass
+
+        with self.assertRaises(NotImplementedError):
+
+            class S4(S3):
+                pass
+
+
+if __name__ == "__main__":
+    unittest.main()