zstdlib 0.0.3__tar.gz → 0.0.5__tar.gz

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

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

{zstdlib-0.0.3 → zstdlib-0.0.5}/tests/test_frozen.py

@@ -75,6 +75,38 @@ class TestFrozen(unittest.TestCase):
         with self.assertRaises(AttributeError):
             del f1.a
 
+    def test_metadata(self):
+        @frozen
+        class F2:
+            def __init__(self, a: int = 1, *, b: bool = False) -> None:
+                """
+                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__")
+        self.assertTupleEqual(f2.__init__.__defaults__, (1,))
+        self.assertDictEqual(f2.__init__.__kwdefaults__, {"b": False})
+        self.assertDictEqual(f2.__init__.__annotations__, {"a": int, "b": bool, "return": None})
+
+    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.3 → zstdlib-0.0.5}/zstdlib/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.3"
+__version__ = "0.0.5"
 
 from .frozen import Freezable, frozen
 from .singleton import Singleton

zstdlib-0.0.5/zstdlib/frozen.py

@@ -0,0 +1,97 @@
+from collections.abc import Callable
+
+
+_FN_ATTRS = (
+    "__annotations__",
+    "__type_params__",
+    "__qualname__",
+    "__module__",
+    "__name__",
+    "__doc__",
+    "__defaults__",
+    "__kwdefaults__",
+)
+
+
+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)
+
+
+def frozen(arg: str | type):
+    """
+    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, name, new) -> None:
+        original = getattr(cls, name)
+        for i in _FN_ATTRS:
+            if hasattr(original, i):
+                setattr(new, i, getattr(original, i))
+        setattr(cls, name, new)
+
+    def mk_frozen(cls: type, method: str) -> type:
+        original_method: Callable = getattr(cls, method)
+        original_setattr: Callable = cls.__setattr__
+        original_delattr: Callable = cls.__delattr__
+
+        def new_method(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, key: str, value):
+            if getattr(self, "_frozen", False):
+                raise AttributeError("Cannot modify frozen object")
+            return original_setattr(self, key, value)
+
+        def __delattr__(self, item: str):
+            if getattr(self, "_frozen", False):
+                raise AttributeError("Cannot modify frozen object")
+            return original_delattr(self, item)
+
+        # 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.3 → zstdlib-0.0.5/zstdlib.egg-info}/PKG-INFO

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

zstdlib-0.0.3/zstdlib/frozen.py

@@ -1,65 +0,0 @@
-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)
-
-
-def frozen(cls):
-    """
-    A class decorator to permanently freeze a class after __init__
-    """
-
-    def __setattr__(self, key: str, value) -> None:
-        if getattr(self, "_frozen", False):
-            raise AttributeError("Cannot modify frozen object")
-        super(cls, self).__setattr__(key, value)
-
-    def __delattr__(self, item: str) -> None:
-        if getattr(self, "_frozen", False):
-            raise AttributeError("Cannot modify frozen object")
-        super(cls, self).__delattr__(item)
-
-    init = cls.__init__
-
-    def __init__(self, *args, **kwargs):
-        init(self, *args, **kwargs)
-        self._frozen = True  # pylint: disable=protected-access
-
-    # Update cls with the new methods
-    cls.__setattr__ = __setattr__
-    cls.__delattr__ = __delattr__
-    cls.__init__ = __init__
-    return cls