zstdlib 0.0.2__tar.gz → 0.0.4__tar.gz

{zstdlib-0.0.2/zstdlib.egg-info → zstdlib-0.0.4}/PKG-INFO

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

{zstdlib-0.0.2 → zstdlib-0.0.4}/tests/log/test_cute.py

@@ -77,7 +77,7 @@ class TestCuteFormatter(LeftBase, unittest.TestCase):
             except ValueError:
                 log.error("test", exc_info=True)
         spt = self.messages[log][0].split("\n")
-        self.assertTrue(len(spt) > 2)
+        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())
@@ -91,7 +91,7 @@ class TestCuteFormatter(LeftBase, unittest.TestCase):
                 log.info(base)
             messages.add(self.messages[log][0].rsplit("|", 1)[-1].strip())
         cols = ("red", "green", "yellow", "blue", "magenta", "cyan", "default")
-        self.assertEqual({getattr(Color, i)(base) for i in cols}, messages)
+        self.assertSetEqual({getattr(Color, i)(base) for i in cols}, messages)
 
 
 if __name__ == "__main__":

{zstdlib-0.0.2 → zstdlib-0.0.4}/tests/test_enum.py

@@ -1,7 +1,7 @@
 # pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring,unused-variable
 import unittest
 
-from zstdlib import EnumType, Enum
+from zstdlib.enum import EnumType, Enum
 
 
 class TestEnumType(unittest.TestCase):

zstdlib-0.0.4/tests/test_frozen.py

@@ -0,0 +1,109 @@
+# 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
+
+    def test_metadata(self):
+        @frozen
+        class F2:
+            def __init__(self):
+                """
+                init doc
+                """
+
+        f2 = F2()
+        self.assertEqual(f2.__init__.__doc__.strip(), "init doc")
+        self.assertEqual(f2.__init__.__name__, "__init__")
+        self.assertEqual(f2.__init__.__qualname__, "TestFrozen.test_metadata.<locals>.F2.__init__")
+
+    def test_frozen_custom(self):
+        @frozen("custom")
+        class F3:
+            def __init__(self):
+                self.a = 1
+
+            def custom(self):
+                self.a = 2
+
+        f3 = F3()
+        self.assertEqual(f3.a, 1)
+        f3.custom()
+        self.assertEqual(f3.a, 2)
+        with self.assertRaises(AttributeError):
+            f3.a = 1
+
+
+if __name__ == "__main__":
+    unittest.main()

{zstdlib-0.0.2 → zstdlib-0.0.4}/tests/test_singleton.py

@@ -3,7 +3,7 @@ from threading import Thread, Lock
 from time import sleep
 import unittest
 
-from zstdlib import SingletonType, Singleton
+from zstdlib.singleton import SingletonType, Singleton
 
 
 class TestSingletonType(unittest.TestCase):

zstdlib-0.0.4/zstdlib/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.0.4"
+
+from .frozen import Freezable, frozen
+from .singleton import Singleton
+from .enum import Enum
+from . import log

zstdlib-0.0.4/zstdlib/frozen.py

@@ -0,0 +1,87 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+
+class Freezable:
+    """
+    A base class for objects that can be frozen
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)  # For MRO super classes
+        if hasattr(self, "_frozen") or hasattr(self, "_can_thaw"):
+            raise ValueError("Base class defines _frozen or _can_thaw")
+        self._can_thaw: bool = True
+        self._frozen: bool = False
+
+    def freeze(self, *, permanent: bool = False):
+        """
+        Prevent further modifications to this object
+        """
+        if permanent:
+            self._can_thaw = False
+        self._frozen = True
+
+    def thaw(self):
+        """
+        Allow modifications to this object
+        """
+        if not self._can_thaw:
+            raise RuntimeError("Cannot thaw permanently frozen object")
+        object.__setattr__(self, "_frozen", False)
+
+    def __setattr__(self, key: str, value) -> None:
+        if getattr(self, "_frozen", False):
+            raise AttributeError("Cannot modify frozen object")
+        super().__setattr__(key, value)
+
+    def __delattr__(self, item: str) -> None:
+        if getattr(self, "_frozen", False):
+            raise AttributeError("Cannot modify frozen object")
+        super().__delattr__(item)
+
+
+_SELF = TypeVar("_SELF")
+
+
+def frozen(arg: str | type[_SELF]):
+    """
+    A class decorator to permanently freeze a class after some method, __init__ by default
+    If passed a string, will freeze after the method with that name
+    """
+
+    def shim_method(cls: type[_SELF], name, new) -> None:
+        original = getattr(cls, name)
+        new.__qualname__ = original.__qualname__
+        new.__name__ = original.__name__
+        new.__doc__ = original.__doc__
+        setattr(cls, name, new)
+
+    def mk_frozen(cls: type[_SELF], method: str) -> type:
+        original_method: Callable = getattr(cls, method)
+
+        def new_method(self: _SELF, *args, **kwargs):
+            ret = original_method(self, *args, **kwargs)
+            # pylint: disable=protected-access
+            self._frozen = True  # type: ignore[attr-defined]
+            return ret
+
+        def __setattr__(self: _SELF, key: str, value) -> None:
+            if getattr(self, "_frozen", False):
+                raise AttributeError("Cannot modify frozen object")
+            super(cls, self).__setattr__(key, value)  # type: ignore[misc]
+
+        def __delattr__(self: _SELF, item: str) -> None:
+            if getattr(self, "_frozen", False):
+                raise AttributeError("Cannot modify frozen object")
+            super(cls, self).__delattr__(item)  # type: ignore[misc]
+
+        # Update cls with the new methods
+        shim_method(cls, method, new_method)
+        shim_method(cls, "__delattr__", __delattr__)
+        shim_method(cls, "__setattr__", __setattr__)
+        return cls
+
+    if isinstance(arg, str):
+        return lambda cls: mk_frozen(cls, arg)
+    return mk_frozen(arg, "__init__")

{zstdlib-0.0.2 → zstdlib-0.0.4}/zstdlib/singleton.py

@@ -7,10 +7,8 @@ class SingletonType(type):
     A thread-safe singleton metaclass
     """
 
-    _seen: set[type] = (
-        set()
-    )  # Objects in this have been seen by singleton before and should not be constructed again
-    _instances: dict[type, Any] = {}  # Fully constructed singleton objects
+    _seen: set[type] = set()  # Types that should not be constructed again
+    _instances: dict[type, Any] = {}  # Fully constructed and initialized singleton types
     _lock = Condition()
     # For preventing subclassing of Singletons
     _types: list[type] = []
@@ -21,7 +19,7 @@ class SingletonType(type):
         Intercept all class definitions to prevent subclassing singleton types except for Singleton
         """
         if "__init_subclass__" in attrs:
-            raise NotImplementedError("Singleton's should not be subclassed")
+            raise NotImplementedError("Singleton's should not be subclassed or implement __init_subclass__")
 
         def _init_subclass(cls):
             with mcs._types_lock:
@@ -46,7 +44,7 @@ class SingletonType(type):
                 cls._lock.wait_for(lambda: cls in cls._instances)
                 return cls._instances[cls]
             cls._seen.add(cls)
-        # The object has not been constructed before, create it outside of any lock to avoid delays
+        # The object has not been constructed before, create it outside any lock to avoid delays
         obj = super().__call__(*args, **kwargs)
         with cls._lock:
             cls._instances[cls] = obj

{zstdlib-0.0.2 → zstdlib-0.0.4/zstdlib.egg-info}/PKG-INFO

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

{zstdlib-0.0.2 → zstdlib-0.0.4}/zstdlib.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 tests/__init__.py
 tests/test_ansi.py
 tests/test_enum.py
+tests/test_frozen.py
 tests/test_singleton.py
 tests/log/__init__.py
 tests/log/base.py
@@ -12,6 +13,7 @@ tests/log/test_trace.py
 zstdlib/__init__.py
 zstdlib/ansi.py
 zstdlib/enum.py
+zstdlib/frozen.py
 zstdlib/py.typed
 zstdlib/singleton.py
 zstdlib.egg-info/PKG-INFO

zstdlib-0.0.2/zstdlib/__init__.py

@@ -1,5 +0,0 @@
-__version__ = "0.0.2"
-
-from .singleton import SingletonType, Singleton
-from .enum import EnumType, Enum
-from . import log