private-attribute-cpp 2.2.2__tar.gz → 2.2.3__tar.gz

{private_attribute_cpp-2.2.2 → private_attribute_cpp-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.2.2
+Version: 2.2.3
 Summary: A Python package that provides a way to define private attributes in C++ implementation.
 Author-Email: HuangHaoHua <13140752715@example.com>
 License-Expression: MIT
@@ -184,10 +184,10 @@ import private_attribute
 
 class PrivateAbcMeta(ABCMeta):
     def __new__(cls, name, bases, attrs, **kwargs):
-        temp = private_attribute.prepare(name, bases, attrs, **kwargs)
-        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-        private_attribute.postprocess(typ, temp)
-        return typ
+        with private_attribute.prepare(name, bases, attrs, **kwargs) as tmp: # In 2.2.3 it support using "with"
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp) # or tmp.postprocess(typ)
+            return typ
 
 private_attribute.register_metaclass(PrivateAbcMeta)
 ```
@@ -249,6 +249,7 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
 - Don't set `__static_attributes__` in private attribute class, or it will be removed.
 - After 2.2.1, when `prepare` was called, it will lock the creation of new private attribute type. There will be only one private attribute type in building (type.\_\_new\_\_) at the same time. Call `postprocess` to unlock it. If build failed, the lock will be released automatically.
+- After 2.2.3, it is recommend to use "with" on `private_attribute.prepare` and `private_attribute.postprocess` to ensure the lock is released.
 
 ## License
 

{private_attribute_cpp-2.2.2 → private_attribute_cpp-2.2.3}/README.md

@@ -174,10 +174,10 @@ import private_attribute
 
 class PrivateAbcMeta(ABCMeta):
     def __new__(cls, name, bases, attrs, **kwargs):
-        temp = private_attribute.prepare(name, bases, attrs, **kwargs)
-        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-        private_attribute.postprocess(typ, temp)
-        return typ
+        with private_attribute.prepare(name, bases, attrs, **kwargs) as tmp: # In 2.2.3 it support using "with"
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp) # or tmp.postprocess(typ)
+            return typ
 
 private_attribute.register_metaclass(PrivateAbcMeta)
 ```
@@ -239,6 +239,7 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
 - Don't set `__static_attributes__` in private attribute class, or it will be removed.
 - After 2.2.1, when `prepare` was called, it will lock the creation of new private attribute type. There will be only one private attribute type in building (type.\_\_new\_\_) at the same time. Call `postprocess` to unlock it. If build failed, the lock will be released automatically.
+- After 2.2.3, it is recommend to use "with" on `private_attribute.prepare` and `private_attribute.postprocess` to ensure the lock is released.
 
 ## License
 

{private_attribute_cpp-2.2.2 → private_attribute_cpp-2.2.3}/private_attribute.cpp

@@ -4060,8 +4060,27 @@ PrivateTempObject_postprocess(PyObject* self, PyObject* type) noexcept
     Py_RETURN_NONE;
 }
 
+static PyObject*
+PrivateTempObject_enter(PyObject* self, PyObject* /*args*/) noexcept
+{
+    Py_INCREF(self);
+    return self;
+}
+
+
+static PyObject*
+PrivateTempObject_exit(PyObject* self, PyObject* /*args*/) noexcept
+{
+    PrivateTempObject* obj = (PrivateTempObject*)self;
+    if (!obj->tmp->cleared) {
+        obj->tmp->clear();
+    }
+    Py_RETURN_NONE;
+}
 static PyMethodDef PrivateTempObject_methods[] = {
     {"postprocess", (PyCFunction)PrivateTempObject_postprocess, METH_O, "postprocess the temp object"},
+    {"__enter__", (PyCFunction)PrivateTempObject_enter, METH_NOARGS, NULL},
+    {"__exit__", (PyCFunction)PrivateTempObject_exit, METH_VARARGS, NULL},
     {NULL}
 };
 
@@ -4147,7 +4166,11 @@ postprocess_for_PrivateAttr(PyObject* /*self*/, PyObject* args) noexcept
 {
     PyObject* type;
     PyObject* tmp;
-    if (!PyArg_ParseTuple(args, "OO", &type, &tmp)) {
+    if (!PyArg_ParseTuple(args, "OO:private_attribute.postprocess", &type, &tmp)) {
+        return NULL;
+    }
+    if (!PyObject_IsInstance(tmp, (PyObject*)&PrivateTempType)) {
+        PyErr_SetString(PyExc_TypeError, "tmp must be a PrivateTempObject");
         return NULL;
     }
     return PrivateTempObject_postprocess(tmp, type);
@@ -4506,10 +4529,10 @@ import private_attribute
 
 class PrivateAbcMeta(ABCMeta):
     def __new__(cls, *args, **kwargs):
-        temp = private_attribute.prepare(*args, **kwargs)
-        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-        private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
-        return typ
+        with private_attribute.prepare(*args, **kwargs) as temp:
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+            return typ
 
 private_attribute.register_metaclass(PrivateAbcMeta)
 ```

{private_attribute_cpp-2.2.2 → private_attribute_cpp-2.2.3}/private_attribute.pyi

@@ -119,6 +119,9 @@ class _PrivateTemp:
     def kwds(self) -> dict[str, Any]: ...
     def postprocess(self, typ: type, /) -> None: ... # add in 2.1.17
 
+    def __enter__(self) -> "_PrivateTemp": ...
+    def __exit__(self, exc_type: type, exc_val: Exception, exc_tb: Any) -> None: ...
+
 def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _PrivateTemp:
     """
     function for custom metaclass to create private attributes class.
@@ -140,10 +143,10 @@ def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _Pri
 
     class PrivateAbcMeta(ABCMeta):
         def __new__(cls, *args, **kwargs):
-            temp = private_attribute.prepare(*args, **kwargs)
-            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-            private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
-            return typ
+            with private_attribute.prepare(*args, **kwargs) as temp:
+                typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+                private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+                return typ
 
     private_attribute.register_metaclass(PrivateAbcMeta)
     ```
@@ -178,10 +181,10 @@ def postprocess(typ: type, temp: _PrivateTemp, /) -> None:
 
     class PrivateAbcMeta(ABCMeta):
         def __new__(cls, *args, **kwargs):
-            temp = private_attribute.prepare(*args, **kwargs)
-            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-            private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
-            return typ
+            with private_attribute.prepare(*args, **kwargs) as temp:
+                typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+                private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+                return typ
 
     private_attribute.register_metaclass(PrivateAbcMeta)
     ```
@@ -208,10 +211,10 @@ def register_metaclass(typ: type, /) -> None:
 
     class PrivateAbcMeta(ABCMeta):
         def __new__(cls, *args, **kwargs):
-            temp = private_attribute.prepare(*args, **kwargs)
-            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-            private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
-            return typ
+            with private_attribute.prepare(*args, **kwargs) as temp:
+                typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+                private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+                return typ
 
     private_attribute.register_metaclass(PrivateAbcMeta)
     ```

{private_attribute_cpp-2.2.2 → private_attribute_cpp-2.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "private_attribute_cpp"
-version = "2.2.2"
+version = "2.2.3"
 description = "A Python package that provides a way to define private attributes in C++ implementation."
 readme = "README.md"
 requires-python = ">=3.10"

{private_attribute_cpp-2.2.2 → private_attribute_cpp-2.2.3}/tests/test_private_abc.py

@@ -5,10 +5,10 @@ import unittest
 
 class PrivateAbcMeta(ABCMeta):
     def __new__(cls, *args, **kwargs):
-        temp = private_attribute.prepare(*args, **kwargs)
-        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-        private_attribute.postprocess(typ, temp)
-        return typ
+        with private_attribute.prepare(*args, **kwargs) as temp:
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
 
 
 private_attribute.register_metaclass(PrivateAbcMeta)
@@ -34,7 +34,7 @@ class ConcreteClass(MyClass):
         self._secret1 = secret1
         self._secret2 = secret2
 
-    def public_method(self):
+    def public_method(self): # type: ignore
         return self._secret1, self._secret2
 
 
@@ -47,7 +47,7 @@ class TestPrivateAbc(unittest.TestCase):
         with self.assertRaises(AttributeError):
             c._secret2
         with self.assertRaises(TypeError):
-            MyClass()
+            MyClass() # type: ignore
         with self.assertRaises(AttributeError):
             MyClass._secret1
         self.assertEqual(MyClass.get_secret1(), 10)