private-attribute-cpp 1.3.6__tar.gz → 1.3.8__tar.gz

{private_attribute_cpp-1.3.6/private_attribute_cpp.egg-info → private_attribute_cpp-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.3.6
+Version: 1.3.8
 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-1.3.6 → private_attribute_cpp-1.3.8}/private_attribute.cpp

@@ -21,6 +21,21 @@
 #include <memory>
 #include <algorithm>
 
+// python under 3.13 doesn't has PyDict_ContainsString, so we implement it ourselves
+#if PY_VERSION_HEX < 0x030D0000
+static int
+PyDict_ContainsString(PyObject *op, const char *key)
+{
+    PyObject *key_obj = PyUnicode_FromString(key);
+    if (key_obj == NULL) {
+        return -1;
+    }
+    int res = PyDict_Contains(op, key_obj);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
 static const auto module_running_time = std::chrono::system_clock::now();
 
 static std::string
@@ -128,6 +143,12 @@ namespace {
     };
 };
 
+namespace AllSlots {
+    static getattrofunc original_getattro = nullptr;
+    static setattrofunc original_setattro = nullptr;
+    static destructor original_finalize = nullptr;
+}
+
 struct FinalObject
 {
     PyObject* result = NULL;
@@ -1191,6 +1212,8 @@ typedef struct {
 static void PrivateAttr_object_init_private_dict(uintptr_t obj_id, uintptr_t type_id);
 static void ensure_tp(PyTypeObject* type_instance);
 static void ensure_subclass_tp(PyTypeObject* type_instance);
+static int PrivateAttr_tp_setattro(PyObject* self, PyObject* name, PyObject* value);
+static void PrivateAttr_tp_finalize(PyObject* self);
 
 static PyObject*
 PrivateAttr_tp_getattro(PyObject* self, PyObject* name)
@@ -1212,8 +1235,11 @@ PrivateAttr_tp_getattro(PyObject* self, PyObject* name)
     }
     Py_XDECREF(code);
     if (::AllData::all_type_getattro.find(type_id) != ::AllData::all_type_getattro.end()){
-        PyObject* result = ::AllData::all_type_getattro[type_id](self, name);
-        return result;
+        if (::AllData::all_type_getattro[type_id]) {
+            PyObject* result = ::AllData::all_type_getattro[type_id](self, name);
+            ensure_tp(typ);
+            return result;
+        }
     }
     return PyObject_GenericGetAttr(self, name);
 }
@@ -1245,6 +1271,7 @@ PrivateAttr_tp_setattro(PyObject* self, PyObject* name, PyObject* value)
     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);
         return result;
     }
     return PyObject_GenericSetAttr(self, name, value);
@@ -1258,7 +1285,10 @@ PrivateAttr_tp_finalize(PyObject* self)
     uintptr_t typ_id = (uintptr_t)typ;
     Py_ssize_t original_ref = Py_REFCNT(self);
     if (::AllData::all_type_finalize.find(typ_id) != ::AllData::all_type_finalize.end()){
-        ::AllData::all_type_finalize[typ_id](self);
+        if (::AllData::all_type_finalize[typ_id]) {
+            ::AllData::all_type_finalize[typ_id](self);
+            ensure_tp(typ);
+        }
     }
     if (original_ref != Py_REFCNT(self)) {
         return;
@@ -1743,6 +1773,157 @@ need_analyse_type(PyObject* type)
     return false;
 }
 
+static void
+get_getattribute_and_getattr(PyTypeObject* cls, PyObject** getattribute, PyObject** getattr)
+{
+    bool has_getattribute = false;
+    bool has_getattr = false;
+    if (PyDict_ContainsString(cls->tp_dict, "__getattribute__")) {
+        *getattribute = PyDict_GetItemString(cls->tp_dict, "__getattribute__");
+        has_getattribute = true;
+    }
+    if (PyDict_ContainsString(cls->tp_dict, "__getattr__")) {
+        *getattr = PyDict_GetItemString(cls->tp_dict, "__getattr__");
+        has_getattr = true;
+    }
+    if (has_getattribute && has_getattr) {
+        return;
+    }
+    for (PyTypeObject* base = cls->tp_base; base != NULL && base != &PyBaseObject_Type; base = base->tp_base) {
+        if (!has_getattribute && PyDict_ContainsString(base->tp_dict, "__getattribute__")) {
+            *getattribute = PyDict_GetItemString(base->tp_dict, "__getattribute__");
+            has_getattribute = true;
+        }
+        if (!has_getattr && PyDict_ContainsString(base->tp_dict, "__getattr__")) {
+            *getattr = PyDict_GetItemString(base->tp_dict, "__getattr__");
+            has_getattr = true;
+        }
+        if (has_getattribute && has_getattr) {
+            return;
+        }
+    }
+}
+
+static void
+get_setattr_and_delattr(PyTypeObject* cls, PyObject** setattr, PyObject** delattr)
+{
+    bool has_setattr = false;
+    bool has_delattr = false;
+    if (PyDict_ContainsString(cls->tp_dict, "__setattr__")) {
+        *setattr = PyDict_GetItemString(cls->tp_dict, "__setattr__");
+        has_setattr = true;
+    }
+    if (PyDict_ContainsString(cls->tp_dict, "__delattr__")) {
+        *delattr = PyDict_GetItemString(cls->tp_dict, "__delattr__");
+        has_delattr = true;
+    }
+    if (has_setattr && has_delattr) {
+        return;
+    }
+    for (PyTypeObject* base = cls->tp_base; base != NULL && base != &PyBaseObject_Type; base = base->tp_base) {
+        if (!has_setattr && PyDict_ContainsString(base->tp_dict, "__setattr__")) {
+            *setattr = PyDict_GetItemString(base->tp_dict, "__setattr__");
+            has_setattr = true;
+        }
+        if (!has_delattr && PyDict_ContainsString(base->tp_dict, "__delattr__")) {
+            *delattr = PyDict_GetItemString(base->tp_dict, "__delattr__");
+            has_delattr = true;
+        }
+        if (has_setattr && has_delattr) {
+            return;
+        }
+    }
+}
+
+static void
+get_del(PyTypeObject* cls, PyObject** del)
+{
+    if (PyDict_ContainsString(cls->tp_dict, "__del__")) {
+        *del = PyDict_GetItemString(cls->tp_dict, "__del__");
+        return;
+    }
+    for (PyTypeObject* base = cls->tp_base; base != NULL && base != &PyBaseObject_Type; base = base->tp_base) {
+        if (PyDict_ContainsString(base->tp_dict, "__del__")) {
+            *del = PyDict_GetItemString(base->tp_dict, "__del__");
+            return;
+        }
+    }
+}
+
+static PyObject*
+python_original_tp_getattro(PyObject* self, PyObject* name)
+{
+    PyObject* getattriute = NULL;
+    PyObject* getattr = NULL;
+    get_getattribute_and_getattr((PyTypeObject*)self->ob_type, &getattriute, &getattr);
+    PyObject* res = NULL;
+    if (getattriute) {
+        res = PyObject_CallFunctionObjArgs(getattriute, self, name, NULL);
+    } else {
+        res = PyObject_GenericGetAttr(self, name);
+    }
+    if (!res && getattr) {
+        // check if the exception is AttributeError
+        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            return NULL;
+        }
+        PyErr_Clear();
+        res = PyObject_CallFunctionObjArgs(getattr, self, name, NULL);
+    }
+    return res;
+}
+
+static int
+python_original_tp_setattro(PyObject* self, PyObject* name, PyObject* value)
+{
+    PyObject* setattr = NULL;
+    PyObject* delattr = NULL;
+    get_setattr_and_delattr((PyTypeObject*)self->ob_type, &setattr, &delattr);
+    if (value && setattr) {
+        PyObject* res = PyObject_CallFunctionObjArgs(setattr, self, name, value, NULL);
+        if (!res) {
+            return -1;
+        }
+        Py_DECREF(res);
+        return 0;
+    } else if (!value && delattr) {
+        PyObject* res = PyObject_CallFunctionObjArgs(delattr, self, name, NULL);
+        if (!res) {
+            return -1;
+        }
+        Py_DECREF(res);
+        return 0;
+    }
+    return PyObject_GenericSetAttr(self, name, value);
+}
+
+static void
+python_original_tp_finalize(PyObject* self)
+{
+    PyObject* del = NULL;
+    get_del((PyTypeObject*)self->ob_type, &del);
+    if (del) {
+        PyObject *exc_type = NULL, *exc_value = NULL, *exc_tb = NULL;
+        PyErr_Fetch(&exc_type, &exc_value, &exc_tb); 
+        PyObject *result = PyObject_CallFunctionObjArgs(del, self, NULL);
+        if (result == NULL)  {
+            // python < 3.13 use PyErr_WriteUnraisable, python >= 3.13 use PyErr_FormatUnraisable
+# if PY_VERSION_HEX >= 0x030D0000
+            PyErr_FormatUnraisable("Exception ignored while "
+                                   "calling deallocator %R", del);
+# else
+            PyErr_WriteUnraisable(del);
+# endif
+        }
+        else {
+            Py_DECREF(result);
+        }
+        if (exc_type != NULL) {
+            PyErr_Restore(exc_type, exc_value, exc_tb);
+        }
+    }
+}
+
 static bool
 PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationData& data) 
 {
@@ -1809,7 +1990,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         }
 
         if (!PyUnicode_Check(attr)) {
-            PyErr_SetString(PyExc_TypeError, "all items in '__private_attrs__' must be strings");
+            PyErr_Format(PyExc_TypeError, "all items in '__private_attrs__' must be 'str', not '%.200s'", Py_TYPE(attr)->tp_name);
             return false;
         }
 
@@ -1821,7 +2002,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         std::string attr_str = real_class_name(attr_cstr, data.class_name);
 
         for (const char** p = invalid_name; *p != NULL; p++) {
-            if (attr_str == *p) {
+            if (strcmp(attr_str.c_str(), *p) == 0) {
                 std::string error_msg = "invalid attribute name: '" + std::string(*p) + "'";
                 PyErr_SetString(PyExc_TypeError, error_msg.c_str());
                 return false;
@@ -1842,10 +2023,10 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         return false;
     }
 
-    PyObject* all_slots = PyDict_GetItemString(data.attrs_copy, "__slots__");
-    bool has_slots = (all_slots != NULL);
+    int has_slots = PyDict_ContainsString(data.attrs_copy, "__slots__");
 
     if (has_slots) {
+        PyObject* all_slots = PyDict_GetItemString(data.attrs_copy, "__slots__");
         PyObject* slot_seq = PySequence_Fast(all_slots, "__slots__ must be a sequence");
         if (!slot_seq) {
             return false;
@@ -1866,8 +2047,6 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
             }
         }
         Py_DECREF(slot_seq);
-    } else {
-        PyErr_Clear();
     }
 
     Py_ssize_t bases_len = PyTuple_GET_SIZE(data.bases);
@@ -1927,16 +2106,16 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
 
     // get "private_func" from kwds
     if (kwds && PyDict_Check(kwds)) {
-        data.private_func = PyDict_GetItemString(kwds, "private_func");
-        if (data.private_func) {
+        bool has_private_func = PyDict_ContainsString(kwds, "private_func");
+        if (has_private_func) {
+            data.private_func = PyDict_GetItemString(kwds, "private_func");
             Py_INCREF(data.private_func);
         }
         data.base_kwds = PyDict_Copy(kwds);
         if (!data.base_kwds) {
             return false;
         }
-        PyDict_DelItemString(data.base_kwds, "private_func");
-        PyErr_Clear();
+        if (has_private_func) PyDict_DelItemString(data.base_kwds, "private_func");
     }
 
     return true;
@@ -1968,49 +2147,77 @@ PrivateAttrType_create(PyTypeObject* type, PrivateAttrCreationData& data)
     return new_type;
 }
 
+static getattrofunc get_need_tp_getattro(PyTypeObject* cls);
+static setattrofunc get_need_tp_setattro(PyTypeObject* cls);
+static destructor get_need_tp_finalize(PyTypeObject* cls);
+
 static void
 ensure_tp(PyTypeObject* type_instance)
 {
     uintptr_t type_id = (uintptr_t)(type_instance);
-    if (type_instance->tp_getattro) {
+    {
         if (type_instance->tp_getattro != PrivateAttr_tp_getattro) {
-            ::AllData::all_type_getattro[type_id] = type_instance->tp_getattro;
+            if (!type_instance->tp_getattro) {
+                ::AllData::all_type_getattro[type_id] = get_need_tp_getattro(type_instance);
+            } else {
+                ::AllData::all_type_getattro[type_id] = type_instance->tp_getattro;
+            }
             type_instance->tp_getattro = PrivateAttr_tp_getattro;
         } else {
-            PyTypeObject* base = type_instance->tp_base;
-            uintptr_t base_id = (uintptr_t)(base);
-            if (::AllData::all_type_getattro.find(base_id) != ::AllData::all_type_getattro.end()) {
-                ::AllData::all_type_getattro[type_id] = ::AllData::all_type_getattro[base_id];
-            } else if (base && base->tp_getattro && base->tp_getattro != PrivateAttr_tp_getattro) {
-                ::AllData::all_type_getattro[type_id] = base->tp_getattro;
+            if (PyDict_ContainsString(type_instance->tp_dict, "__getattribute__") || PyDict_ContainsString(type_instance->tp_dict, "__getattr__")) {
+                ::AllData::all_type_getattro[type_id] = AllSlots::original_getattro;
+            } else {
+                PyTypeObject* base = type_instance->tp_base;
+                uintptr_t base_id = (uintptr_t)(base);
+                if (::AllData::all_type_getattro.find(base_id) != ::AllData::all_type_getattro.end()) {
+                    ::AllData::all_type_getattro[type_id] = ::AllData::all_type_getattro[base_id];
+                } else if (base && base->tp_getattro && base->tp_getattro != PrivateAttr_tp_getattro) {
+                    ::AllData::all_type_getattro[type_id] = base->tp_getattro;
+                }
             }
         }
     }
-    if (type_instance->tp_setattro) {
+    {
         if (type_instance->tp_setattro != PrivateAttr_tp_setattro) {
-            ::AllData::all_type_setattro[type_id] = type_instance->tp_setattro;
+            if (!type_instance->tp_setattro) {
+                ::AllData::all_type_setattro[type_id] = get_need_tp_setattro(type_instance);
+            } else {
+                ::AllData::all_type_setattro[type_id] = type_instance->tp_setattro;
+            }
             type_instance->tp_setattro = PrivateAttr_tp_setattro;
         } else {
-            PyTypeObject* base = type_instance->tp_base;
-            uintptr_t base_id = (uintptr_t)(base);
-            if (::AllData::all_type_setattro.find(base_id) != ::AllData::all_type_setattro.end()) {
-                ::AllData::all_type_setattro[type_id] = ::AllData::all_type_setattro[base_id];
-            } else if (base && base->tp_setattro && base->tp_setattro != PrivateAttr_tp_setattro) {
-                ::AllData::all_type_setattro[type_id] = base->tp_setattro;
+            if (PyDict_ContainsString(type_instance->tp_dict, "__setattr__") || PyDict_ContainsString(type_instance->tp_dict, "__delattr__")) {
+                ::AllData::all_type_setattro[type_id] = AllSlots::original_setattro;
+            } else {
+                PyTypeObject* base = type_instance->tp_base;
+                uintptr_t base_id = (uintptr_t)(base);
+                if (::AllData::all_type_setattro.find(base_id) != ::AllData::all_type_setattro.end()) {
+                    ::AllData::all_type_setattro[type_id] = ::AllData::all_type_setattro[base_id];
+                } else if (base && base->tp_setattro && base->tp_setattro != PrivateAttr_tp_setattro) {
+                    ::AllData::all_type_setattro[type_id] = base->tp_setattro;
+                }
             }
         }
     }
-    if (type_instance->tp_finalize) {
+    {
         if (type_instance->tp_finalize != PrivateAttr_tp_finalize) {
-            ::AllData::all_type_finalize[type_id] = type_instance->tp_finalize;
+            if (!type_instance->tp_finalize) {
+                ::AllData::all_type_finalize[type_id] = get_need_tp_finalize(type_instance);
+            } else {
+                ::AllData::all_type_finalize[type_id] = type_instance->tp_finalize;
+            }
             type_instance->tp_finalize = PrivateAttr_tp_finalize;
         } else {
-            PyTypeObject* base = type_instance->tp_base;
-            uintptr_t base_id = (uintptr_t)(base);
-            if (::AllData::all_type_finalize.find(base_id) != ::AllData::all_type_finalize.end()) {
-                ::AllData::all_type_finalize[type_id] = ::AllData::all_type_finalize[base_id];
-            } else if (base && base->tp_finalize && base->tp_finalize != PrivateAttr_tp_finalize) {
-                ::AllData::all_type_finalize[type_id] = base->tp_finalize;
+            if (PyDict_ContainsString(type_instance->tp_dict, "__del__")) {
+                ::AllData::all_type_finalize[type_id] = AllSlots::original_finalize;
+            } else {
+                PyTypeObject* base = type_instance->tp_base;
+                uintptr_t base_id = (uintptr_t)(base);
+                if (::AllData::all_type_finalize.find(base_id) != ::AllData::all_type_finalize.end()) {
+                    ::AllData::all_type_finalize[type_id] = ::AllData::all_type_finalize[base_id];
+                } else if (base && base->tp_finalize && base->tp_finalize != PrivateAttr_tp_finalize) {
+                    ::AllData::all_type_finalize[type_id] = base->tp_finalize;
+                }
             }
         }
     }
@@ -2022,23 +2229,37 @@ ensure_subclass_tp(PyTypeObject* type_instance)
     // type.__subclasses__
     PyObject* type_subclasses = (PyObject*)type_instance->tp_subclasses;
     if (!type_subclasses) {
-        PyErr_Clear();
         return;
     }
-    if (!PyList_Check(type_subclasses)) {
-        Py_DECREF(type_subclasses);
+    if (!PyDict_Check(type_subclasses)) {
         return;
     }
-    Py_ssize_t subclasses_size = PyList_GET_SIZE(type_subclasses);
-    for (Py_ssize_t i = 0; i < subclasses_size; i++) {
-        PyObject* subclass = PyList_GET_ITEM(type_subclasses, i);
+    // check all values in the dict. It should be a weakref to a type. If not, continue.
+    PyObject* key, *value;
+    Py_ssize_t pos = 0;
+    while (PyDict_Next(type_subclasses, &pos, &key, &value)) {
+        if (!value || !PyWeakref_CheckRef(value)) {
+            continue;
+        }
+// python<3.13 use PyWeakref_GetObject, python>=3.13 use PyWeakref_GetRef
+#if PY_VERSION_HEX < 0x030D0000
+        PyObject* subclass = PyWeakref_GetObject(value);
         if (!subclass || !PyType_Check(subclass)) {
             continue;
         }
         ensure_tp((PyTypeObject*)subclass);
-        ensure_subclass_tp((PyTypeObject*)subclass);
+#else
+        PyObject* subclass;
+        if (PyWeakref_GetRef(value, (PyObject**)&subclass) != 0) {
+            continue;
+        }
+        if (!subclass || !PyType_Check(subclass)) {
+            continue;
+        }
+        ensure_tp((PyTypeObject*)subclass);
+        Py_XDECREF(subclass);
+#endif
     }
-    Py_DECREF(type_subclasses);
 }
 
 static bool
@@ -2052,6 +2273,15 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data)
     uintptr_t type_id = (uintptr_t)(type_instance);
 
     ensure_tp(type_instance);
+    if (PyDict_ContainsString(type_instance->tp_dict, "__getattribute__") || PyDict_ContainsString(type_instance->tp_dict, "__getattr__")) {
+        ::AllData::all_type_getattro[type_id] = AllSlots::original_getattro;
+    }
+    if (PyDict_ContainsString(type_instance->tp_dict, "__setattr__") || PyDict_ContainsString(type_instance->tp_dict, "__delattr__")) {
+        ::AllData::all_type_setattro[type_id] = AllSlots::original_setattro;
+    }
+    if (PyDict_ContainsString(type_instance->tp_dict, "__del__")) {
+        ::AllData::all_type_finalize[type_id] = AllSlots::original_finalize;
+    }
 
     ::AllData::type_attr_dict[type_id] = {};
     ::AllData::all_type_attr_set[type_id] = data.private_attrs_set;
@@ -2205,6 +2435,139 @@ PrivateAttrType_getattr(PyObject* cls, PyObject* name)
     return result;
 }
 
+static int
+init_all_slots()
+{
+    AllSlots::original_getattro = python_original_tp_getattro;
+    AllSlots::original_setattro = python_original_tp_setattro;
+    AllSlots::original_finalize = python_original_tp_finalize;
+    return 0;
+}
+
+static getattrofunc
+get_need_tp_getattro(PyTypeObject* cls)
+{
+    if (PyDict_ContainsString(cls->tp_dict, "__getattribute__") || PyDict_ContainsString(cls->tp_dict, "__getattr__")) {
+        return AllSlots::original_getattro;
+    }
+    PyTypeObject* base = cls->tp_base;
+    while (base) {
+        if (base->tp_getattro != PrivateAttr_tp_getattro) {
+            return base->tp_getattro;
+        } else if (::AllData::all_type_getattro.find((uintptr_t)base) != ::AllData::all_type_getattro.end()) {
+            if (::AllData::all_type_getattro[(uintptr_t)base]) {
+                return ::AllData::all_type_getattro[(uintptr_t)base];
+            }
+            base = base->tp_base;
+        } else {
+            base = base->tp_base;
+        }
+    }
+    return NULL;
+}
+
+static setattrofunc
+get_need_tp_setattro(PyTypeObject* cls)
+{
+    if (PyDict_ContainsString(cls->tp_dict, "__setattr__") || PyDict_ContainsString(cls->tp_dict, "__delattr__")) {
+        return AllSlots::original_setattro;
+    }
+    PyTypeObject* base = cls->tp_base;
+    while (base) {
+        if (base->tp_setattro != PrivateAttr_tp_setattro) {
+            return base->tp_setattro;
+        } else if (::AllData::all_type_setattro.find((uintptr_t)base) != ::AllData::all_type_setattro.end()) {
+            if (::AllData::all_type_setattro[(uintptr_t)base]) {
+                return ::AllData::all_type_setattro[(uintptr_t)base];
+            }
+            base = base->tp_base;
+        } else {
+            base = base->tp_base;
+        }
+    }
+    return NULL;
+}
+
+static destructor
+get_need_tp_finalize(PyTypeObject* cls)
+{
+    if (PyDict_ContainsString(cls->tp_dict, "__del__")) {
+        return AllSlots::original_finalize;
+    }
+    PyTypeObject* base = cls->tp_base;
+    while (base) {
+        if (base->tp_finalize != PrivateAttr_tp_finalize) {
+            return base->tp_finalize;
+        } else if (::AllData::all_type_finalize.find((uintptr_t)base) != ::AllData::all_type_finalize.end()) {
+            if (::AllData::all_type_finalize[(uintptr_t)base]) {
+                return ::AllData::all_type_finalize[(uintptr_t)base];
+            }
+            base = base->tp_base;
+        } else {
+            base = base->tp_base;
+        }
+    }
+    return NULL;
+}
+
+static void
+type_change_all_slots(PyTypeObject* cls, const char* name)
+{
+    if (strcmp(name, "__getattribute__") == 0 || strcmp(name, "__getattr__") == 0) {
+        cls->tp_getattro = PrivateAttr_tp_getattro;
+        ::AllData::all_type_getattro[(uintptr_t)cls] = get_need_tp_getattro(cls);
+    } else if (strcmp(name, "__setattr__") == 0 || strcmp(name, "__delattr__") == 0) {
+        cls->tp_setattro = PrivateAttr_tp_setattro;
+        ::AllData::all_type_setattro[(uintptr_t)cls] = get_need_tp_setattro(cls);
+    } else if (strcmp(name, "__del__") == 0) {
+        cls->tp_finalize = PrivateAttr_tp_finalize;
+        ::AllData::all_type_finalize[(uintptr_t)cls] = get_need_tp_finalize(cls);
+    }
+}
+
+static void
+subtype_change_all_slots(PyTypeObject* cls, const char* name)
+{
+    // tp_subclasses: {id(type): weakref.ref(type)}
+    PyObject* tp_subclasses = (PyObject*)cls->tp_subclasses;
+    if (!tp_subclasses) {
+        return;
+    }
+    if (!PyDict_Check(tp_subclasses)) {
+        return;
+    }
+    PyObject* key;
+    PyObject* value;
+    Py_ssize_t pos = 0;
+    while (PyDict_Next(tp_subclasses, &pos, &key, &value)) {
+        if (!PyWeakref_Check(value)) {
+            continue;
+        }
+#if PY_VERSION_HEX < 0x030D0000
+        PyObject* obj = PyWeakref_GET_OBJECT(value);
+        if (!obj) {
+            continue;
+        }
+#else
+        PyObject* obj;
+        if (PyWeakref_GetRef(value, &obj) != 0) {
+            continue;
+        }
+        if (!obj) {
+            continue;
+        }
+#endif
+        if (!PyType_Check(obj)) {
+            continue;
+        }
+        PyTypeObject* sub_cls = (PyTypeObject*)obj;
+        type_change_all_slots(sub_cls, name);
+#if PY_VERSION_HEX >= 0x030D0000
+        Py_XDECREF(obj);
+#endif
+    }
+}
+
 static int
 PrivateAttrType_setattr(PyObject* cls, PyObject* name, PyObject* value)
 {
@@ -2231,6 +2594,33 @@ PrivateAttrType_setattr(PyObject* cls, PyObject* name, PyObject* value)
         return type_setattr(cls, name_str, value);
     }
     Py_XDECREF(now_code);
+    // if name in __getattribute__, __setattr__, __delattr__, __del__, just set to tp_dict
+    if (strcmp(name_str.c_str(), "__getattribute__") == 0 ||
+        strcmp(name_str.c_str(), "__getattr__") == 0 ||
+        strcmp(name_str.c_str(), "__setattr__") == 0 ||
+        strcmp(name_str.c_str(), "__delattr__") == 0 ||
+        strcmp(name_str.c_str(), "__del__") == 0) {
+        PyObject* tp_dict = ((PyTypeObject*)cls)->tp_dict;
+        if (!tp_dict) {
+            PyErr_SetString(PyExc_TypeError, "type has no tp_dict");
+            return -1;
+        }
+        if (!value) {
+            if (PyDict_DelItem(tp_dict, name) < 0) {
+                PyErr_Format(PyExc_AttributeError, "type object '%.100s' has no attribute '%U'", ((PyTypeObject*)cls)->tp_name, name);
+                return -1;
+            }
+            type_change_all_slots((PyTypeObject*)cls, name_str.c_str());
+            subtype_change_all_slots((PyTypeObject*)cls, name_str.c_str());
+            return 0;
+        }
+        if (PyDict_SetItem(tp_dict, name, value) < 0) {
+            return -1;
+        }
+        type_change_all_slots((PyTypeObject*)cls, name_str.c_str());
+        subtype_change_all_slots((PyTypeObject*)cls, name_str.c_str());
+        return 0;
+    }
     PyTypeObject* base = Py_TYPE(cls)->tp_base;
     while (base && base->tp_base && base->tp_setattro == PrivateAttrType_setattr) {
         base = base->tp_base;
@@ -2316,7 +2706,7 @@ static void
 PrivateAttrType_del(PyObject* cls)
 {
     PrivateAttrType_finalize(cls);
-    (Py_TYPE(cls))->tp_free(cls);
+    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.";
@@ -2775,7 +3165,8 @@ static PyModuleDef def = {
 PyMODINIT_FUNC
 PyInit_private_attribute(void)
 {
-    if (PyType_Ready(&PrivateWrapType) < 0 ||
+    if (init_all_slots() <0 ||
+        PyType_Ready(&PrivateWrapType) < 0 ||
         PyType_Ready(&PrivateWrapProxyType) < 0 ||
         PyType_Ready(&PrivateAttrType) < 0 ||
         PyType_Ready(&PrivateModuleType) < 0 ||

{private_attribute_cpp-1.3.6 → private_attribute_cpp-1.3.8/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.3.6
+Version: 1.3.8
 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-1.3.6 → private_attribute_cpp-1.3.8}/setup.py

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