private-attribute-cpp 2.1.22__tar.gz → 2.1.24__tar.gz

{private_attribute_cpp-2.1.22/private_attribute_cpp.egg-info → private_attribute_cpp-2.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.22
+Version: 2.1.24
 Summary: A Python package that provides a way to define private attributes in C++ implementation.
 Home-page: https://github.com/Locked-chess-official/private_attribute_cpp
 Author: HuangHaoHua

{private_attribute_cpp-2.1.22 → private_attribute_cpp-2.1.24}/private_attribute.cpp

@@ -125,6 +125,18 @@ public:
     PyObjectStorage(PyObject* obj) noexcept : obj(obj) {
         Py_XINCREF(obj);
     }
+    // Construct a PyObjectStorage that takes ownership of a strong reference
+    // already held by the caller (a "new reference"). The reference count is
+    // NOT incremented; the stored object's ownership is simply transferred
+    // into the storage, and the destructor will release it exactly once.
+    static PyObjectStorage from_new_ref(PyObject* obj) noexcept {
+        PyObjectStorage storage;
+        storage.obj = obj;
+        return storage;
+    }
+    static PyObjectStorage from_new_ref(PyCodeObject* obj) noexcept {
+        return from_new_ref(reinterpret_cast<PyObject*>(obj));
+    }
     // support for PyCodeObject*
     PyObjectStorage(PyCodeObject* obj) noexcept : obj(reinterpret_cast<PyObject*>(obj)) {
         Py_XINCREF(obj);
@@ -176,9 +188,10 @@ public:
         return obj;
     }
 
-    operator PyCodeObject*() const noexcept {
-        return reinterpret_cast<PyCodeObject*>(obj);
+    explicit operator bool() const noexcept {
+        return obj != NULL;
     }
+
     PyObject* get() const noexcept {
         return obj;
     }
@@ -506,22 +519,22 @@ custom_random_string(uintptr_t obj_id, const std::string& attr_name, PyObject* f
             return result;
         } else {
             lock.unlock();
-            PyObject* python_result = PyObject_CallFunction(
-                func,
-                "Ks",
-                static_cast<unsigned long long>(obj_id),
-                attr_name.c_str()
+            PyObjectStorage python_result = PyObjectStorage::from_new_ref(
+                    PyObject_CallFunction(
+                    func,
+                    "Ks",
+                    static_cast<unsigned long long>(obj_id),
+                    attr_name.c_str()
+                )
             );
             if (python_result) {
                 if (!PyUnicode_Check(python_result)) {
-                    Py_DECREF(python_result);
-                    PyErr_SetString(PyExc_TypeError, "private_func function must return a string");
+                    PyErr_Format(PyExc_TypeError, "private_func function must return a string, not '%s'", Py_TYPE(python_result)->tp_name);
                     result.ok = false;
                     result.value = "private_func function must return a string";
                     return result;
                 }
                 result.value = PyUnicode_AsUTF8(python_result);
-                Py_DECREF(python_result);
                 std::string original_result = result.value;
                 unsigned long long i = 1;
                 std::unique_lock<std::shared_mutex> lock2(::AllData::cache_mutex);
@@ -1462,6 +1475,10 @@ PrivateWrap_New(PyObject *decorator, PyObject *func, PyObject *list) noexcept
 
     PrivateWrapObject *self =
         PyObject_GC_New(PrivateWrapObject, &PrivateWrapType);
+    if (!self) {
+        Py_DECREF(wrapped);
+        return NULL;
+    }
     self->func_list = list;
     Py_INCREF(list);
 
@@ -1499,19 +1516,20 @@ PrivateWrapProxy_call(PrivateWrapProxyObject *self, PyObject *args, PyObject* /*
     PyObject *func;
     if (!PyArg_ParseTuple(args, "O:private_attribute.PrivateWrapProxy.__call__", &func)) return NULL;
     if(PyObject_TypeCheck(func, &PrivateWrapType)) {
+        PyObjectStorage final_func_list = PyObjectStorage::from_new_ref(
+            PySequence_Concat(((PrivateWrapObject*)func)->func_list, self->func_list));
         return (PyObject*)PrivateWrap_New(
             self->decorator,
             ((PrivateWrapObject*)func)->result,
-            PySequence_Concat(((PrivateWrapObject*)func)->func_list,
-                              self->func_list)
+            final_func_list
         );
     }
 
     PyObject *new_list = PyList_New(0);
     PyList_Append(new_list, func);
 
-    PyObject *combined =
-        PySequence_Concat(new_list, self->func_list);
+    PyObjectStorage combined =
+        PyObjectStorage::from_new_ref(PySequence_Concat(new_list, self->func_list));
 
     return (PyObject*)PrivateWrap_New(
         self->decorator,
@@ -1668,25 +1686,24 @@ PrivateAttr_tp_getattro(PyObject* self, PyObject* name) noexcept
     uintptr_t type_id = (uintptr_t)typ;
     PrivateAttr_object_init_private_dict((uintptr_t)self, type_id);
     std::string name_str = PyUnicode_AsUTF8(name);
-    auto code = get_now_code();
-    if (type_private_attr(type_id, name_str)) {
-        if (!code) {
-            Py_XDECREF(code);
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            return NULL;
-        }
-        AttrClassifyResult classify = attr_classify(type_id, name_str, code);
-        Py_XDECREF(code);
-        if (!classify.allowed) {
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            return NULL;
-        }
-        if (classify.type_id != 0) {
-            return id_getattr(classify.type_id, name_str, self, (PyObject*)typ);
+    {
+        PyObjectStorage code = PyObjectStorage::from_new_ref(get_now_code());
+        if (type_private_attr(type_id, name_str)) {
+            if (!code) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return NULL;
+            }
+            AttrClassifyResult classify = attr_classify(type_id, name_str, (PyCodeObject*)(code.get()));
+            if (!classify.allowed) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return NULL;
+            }
+            if (classify.type_id != 0) {
+                return id_getattr(classify.type_id, name_str, self, (PyObject*)typ);
+            }
+            // owner is 0: not private for this access context -> normal attribute
         }
-        // owner is 0: not private for this access context -> normal attribute
     }
-    Py_XDECREF(code);
     if (::AllData::all_type_getattro.find(type_id) != ::AllData::all_type_getattro.end()){
         if (::AllData::all_type_getattro[type_id]) {
             PyObject* result = ::AllData::all_type_getattro[type_id](self, name);
@@ -1707,28 +1724,27 @@ PrivateAttr_tp_setattro(PyObject* self, PyObject* name, PyObject* value) noexcep
         return -1;
     }
     std::string name_str(c_name);
-    auto code = get_now_code();
-    if (type_private_attr(typ_id, name_str)) {
-        if (!code) {
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            Py_XDECREF(code);
-            return -1;
-        }
-        AttrClassifyResult classify = attr_classify(typ_id, name_str, code);
-        Py_XDECREF(code);
-        if (!classify.allowed) {
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            return -1;
-        }
-        if (classify.type_id != 0) {
-            if (!value) {
-                return id_delattr(classify.type_id, name_str, self, (PyObject*)typ);
+    {
+        PyObjectStorage code = PyObjectStorage::from_new_ref(get_now_code());
+        if (type_private_attr(typ_id, name_str)) {
+            if (!code) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return -1;
+            }
+            AttrClassifyResult classify = attr_classify(typ_id, name_str, (PyCodeObject*)(code.get()));
+            if (!classify.allowed) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return -1;
             }
-            return id_setattr(classify.type_id, name_str, self, (PyObject*)typ, value);
+            if (classify.type_id != 0) {
+                if (!value) {
+                    return id_delattr(classify.type_id, name_str, self, (PyObject*)typ);
+                }
+                return id_setattr(classify.type_id, name_str, self, (PyObject*)typ, value);
+            }
+            // owner is 0: not private for this access context -> normal attribute
         }
-        // owner is 0: not private for this access context -> normal attribute
     }
-    Py_XDECREF(code);
     if (::AllData::all_type_setattro.find(typ_id) != ::AllData::all_type_setattro.end()){
         int result = ::AllData::all_type_setattro[typ_id](self, name, value);
         ensure_tp(typ);
@@ -2636,10 +2652,9 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyObjectStorage>&
             Py_ssize_t len = PySequence_Length(co_contain);
             if (len >= 0) {
                 for (Py_ssize_t i = 0; i < len; i++) {
-                    PyObject* item = PySequence_GetItem(co_contain, i);
+                    PyObjectStorage item = PyObjectStorage::from_new_ref(PySequence_GetItem(co_contain, i));
                     if (item) {
                         analyse_all_code(item, map, _seen);
-                        Py_DECREF(item);
                     }
                 }
             }
@@ -2653,10 +2668,9 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyObjectStorage>&
             Py_ssize_t len = PySequence_Length(func_list);
             if (len >= 0) {
                 for (Py_ssize_t i = 0; i < len; i++) {
-                    PyObject* func = PySequence_GetItem(func_list, i);
+                    PyObjectStorage func = PyObjectStorage::from_new_ref(PySequence_GetItem(func_list, i));
                     if (func) {
                         analyse_all_code(func, map, _seen);
-                        Py_DECREF(func);
                     }
                 }
             }
@@ -2664,50 +2678,44 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyObjectStorage>&
         return;
     }
     if (PyObject_TypeCheck(obj, &PyProperty_Type)) {
-        PyObject* fget = try_get_attr_string(obj, "fget");
+        PyObjectStorage fget = PyObjectStorage::from_new_ref(try_get_attr_string(obj, "fget"));
         if (fget) {
             analyse_all_code(fget, map, _seen);
-            Py_DECREF(fget);
         }
-        PyObject* fset = try_get_attr_string(obj, "fset");
+        PyObjectStorage fset = PyObjectStorage::from_new_ref(try_get_attr_string(obj, "fset"));
         if (fset) {
             analyse_all_code(fset, map, _seen);
-            Py_DECREF(fset);
         }
-        PyObject* fdel = try_get_attr_string(obj, "fdel");
+        PyObject* fdel = PyObjectStorage::from_new_ref(try_get_attr_string(obj, "fdel"));
         if (fdel) {
             analyse_all_code(fdel, map, _seen);
-            Py_DECREF(fdel);
         }
         return;
     }
     if (PyObject_TypeCheck(obj, &PyClassMethod_Type) || PyObject_TypeCheck(obj, &PyStaticMethod_Type)) {
-        PyObject* func = try_get_attr_string(obj, "__func__");
+        PyObjectStorage func = PyObjectStorage::from_new_ref(try_get_attr_string(obj, "__func__"));
         if (func) {
             analyse_all_code(func, map, _seen);
-            Py_DECREF(func);
         }
         return;
     }
-    PyObject* wrap = try_get_attr_string(obj, "__wrapped__");
-    if (wrap) {
-        if (wrap == obj) {
-            PyObject* code = try_get_attr_string(obj, "__code__");
-            if (code) {
-                analyse_all_code(code, map, _seen);
-                Py_DECREF(code);
+    {
+        PyObjectStorage wrap = PyObjectStorage::from_new_ref(try_get_attr_string(obj, "__wrapped__"));
+        if (wrap) {
+            if (wrap == obj) {
+                PyObjectStorage code = PyObjectStorage::from_new_ref(try_get_attr_string(obj, "__code__"));
+                if (code) {
+                    analyse_all_code(code, map, _seen);
+                }
+                return;
             }
-            Py_DECREF(wrap);
+            analyse_all_code(wrap, map, _seen);
             return;
         }
-        analyse_all_code(wrap, map, _seen);
-        Py_DECREF(wrap);
-        return;
     }
-    PyObject* code = try_get_attr_string(obj, "__code__");
+    PyObjectStorage code = PyObjectStorage::from_new_ref(try_get_attr_string(obj, "__code__"));
     if (code) {
         analyse_all_code(code, map, _seen);
-        Py_DECREF(code);
     }
 }
 
@@ -2854,8 +2862,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         __private_attrs__ = PyDict_GetItemString(data.attrs, "__private_attrs__");
     }
     else {
-        __private_attrs__ = PyTuple_New(0);
-        Py_DECREF(__private_attrs__);
+        __private_attrs__ = PyObjectStorage::from_new_ref(PyTuple_New(0));
     }
 
     if (PyUnicode_Check(__private_attrs__)) {
@@ -2864,8 +2871,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
             return false;
         }
         PyTuple_SET_ITEM(new___private_attrs__, 0, __private_attrs__);
-        __private_attrs__ = new___private_attrs__;
-        Py_DECREF(__private_attrs__);
+        __private_attrs__ = PyObjectStorage::from_new_ref(new___private_attrs__);
     }
 
     if (!PySequence_Check(__private_attrs__)) {
@@ -2935,41 +2941,38 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         if (PyUnicode_Check(all_slots)) {
             const char* slot_cstr = PyUnicode_AsUTF8(all_slots);
             if (data.private_attrs_vector_string.find((std::string)slot_cstr) != data.private_attrs_vector_string.end()){
-                std::string error_msg = "'__slots__' and '__private_attrs__' cannot have the same attribute name: '" + std::string(slot_cstr) + "'";
-                PyErr_SetString(PyExc_TypeError, error_msg.c_str());
+                PyErr_Format(PyExc_TypeError, "'__slots__' and '__private_attrs__' cannot have the same attribute name: '%s'", slot_cstr);
                 return false;
             }
         } else {
-            PyObject* slot_seq;
+            PyObjectStorage slot_seq;
             if (PyAnyDict_Check(all_slots)) {
                 // use the key of the dict as the slot name
                 PyObject* keys = PyDict_Keys(all_slots);
                 if (!keys) {
                     return false;
                 }
-                slot_seq = keys;
+                slot_seq = PyObjectStorage::from_new_ref(keys);
             } else {
-                slot_seq = PySequence_Fast(all_slots, "__slots__ must be a string, dict or sequence");
+                slot_seq = PyObjectStorage::from_new_ref(PySequence_Fast(all_slots, "__slots__ must be a string, dict or sequence"));
             }
-            if (!slot_seq) {
+            if (!slot_seq.get()) {
                 return false;
             }
 
-            Py_ssize_t slot_len = PySequence_Fast_GET_SIZE(slot_seq);
+            Py_ssize_t slot_len = PySequence_Fast_GET_SIZE(slot_seq.get());
 
             for (Py_ssize_t j = 0; j < slot_len; j++) {
-                PyObject* slot = PySequence_Fast_GET_ITEM(slot_seq, j);
+                PyObject* slot = PySequence_Fast_GET_ITEM(slot_seq.get(), j);
                 if (PyUnicode_Check(slot)) {
                     const char* slot_cstr = PyUnicode_AsUTF8(slot);
                     std::string final_name = real_class_name(slot_cstr, data.class_name);
                     if (data.private_attrs_vector_string.find(final_name) != data.private_attrs_vector_string.end()){
                         PyErr_Format(PyExc_TypeError, "'__slots__' and '__private_attrs__' cannot have the same attribute name: '%s'", final_name.c_str());
-                        Py_DECREF(slot_seq);
                         return false;
                     }
                 }
             }
-            Py_DECREF(slot_seq);
         }
     }
 
@@ -2999,7 +3002,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
     {
         Py_ssize_t pos = 0;
         PyObject* key, *value;
-        PyObject* forward_analyse = PyDict_Copy(data.attrs_copy);
+        PyObjectStorage forward_analyse = PyObjectStorage::from_new_ref(PyDict_Copy(data.attrs_copy));
         while (PyDict_Next(forward_analyse, &pos, &key, &value)) {
             if (!key || !PyUnicode_Check(key)) {
                 PyErr_SetString(PyExc_TypeError, "all keys in 'attrs' must be strings");
@@ -3038,7 +3041,6 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
                 if (PyDict_SetItem(data.attrs_copy, key, need_value) < 0) return false;
             }
         }
-        Py_DECREF(forward_analyse);
     }
 
     // get "private_func" from kwds
@@ -3314,7 +3316,8 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
     }
 
     if (data.private_func) {
-        Py_INCREF(data.private_func);
+        // The PyObjectStorage assignment already INCREFs (RAII); the manual
+        // INCREF was removed to avoid a +1 leak.
         ::AllData::type_need_call[type_id] = data.private_func;
     }
 
@@ -3402,25 +3405,23 @@ PrivateAttrType_getattr(PyObject* cls, PyObject* name) noexcept
     }
     uintptr_t typ_id = (uintptr_t)(cls);
     std::string name_str = PyUnicode_AsUTF8(name);
-    PyCodeObject* now_code = get_now_code();
-    if (type_private_attr(typ_id, name_str)) {
-        if (!now_code) {
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            Py_XDECREF(now_code);
-            return NULL;
-        }
-        AttrClassifyResult classify = attr_classify(typ_id, name_str, now_code);
-        Py_XDECREF(now_code);
-        if (!classify.allowed) {
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            return NULL;
-        }
-        if (classify.type_id != 0) {
-            return type_getattr(cls, name_str);
+    {
+        PyObjectStorage now_code = PyObjectStorage::from_new_ref(get_now_code());
+        if (type_private_attr(typ_id, name_str)) {
+            if (!now_code) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return NULL;
+            }
+            AttrClassifyResult classify = attr_classify(typ_id, name_str, (PyCodeObject*)(now_code.get()));
+            if (!classify.allowed) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return NULL;
+            }
+            if (classify.type_id != 0) {
+                return type_getattr(cls, name_str);
+            }
         }
-        // owner is 0: not private for this access context -> normal attribute
     }
-    Py_XDECREF(now_code);
     PyTypeObject* base = Py_TYPE(cls)->tp_base;
     while (base && base->tp_base && base->tp_getattro == PrivateAttrType_getattr) {
         base = base->tp_base;
@@ -3493,35 +3494,31 @@ init_all_slots() noexcept
         return 0;
     }
     original_type_tp_setattro = PyType_Type.tp_setattro;
-    PyObject* original_setattr = PyObject_GetAttrString((PyObject*)&PyType_Type, "__setattr__");
+    PyObjectStorage original_setattr = PyObjectStorage::from_new_ref(PyObject_GetAttrString((PyObject*)&PyType_Type, "__setattr__"));
     if (!original_setattr) {return -1;}
     if (original_setattr && PyObject_IsInstance(original_setattr, (PyObject*)&PyWrapperDescr_Type)) {
-        ((PyWrapperDescrObject*)original_setattr)->d_wrapped = (void*)new_type_tp_setattro;
+        ((PyWrapperDescrObject*)(original_setattr.get()))->d_wrapped = (void*)new_type_tp_setattro;
     }
-    Py_DECREF(original_setattr);
-    PyObject* original_delattr = PyObject_GetAttrString((PyObject*)&PyType_Type, "__delattr__");
+    PyObjectStorage original_delattr = PyObjectStorage::from_new_ref(PyObject_GetAttrString((PyObject*)&PyType_Type, "__delattr__"));
     if (!original_delattr) {return -1;}
     if (original_delattr && PyObject_IsInstance(original_delattr, (PyObject*)&PyWrapperDescr_Type)) {
-        ((PyWrapperDescrObject*)original_delattr)->d_wrapped = (void*)new_type_tp_setattro;
+        ((PyWrapperDescrObject*)(original_delattr.get()))->d_wrapped = (void*)new_type_tp_setattro;
     }
-    Py_DECREF(original_delattr);
     PyType_Type.tp_setattro = new_type_tp_setattro;
-    PyObject* all_metaclasses = PyObject_CallMethod((PyObject*)&PyType_Type, "__subclasses__", "O", (PyObject*)&PyType_Type);
+    PyObjectStorage all_metaclasses = PyObjectStorage::from_new_ref(PyObject_CallMethod((PyObject*)&PyType_Type, "__subclasses__", "O", (PyObject*)&PyType_Type));
     if (!all_metaclasses) {return -1;}
     if (!PyList_Check(all_metaclasses)) {
-        Py_DECREF(all_metaclasses);
-        has_init_slots = true;
-        return 0;
+        PyErr_SetString(PyExc_TypeError, "subclasses of type is not list");
+        return -1;
     }
-    Py_ssize_t list_len = PyList_GET_SIZE(all_metaclasses);
+    Py_ssize_t list_len = PyList_GET_SIZE(all_metaclasses.get());
     for (Py_ssize_t i = 0; i < list_len; i++) {
-        PyObject* metaclass = PyList_GET_ITEM(all_metaclasses, i);
+        PyObject* metaclass = PyList_GET_ITEM(all_metaclasses.get(), i);
         if (!PyType_Check(metaclass)) {continue;}
         if (((PyTypeObject*)metaclass)->tp_setattro == original_type_tp_setattro) {
             ((PyTypeObject*)metaclass)->tp_setattro = new_type_tp_setattro;
         }
     }
-    Py_DECREF(all_metaclasses);
     has_init_slots = true;
     return 0;
 }
@@ -3756,25 +3753,24 @@ PrivateAttrType_setattr(PyObject* cls, PyObject* name, PyObject* value) noexcept
         PyErr_SetString(PyExc_TypeError, error_message.c_str());
         return -1;
     }
-    PyCodeObject* now_code = get_now_code();
-    if (type_private_attr(typ_id, name_str)) {
-        if (!now_code) {
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            Py_XDECREF(now_code);
-            return -1;
-        }
-        AttrClassifyResult classify = attr_classify(typ_id, name_str, now_code);
-        Py_XDECREF(now_code);
-        if (!classify.allowed) {
-            PyErr_SetString(PyExc_AttributeError, "private attribute");
-            return -1;
-        }
-        if (classify.type_id != 0) {
-            return type_setattr(cls, name_str, value);
+    {
+        PyObjectStorage now_code = PyObjectStorage::from_new_ref(get_now_code());
+        if (type_private_attr(typ_id, name_str)) {
+            if (!now_code) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return -1;
+            }
+            AttrClassifyResult classify = attr_classify(typ_id, name_str, (PyCodeObject*)(now_code.get()));
+            if (!classify.allowed) {
+                PyErr_SetString(PyExc_AttributeError, "private attribute");
+                return -1;
+            }
+            if (classify.type_id != 0) {
+                return type_setattr(cls, name_str, value);
+            }
+            // owner is 0: not private for this access context -> normal attribute
         }
-        // owner is 0: not private for this access context -> normal attribute
     }
-    Py_XDECREF(now_code);
     PyTypeObject* base = Py_TYPE(cls)->tp_base;
     while (base && base->tp_base && base->tp_setattro == PrivateAttrType_setattr) {
         base = base->tp_base;
@@ -3854,86 +3850,55 @@ PrivateAttrType_del(PyObject* cls) noexcept
     PyType_Type.tp_dealloc(cls);
 }
 
-static const char* PrivateAttrBase_doc = "The class to help to create private attribute. It does not have any special behavior.";
+static const char* PrivateAttrBase_doc = "The class to help creating private attribute. It does not have any special behavior.";
 
 // PrivateAttrBase
 static PyObject*
 create_private_attr_base_simple(void) noexcept
 {
-    PyObject* name = NULL;
-    PyObject* bases = NULL;
-    PyObject* dict = NULL;
-    PyObject* private_attrs = NULL;
-    PyObject* doc = NULL;
-    PyObject* module_name = NULL;
-    PyObject* args = NULL;
-    PyObject* base_type = NULL;
-
-    name = PyUnicode_InternFromString("PrivateAttrBase");
-    if (!name) goto fail;
-
-    bases = PyTuple_New(0);
-    if (!bases) goto fail;
+    PyObjectStorage name = PyObjectStorage::from_new_ref(PyUnicode_InternFromString("PrivateAttrBase"));
+    if (!name) return NULL;
 
-    dict = PyDict_New();
-    if (!dict) goto fail;
+    PyObjectStorage bases = PyObjectStorage::from_new_ref(PyTuple_New(0));
+    if (!bases) return NULL;
 
-    private_attrs = PyTuple_New(0);
-    if (!private_attrs) goto fail;
+    PyObjectStorage dict = PyObjectStorage::from_new_ref(PyDict_New());
+    if (!dict) return NULL;
 
-    doc = PyUnicode_InternFromString(PrivateAttrBase_doc);
-    if (!doc) goto fail;
+    PyObjectStorage private_attrs = PyObjectStorage::from_new_ref(PyTuple_New(0));
+    if (!private_attrs) return NULL;
 
-    module_name = PyUnicode_InternFromString("private_attribute");
-    if (!module_name) goto fail;
+    PyObjectStorage doc = PyObjectStorage::from_new_ref(PyUnicode_InternFromString(PrivateAttrBase_doc));
+    if (!doc) return NULL;
 
-    if (PyDict_SetItemString(dict, "__private_attrs__", private_attrs) < 0) goto fail;
-    if (PyDict_SetItemString(dict, "__slots__", private_attrs) < 0) goto fail;
-    if (PyDict_SetItemString(dict, "__doc__", doc) < 0) goto fail;
-    if (PyDict_SetItemString(dict, "__module__", module_name) < 0) goto fail;
+    PyObjectStorage module_name = PyObjectStorage::from_new_ref(PyUnicode_InternFromString("private_attribute"));
+    if (!module_name) return NULL;
 
-    Py_DECREF(doc);
-    doc = NULL;
-    Py_DECREF(module_name);
-    module_name = NULL;
+    if (PyDict_SetItemString(dict, "__private_attrs__", private_attrs) < 0) return NULL;
+    if (PyDict_SetItemString(dict, "__slots__", private_attrs) < 0) return NULL;
+    if (PyDict_SetItemString(dict, "__doc__", doc) < 0) return NULL;
+    if (PyDict_SetItemString(dict, "__module__", module_name) < 0) return NULL;
 
-    args = PyTuple_Pack(3, name, bases, dict);
-    if (!args) goto fail;
+    PyObjectStorage args = PyObjectStorage::from_new_ref(PyTuple_Pack(3, name.get(), bases.get(), dict.get()));
+    if (!args) return NULL;
 
+    PyObject* base_type = NULL;
     {
         // RAII: the first heap type created through tp_new (PrivateAttrBase)
         // carries CPython's pristine subtype_traverse/subtype_clear in its
         // tp_traverse/tp_clear; PrivateAttrType_new captures those pointers
         // while this guard is active.
         PrivateAttrCaptureGuard capture_guard;
-        base_type = PrivateAttrType_new((PyTypeObject*)&PrivateAttrType, args, NULL);
+        base_type = PrivateAttrType_new((PyTypeObject*)&PrivateAttrType, args.get(), NULL);
     }
-    Py_DECREF(args);
-    args = NULL;
-
-    Py_DECREF(name);
-    name = NULL;
-    Py_DECREF(bases);
-    bases = NULL;
-    Py_DECREF(dict);
-    dict = NULL;
 
-    if (!base_type) goto fail;
+    if (!base_type) return NULL;
 
     ((PyTypeObject*)base_type)->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
     return base_type;
-
-fail:
-    Py_XDECREF(name);
-    Py_XDECREF(bases);
-    Py_XDECREF(dict);
-    Py_XDECREF(private_attrs);
-    Py_XDECREF(doc);
-    Py_XDECREF(module_name);
-    Py_XDECREF(args);
-    return NULL;
 }
 
+
 typedef struct {
     PyObject_HEAD
     PrivateAttrCreationData* tmp;
@@ -4132,7 +4097,8 @@ metaclass_weakref_callback(PyObject* self, PyObject* /*weakref*/) noexcept
 
     auto it = ::AllData::all_register_type_weak_ref.find(id);
     if (it != ::AllData::all_register_type_weak_ref.end()) {
-        Py_DECREF(it->second);
+        // The PyObjectStorage destructor releases the stored reference on
+        // erase; do not DECREF here (double-DECREF).
         ::AllData::all_register_type_weak_ref.erase(it);
     }
     METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(getattro);
@@ -4229,7 +4195,9 @@ register_metaclass_head(PyObject* metaclass) noexcept
         Py_DECREF(capsule);
         return NULL;
     }
-    ::AllData::all_register_type_weak_ref[id] = ref;
+    // PyWeakref_NewRef returns a new reference; transfer it into the storage
+    // without an extra INCREF (which the plain assignment operator would add).
+    ::AllData::all_register_type_weak_ref[id] = PyObjectStorage::from_new_ref(ref);
     PyTypeObject* mt = (PyTypeObject*)metaclass;
     // Save the ORIGINAL slots before wrapping. Always resolve through the
     // get_type_need_tp_* walkers so a delegating default (CPython's
@@ -4374,50 +4342,33 @@ PrivateModule_get_PrivateAttrBase(PyObject* /*self*/, void* /*closure*/) noexcep
             return NULL;
         }
         AllData::store_module_self[AllData::kPrivateAttrBaseKey] = base;
-        Py_DECREF(base);
-        it = AllData::store_module_self.find(AllData::kPrivateAttrBaseKey);
+        return base;
     }
     PyObject* PrivateAttrBase = it->second.get();
     Py_INCREF(PrivateAttrBase);
     return PrivateAttrBase;
 }
 
-static int
-PyList_AppendString(PyObject* list, const char* str) noexcept
-{
-    PyObject* obj = PyUnicode_InternFromString(str);
-    if (!obj) return -1;
-    if (PyList_Append(list, obj) < 0) {
-        Py_DECREF(obj);
-        return -1;
-    }
-    Py_DECREF(obj);
-    return 0;
-}
-
-#define DIR_CHECK(command) do {if (command < 0) goto finally;} while (0)
-
 static PyObject*
 PrivateModule_dir(PyObject* self, PyObject* /*args*/) noexcept
 {
     PyObject* parent_dir = PyObject_CallMethod((PyObject*)&PyModule_Type, "__dir__", "O", self);
     if (!parent_dir) return NULL;
-    PyObject* attr_list = PyList_New(0);
+    PyObject* attr_list = Py_BuildValue("[ssssssss]",
+        "PrivateWrapProxy",
+        "PrivateAttrType",
+        "PrivateAttrBase",
+        "prepare",
+        "postprocess",
+        "register_metaclass",
+        "ensure_type",
+        "ensure_metaclass"
+    );
     if (!attr_list) {
         Py_DECREF(parent_dir);
         return NULL;
     }
-    PyObject* result = NULL;
-    DIR_CHECK(PyList_AppendString(attr_list, "PrivateWrapProxy"));
-    DIR_CHECK(PyList_AppendString(attr_list, "PrivateAttrType"));
-    DIR_CHECK(PyList_AppendString(attr_list, "PrivateAttrBase"));
-    DIR_CHECK(PyList_AppendString(attr_list, "prepare"));
-    DIR_CHECK(PyList_AppendString(attr_list, "postprocess"));
-    DIR_CHECK(PyList_AppendString(attr_list, "register_metaclass"));
-    DIR_CHECK(PyList_AppendString(attr_list, "ensure_type"));
-    DIR_CHECK(PyList_AppendString(attr_list, "ensure_metaclass"));
-    result = PySequence_Concat(parent_dir, attr_list);
-finally:
+    PyObject* result = PySequence_Concat(parent_dir, attr_list);
     Py_DECREF(parent_dir);
     Py_DECREF(attr_list);
     return result;
@@ -4676,25 +4627,21 @@ atexit_register_clean_func(void) noexcept
     if (resigtered_clean_func) {
         return 0;
     }
-    PyObject* atexit = PyImport_ImportModule("atexit");
+    PyObjectStorage atexit = PyObjectStorage::from_new_ref(PyImport_ImportModule("atexit"));
     if (!atexit) {
         return -1;
     }
 
-    PyObject* func = PyCFunction_New(&clean_storage, NULL);
+    PyObjectStorage func = PyObjectStorage::from_new_ref(PyCFunction_New(&clean_storage, NULL));
     if (!func) {
-        Py_DECREF(atexit);
         return -1;
     }
 
-    PyObject* result = PyObject_CallMethod(atexit, "register", "O", func);
-    Py_DECREF(func);
-    Py_DECREF(atexit);
+    PyObjectStorage result = PyObjectStorage::from_new_ref(PyObject_CallMethod(atexit, "register", "O", func.get()));
 
     if (!result) {
         return -1;
     }
-    Py_DECREF(result);
     resigtered_clean_func = true;
     return 0;
 }
@@ -4702,7 +4649,7 @@ atexit_register_clean_func(void) noexcept
 static PyObject*
 PrivateModule_create(PyObject* spec, PyModuleDef* /*def*/) noexcept
 {
-    PyObject* name = PyObject_GetAttrString(spec, "name");
+    PyObjectStorage name = PyObjectStorage::from_new_ref(PyObject_GetAttrString(spec, "name"));
     if (!name) {
         return NULL;
     }
@@ -4711,13 +4658,9 @@ PrivateModule_create(PyObject* spec, PyModuleDef* /*def*/) noexcept
     // PyInit_private_attribute is genuinely a
     // `private_attribute.private_attribute_module` instance from the start,
     // rather than a plain module re-typed with Py_SET_TYPE afterwards.
-    PyObject* m = PyObject_CallFunction((PyObject*)&PrivateModuleType, "O", name);
-    Py_DECREF(name);
-    return m;
+    return PyObject_CallFunction((PyObject*)&PrivateModuleType, "O", name.get());
 }
 
-#define MODULE_EXEC_CHECK(command) do {if (command < 0) {return -1;}} while(0)
-
 static int
 PrivateModule_exec(PyObject* m) noexcept
 {
@@ -4730,7 +4673,16 @@ PrivateModule_exec(PyObject* m) noexcept
         return -1;
     }
     Py_DECREF(private_attr_base);
-    PyObject* all = PyList_New(0);
+    PyObject* all = Py_BuildValue("[ssssssss]",
+        "PrivateWrapProxy",
+        "PrivateAttrType",
+        "PrivateAttrBase",
+        "prepare",
+        "postprocess",
+        "register_metaclass",
+        "ensure_type",
+        "ensure_metaclass"
+    );
     if (!all) {
         return -1;
     }
@@ -4738,24 +4690,6 @@ PrivateModule_exec(PyObject* m) noexcept
         Py_DECREF(all);
         return -1;
     }
-    /* all contains:
-     * PrivateWrapProxy
-     * PrivateAttrType
-     * PrivateAttrBase
-     * prepare
-     * postprocess
-     * register_metaclass
-     * ensure_type
-     * ensure_metaclass
-     */
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "PrivateWrapProxy"));
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "PrivateAttrType"));
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "PrivateAttrBase"));
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "prepare"));
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "postprocess"));
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "register_metaclass"));
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "ensure_type"));
-    MODULE_EXEC_CHECK(PyList_AppendString(all, "ensure_metaclass"));
 
     AllData::store_module_self[AllData::kModuleSelfKey] = m;    // store module self
 

{private_attribute_cpp-2.1.22 → private_attribute_cpp-2.1.24}/private_attribute.pyi

@@ -102,7 +102,7 @@ class PrivateAttrType(type):
                 private_func: Callable[[int, str], str]|None = None) -> PrivateAttrType: ...
 
 class PrivateAttrBase(metaclass=PrivateAttrType):
-    "The class to help to create private attribute. It does not have any special behavior."
+    "The class to help creating private attribute. It does not have any special behavior."
     __slots__ = ()
     __private_attrs__ = ()
 

{private_attribute_cpp-2.1.22 → private_attribute_cpp-2.1.24/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.22
+Version: 2.1.24
 Summary: A Python package that provides a way to define private attributes in C++ implementation.
 Home-page: https://github.com/Locked-chess-official/private_attribute_cpp
 Author: HuangHaoHua

{private_attribute_cpp-2.1.22 → private_attribute_cpp-2.1.24}/setup.py

@@ -24,7 +24,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='2.1.22',
+    version='2.1.24',
     author="HuangHaoHua",
     author_email="13140752715@example.com",
     description='A Python package that provides a way to define private attributes in C++ implementation.',

{private_attribute_cpp-2.1.22 → private_attribute_cpp-2.1.24}/tests/test_private_wrap.py

@@ -1,6 +1,7 @@
 import private_attribute
 import unittest
 
+# test whether the PrivateWrapProxy can find the original function if the decorator is a custom type
 class MyWrap:
     def __init__(self, func):
         self.func1 = func
@@ -19,6 +20,12 @@ class MyWrap:
             return func.__get__(instance, owner)(*args, **kwargs)
         return wrapper
 
+# test whether the PrivateWrapProxy can find the original function if the decorator forgets to use functools.wrap
+def ill_decorator(func):
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    return wrapper
+
 class MyClass(private_attribute.PrivateAttrBase):
     __private_attrs__ = ["_secret1", "_secret2", "_secret3"]
     def __init__(self, secret1, secret2, secret3):
@@ -27,11 +34,12 @@ class MyClass(private_attribute.PrivateAttrBase):
         self._secret3 = secret3
 
     @private_attribute.PrivateWrapProxy(MyWrap)
-    def get_secret(self):
+    def get_secret(self): # type: ignore
         return self._secret1
 
     @private_attribute.PrivateWrapProxy(get_secret.result.add, get_secret)
-    def get_secret(self):
+    @private_attribute.PrivateWrapProxy(ill_decorator, get_secret)
+    def get_secret(self): # type: ignore
         return self._secret2
 
     @private_attribute.PrivateWrapProxy(get_secret.result.add, get_secret)