private-attribute-cpp 2.1.4__tar.gz → 2.1.6__tar.gz

{private_attribute_cpp-2.1.4/private_attribute_cpp.egg-info → private_attribute_cpp-2.1.6}/PKG-INFO

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

@@ -203,6 +203,7 @@ namespace {
         };
         static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t, std::shared_ptr<std::shared_mutex>>>
             all_object_mutex, all_type_subclass_mutex;
+        static std::mutex object_creatmutex_mutex, type_createmutex_mutex, type_parenttype_createmutex_mutex;
         static std::unordered_map<uintptr_t, std::vector<uintptr_t>> all_type_parent_id;
         // all type tp_getattro map
         static std::unordered_map<uintptr_t, getattrofunc> all_type_getattro;
@@ -219,15 +220,63 @@ namespace {
         // defaults as "not a real original" and keep walking upward.
         static traverseproc captured_subtype_traverse = NULL;
         static inquiry captured_subtype_clear = NULL;
-        // all type tp_finalizer map
-        static std::unordered_map<uintptr_t, destructor> all_type_finalize;
+        static std::unordered_map<uintptr_t, destructor> all_type_del;
 
         static std::shared_mutex all_register_new_metaclass_mutex;
         static std::unordered_map<uintptr_t, PyObjectStorage> all_register_type_weak_ref;
+        static std::vector<PyObjectStorage> store_module_self;
     };
 };
 
-static void
+static inline void
+object_create_mutex(uintptr_t final_id, uintptr_t obj_id) noexcept
+{
+    // get object_creatmutex_mutex
+    std::lock_guard<std::mutex> lock(AllData::object_creatmutex_mutex);
+    if (::AllData::all_object_attr[final_id].find(obj_id) == ::AllData::all_object_attr[final_id].end()) {
+        ::AllData::all_object_attr[final_id][obj_id] = {};
+    }
+    if (::AllData::all_object_mutex.find(final_id) == ::AllData::all_object_mutex.end()) {
+        ::AllData::all_object_mutex[final_id] = {};
+    }
+    if (::AllData::all_object_mutex[final_id].find(obj_id) == ::AllData::all_object_mutex[final_id].end()) {
+        std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
+        ::AllData::all_object_mutex[final_id][obj_id] = lock;
+    }
+}
+
+static inline void
+type_create_mutex(uintptr_t typ_id) noexcept {
+    std::lock_guard<std::mutex> lock(AllData::type_createmutex_mutex);
+    if (::AllData::type_attr_dict.find(typ_id) == ::AllData::type_attr_dict.end()) {
+        ::AllData::type_attr_dict[typ_id] = {};
+    }
+    if (::AllData::all_type_mutex.find(typ_id) == ::AllData::all_type_mutex.end()) {
+        std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
+        ::AllData::all_type_mutex[typ_id] = lock;
+    }
+}
+
+static inline void
+type_parenttype_create_mutex(uintptr_t final_id, uintptr_t typ_id) noexcept
+{
+    std::lock_guard<std::mutex> lock(AllData::type_parenttype_createmutex_mutex);
+    if (::AllData::all_type_subclass_attr.find(final_id) == ::AllData::all_type_subclass_attr.end()) {
+        ::AllData::all_type_subclass_attr[final_id] = {};
+    }
+    if (::AllData::all_type_subclass_attr[final_id].find(typ_id) == ::AllData::all_type_subclass_attr[final_id].end()) {
+        ::AllData::all_type_subclass_attr[final_id][typ_id] = {};
+    }
+    if (::AllData::all_type_subclass_mutex.find(final_id) == ::AllData::all_type_subclass_mutex.end()) {
+        ::AllData::all_type_subclass_mutex[final_id] = {};
+    }
+    if (::AllData::all_type_subclass_mutex[final_id].find(typ_id) == ::AllData::all_type_subclass_mutex[final_id].end()) {
+        std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
+        ::AllData::all_type_subclass_mutex[final_id][typ_id] = lock;
+    }
+}
+
+static inline void
 clean_all_storages() noexcept
 {
     AllData::cache.clear();
@@ -247,8 +296,9 @@ clean_all_storages() noexcept
     AllData::all_type_setattro.clear();
     AllData::all_type_traverse.clear();
     AllData::all_type_clear.clear();
-    AllData::all_type_finalize.clear();
+    AllData::all_type_del.clear();
     AllData::all_register_type_weak_ref.clear();
+    AllData::store_module_self.clear();
 }
 
 struct FinalObject
@@ -563,16 +613,7 @@ id_getattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
         PyErr_SetString(PyExc_TypeError, "type not found");
         return NULL;
     }
-    if (::AllData::all_object_attr[final_id].find(obj_id) == ::AllData::all_object_attr[final_id].end()) {
-        ::AllData::all_object_attr[final_id][obj_id] = {};
-    }
-    if (::AllData::all_object_mutex.find(final_id) == ::AllData::all_object_mutex.end()) {
-        ::AllData::all_object_mutex[final_id] = {};
-    }
-    if (::AllData::all_object_mutex[final_id].find(obj_id) == ::AllData::all_object_mutex[final_id].end()) {
-        std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-        ::AllData::all_object_mutex[final_id][obj_id] = lock;
-    }
+    object_create_mutex(final_id, obj_id);
     PyObject* result = NULL;
     if (final_object.status != -1) {
         result = final_object.result;
@@ -699,16 +740,7 @@ id_setattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
         PyErr_SetString(PyExc_TypeError, "type not found");
         return -1;
     }
-    if (::AllData::all_object_attr[final_id].find(obj_id) == ::AllData::all_object_attr[final_id].end()) {
-        ::AllData::all_object_attr[final_id][obj_id] = {};
-    }
-    if (::AllData::all_object_mutex.find(final_id) == ::AllData::all_object_mutex.end()) {
-        ::AllData::all_object_mutex[final_id] = {};
-    }
-    if (::AllData::all_object_mutex[final_id].find(obj_id) == ::AllData::all_object_mutex[final_id].end()) {
-        std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-        ::AllData::all_object_mutex[final_id][obj_id] = lock;
-    }
+    object_create_mutex(final_id, obj_id);
     // first: call __set__ method
     PyObject* result = NULL;
     if (final_object.status != -1) {
@@ -764,13 +796,7 @@ type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexc
         return -1;
     }
     if (final_id == typ_id) {
-        if (::AllData::type_attr_dict.find(typ_id) == ::AllData::type_attr_dict.end()) {
-            ::AllData::type_attr_dict[typ_id] = {};
-        }
-        if (::AllData::all_type_mutex.find(typ_id) == ::AllData::all_type_mutex.end()) {
-            std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-            ::AllData::all_type_mutex[typ_id] = lock;
-        }
+        type_create_mutex(typ_id);
         {
             std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[typ_id]);
             ::AllData::type_attr_dict[typ_id][final_key] = value;
@@ -779,19 +805,7 @@ type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexc
     } else {
         // The accessed class is a subclass that stores its own value for a
         // parent's private name separately: all_type_subclass_attr[final_id][typ_id].
-        if (::AllData::all_type_subclass_attr.find(final_id) == ::AllData::all_type_subclass_attr.end()) {
-            ::AllData::all_type_subclass_attr[final_id] = {};
-        }
-        if (::AllData::all_type_subclass_attr[final_id].find(typ_id) == ::AllData::all_type_subclass_attr[final_id].end()) {
-            ::AllData::all_type_subclass_attr[final_id][typ_id] = {};
-        }
-        if (::AllData::all_type_subclass_mutex.find(final_id) == ::AllData::all_type_subclass_mutex.end()) {
-            ::AllData::all_type_subclass_mutex[final_id] = {};
-        }
-        if (::AllData::all_type_subclass_mutex[final_id].find(typ_id) == ::AllData::all_type_subclass_mutex[final_id].end()) {
-            std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-            ::AllData::all_type_subclass_mutex[final_id][typ_id] = lock;
-        }
+        type_parenttype_create_mutex(final_id, typ_id);
         {
             std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_subclass_mutex[final_id][typ_id]);
             ::AllData::all_type_subclass_attr[final_id][typ_id][final_key] = value;
@@ -830,16 +844,7 @@ id_delattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
         PyErr_SetString(PyExc_TypeError, "type not found");
         return -1;
     }
-    if (::AllData::all_object_attr[final_id].find(obj_id) == ::AllData::all_object_attr[final_id].end()) {
-        ::AllData::all_object_attr[final_id][obj_id] = {};
-    }
-    if (::AllData::all_object_mutex.find(final_id) == ::AllData::all_object_mutex.end()) {
-        ::AllData::all_object_mutex[final_id] = {};
-    }
-    if (::AllData::all_object_mutex[final_id].find(obj_id) == ::AllData::all_object_mutex[final_id].end()) {
-        std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-        ::AllData::all_object_mutex[final_id][obj_id] = lock;
-    }
+    object_create_mutex(final_id, obj_id);
     // first: find attribute on type to find "__delete__"
     PyObject* result = NULL;
     if (final_object.status == 0) {
@@ -897,13 +902,7 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
         return -1;
     }
     if (typ_id == final_id) {
-        if (::AllData::type_attr_dict.find(typ_id) == ::AllData::type_attr_dict.end()) {
-            ::AllData::type_attr_dict[typ_id] = {};
-        }
-        if (::AllData::all_type_mutex.find(typ_id) == ::AllData::all_type_mutex.end()) {
-            std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-            ::AllData::all_type_mutex[typ_id] = lock;
-        }
+        type_create_mutex(typ_id);
         std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[typ_id]);
         if (::AllData::type_attr_dict[typ_id].find(final_key) == ::AllData::type_attr_dict[typ_id].end()) {
             const char* type_name = get_name_from_tp_name((PyTypeObject*)typ);
@@ -915,19 +914,7 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
         }
         ::AllData::type_attr_dict[typ_id].erase(final_key);
     } else {
-        if (::AllData::all_type_subclass_attr.find(final_id) == ::AllData::all_type_subclass_attr.end()) {
-            ::AllData::all_type_subclass_attr[final_id] = {};
-        }
-        if (::AllData::all_type_subclass_attr[final_id].find(typ_id) == ::AllData::all_type_subclass_attr[final_id].end()) {
-            ::AllData::all_type_subclass_attr[final_id][typ_id] = {};
-        }
-        if (::AllData::all_type_subclass_mutex.find(final_id) == ::AllData::all_type_subclass_mutex.end()) {
-            ::AllData::all_type_subclass_mutex[final_id] = {};
-        }
-        if (::AllData::all_type_subclass_mutex[final_id].find(typ_id) == ::AllData::all_type_subclass_mutex[final_id].end()) {
-            std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-            ::AllData::all_type_subclass_mutex[final_id][typ_id] = lock;
-        }
+        type_parenttype_create_mutex(final_id, typ_id);
         std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_subclass_mutex[final_id][typ_id]);
         if (::AllData::all_type_subclass_attr[final_id][typ_id].find(final_key) == ::AllData::all_type_subclass_attr[final_id][typ_id].end()) {
             const char* type_name = get_name_from_tp_name((PyTypeObject*)typ);
@@ -1364,6 +1351,7 @@ typedef struct {
 static void PrivateAttr_object_init_private_dict(uintptr_t obj_id, uintptr_t type_id) noexcept;
 static int PrivateAttr_tp_setattro(PyObject* self, PyObject* name, PyObject* value) noexcept;
 static void PrivateAttr_tp_finalize(PyObject* self) noexcept;
+static void clear_object_related(uintptr_t id_self, uintptr_t typ_id) noexcept;
 
 static PyObject*
 PrivateAttr_tp_getattro(PyObject* self, PyObject* name) noexcept
@@ -1441,60 +1429,6 @@ PrivateAttr_tp_setattro(PyObject* self, PyObject* name, PyObject* value) noexcep
     return PyObject_GenericSetAttr(self, name, value);
 }
 
-static void
-PrivateAttr_tp_finalize(PyObject* self) noexcept
-{
-    uintptr_t id_self = (uintptr_t)self;
-    PyTypeObject* typ = Py_TYPE(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()){
-        if (::AllData::all_type_finalize[typ_id]) {
-            ::AllData::all_type_finalize[typ_id](self);
-            ensure_tp(typ);
-        }
-    }
-    if (original_ref != Py_REFCNT(self)) {
-        return;
-    }
-    std::vector<uintptr_t> parent_ids;
-    if (::AllData::all_type_parent_id.find(typ_id) != ::AllData::all_type_parent_id.end()){
-        parent_ids = ::AllData::all_type_parent_id[typ_id];
-    }
-
-    {
-        // first: clear ::AllData::all_object_attr and ::AllData::all_object_mutex on this typ_id
-        if (::AllData::all_object_attr.find(typ_id) != ::AllData::all_object_attr.end()){
-            auto& all_object_attr = ::AllData::all_object_attr[typ_id];
-            if (all_object_attr.find(id_self) != all_object_attr.end()){
-                all_object_attr.erase(id_self);
-            }
-        }
-        if (::AllData::all_object_mutex.find(typ_id) != ::AllData::all_object_mutex.end()){
-            auto& all_object_mutex = ::AllData::all_object_mutex[typ_id];
-            if (all_object_mutex.find(id_self) != all_object_mutex.end()){
-                all_object_mutex.erase(id_self);
-            }
-        }
-        // second: clear the above in parent types
-        for (auto& parent_id : parent_ids){
-            if (::AllData::all_object_attr.find(parent_id) != ::AllData::all_object_attr.end()){
-                auto& all_object_attr = ::AllData::all_object_attr[parent_id];
-                if (all_object_attr.find(id_self) != all_object_attr.end()){
-                    all_object_attr.erase(id_self);
-                }
-            }
-            if (::AllData::all_object_mutex.find(parent_id) != ::AllData::all_object_mutex.end()){
-                auto& all_object_mutex = ::AllData::all_object_mutex[parent_id];
-                if (all_object_mutex.find(id_self) != all_object_mutex.end()){
-                    all_object_mutex.erase(id_self);
-                }
-            }
-        }
-        clear_obj(id_self);
-    }
-}
-
 // shared helper for clearing object-related data (used by tp_clear and tp_finalize)
 static void
 clear_object_related(uintptr_t id_self, uintptr_t typ_id) noexcept
@@ -1606,6 +1540,61 @@ PrivateAttr_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
         }
     }
 
+    // Instance-dict visit (mirror of subtype_traverse's dictoffset block).
+    // The saved "original" for a private-attribute class is subtype_traverse,
+    // but because the class's LIVE tp_traverse has been replaced with this
+    // wrapper, subtype_traverse skips its own slot-walking loop, keeps base ==
+    // typ, and its `type->tp_dictoffset != base->tp_dictoffset` check sees equal
+    // offsets -> it never visits the instance __dict__. The instance __dict__
+    // (e.g. `self.__dict__['x'] = self` self-cycles) would then be invisible to
+    // the collector and leak. Do the visit explicitly here instead.
+    //
+    // The managed-dict API is version-dependent: 3.13+ exposes the public
+    // PyObject_VisitManagedDict, 3.12 only the internal _PyObject_VisitManagedDict,
+    // and <=3.11 has no managed dict at all (classic positive tp_dictoffset,
+    // visited through _PyObject_GetDictPtr like subtype_traverse does).
+#if PY_VERSION_HEX >= 0x030D0000
+    if ((typ->tp_flags & Py_TPFLAGS_MANAGED_DICT)
+        && typ->tp_dictoffset == -1) {
+        int err = PyObject_VisitManagedDict(self, visit, arg);
+        if (err) {
+            return err;
+        }
+    }
+#elif PY_VERSION_HEX >= 0x030C0000
+    if ((typ->tp_flags & Py_TPFLAGS_MANAGED_DICT)
+        && typ->tp_dictoffset == -1) {
+        int err = _PyObject_VisitManagedDict(self, visit, arg);
+        if (err) {
+            return err;
+        }
+    }
+#else
+    PyObject** dictptr = _PyObject_GetDictPtr(self);
+    if (dictptr && *dictptr) {
+        int err = visit(*dictptr, arg);
+        if (err) {
+            return err;
+        }
+    }
+#endif
+
+    // Instance->type link (mirror of subtype_traverse's heap-type visit).
+    // subtype_traverse(self) does Py_VISIT(Py_TYPE(self)) only when the
+    // resolved base traverse does NOT belong to a heap type. Because the
+    // instance's LIVE tp_traverse has been replaced with this wrapper,
+    // subtype_traverse keeps base == typ (heap), so that Py_VISIT is skipped
+    // and a cycle like  A ->(tp_dict)-> a  and  a ->(ob_type)-> A  is invisible
+    // to the collector. Visit the instance's type explicitly when it is a heap
+    // type, matching subtype_traverse's intent. (This is the same fix applied
+    // to the metaclass wrapper PrivateAttrType_tp_traverse.)
+    {
+        PyTypeObject* meta = Py_TYPE(self);
+        if (meta && (meta->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
+            Py_VISIT((PyObject*)meta);
+        }
+    }
+
     // traverse per-object private attributes for this type and its parents
     std::vector<uintptr_t> parent_ids;
     if (::AllData::all_type_parent_id.find(typ_id) != ::AllData::all_type_parent_id.end()){
@@ -1656,11 +1645,99 @@ PrivateAttr_tp_clear(PyObject* self) noexcept
         if (orig) orig(self);
     }
 
+    // Instance-dict clear (mirror of subtype_clear's dict handling). Same
+    // reasoning as the traverse side: subtype_clear can't run its dict block
+    // once the LIVE tp_clear has been replaced, so clear the instance dict
+    // explicitly to break __dict__ self-cycles. Version-dependent APIs, see
+    // the matching traverse block above.
+#if PY_VERSION_HEX >= 0x030D0000
+    if ((typ->tp_flags & Py_TPFLAGS_MANAGED_DICT)
+        && typ->tp_dictoffset == -1) {
+        PyObject_ClearManagedDict(self);
+    }
+#elif PY_VERSION_HEX >= 0x030C0000
+    if ((typ->tp_flags & Py_TPFLAGS_MANAGED_DICT)
+        && typ->tp_dictoffset == -1) {
+        _PyObject_ClearManagedDict(self);
+    }
+#else
+    PyObject** dictptr = _PyObject_GetDictPtr(self);
+    if (dictptr && *dictptr) {
+        Py_CLEAR(*dictptr);
+    }
+#endif
+
     // clear our per-object data
     clear_object_related(id_self, typ_id);
     return 0;
 }
 
+class KeepPythonException {
+private:
+    PyObject* typ;
+    PyObject* exc;
+    PyObject* tb;
+public:
+    KeepPythonException() noexcept {
+        // under 3.12 use PyErr_Fetch
+#if PY_VERSION_HEX < 0x030C0000
+        PyErr_Fetch(&typ, &exc, &tb);
+#else
+        exc = PyErr_GetRaisedException();
+#endif
+    }
+
+    ~KeepPythonException() noexcept {
+        // under 3.12 use PyErr_Restore
+#if PY_VERSION_HEX < 0x030C0000
+        PyErr_Restore(typ, exc, tb);
+#else
+        PyErr_SetRaisedException(exc);
+#endif
+    }
+};
+
+static void
+PrivateAttr_tp_finalize(PyObject* self) noexcept
+{
+    KeepPythonException _;
+    uintptr_t id_self = (uintptr_t)self;
+    PyTypeObject* typ = Py_TYPE(self);
+    uintptr_t typ_id = (uintptr_t)typ;
+
+    Py_ssize_t refcnt = Py_REFCNT(self);
+    // Chain to the original tp_finalize if there is one.
+    if (::AllData::all_type_del.find(typ_id) != ::AllData::all_type_del.end()) {
+        destructor orig = ::AllData::all_type_del[typ_id];
+        if (orig && orig != PrivateAttr_tp_finalize) {
+            orig(self);
+        }
+    }
+    if (Py_REFCNT(self) > refcnt) {
+        return;
+    }
+    clear_object_related(id_self, typ_id);
+}
+
+static destructor
+get_need_tp_finalize(PyTypeObject* cls) noexcept
+{
+    PyTypeObject* base = cls->tp_base;
+    while (base) {
+        if (base->tp_finalize != PrivateAttr_tp_finalize) {
+            return base->tp_finalize;
+        } else if (::AllData::all_type_del.find((uintptr_t)base) != ::AllData::all_type_del.end()) {
+            if (::AllData::all_type_del[(uintptr_t)base]) {
+                return ::AllData::all_type_del[(uintptr_t)base];
+            }
+            base = base->tp_base;
+        } else {
+            base = base->tp_base;
+        }
+    }
+    return NULL;
+}
+
 // get_type_need_tp_* : the metaclass counterparts of get_need_tp_*.
 // get_need_tp_*          -> find the original slots of *types created by* the
 //                            metaclasses (wrapped with the instance-level
@@ -1668,13 +1745,12 @@ PrivateAttr_tp_clear(PyObject* self) noexcept
 // get_type_need_tp_*     -> find the original slots of the *metaclasses*
 //                            themselves (wrapped with the metaclass-level
 //                            PrivateAttrType_getattr / PrivateAttrType_setattr /
-//                            register_finalize / PrivateAttrType_tp_traverse /
+//                            PrivateAttrType_tp_traverse /
 //                            PrivateAttrType_tp_clear).
 static getattrofunc get_type_need_tp_getattro(PyTypeObject* cls) noexcept;
 static setattrofunc get_type_need_tp_setattro(PyTypeObject* cls) noexcept;
 static traverseproc get_type_need_tp_traverse(PyTypeObject* cls) noexcept;
 static inquiry get_type_need_tp_clear(PyTypeObject* cls) noexcept;
-static destructor get_type_need_tp_finalize(PyTypeObject* cls) noexcept;
 
 // metaclass-level (type object) traverse/clear: call original if any, and handle AllData-stored type attributes
 static int
@@ -1689,14 +1765,15 @@ PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
     }
     PrivateAttrRecursionGuard guard((uintptr_t)self);
 
-    // Call saved/original traverse if exists
-    if (::AllData::all_type_traverse.find(typ_id) != ::AllData::all_type_traverse.end()) {
-        traverseproc orig = ::AllData::all_type_traverse[typ_id];
-        if (orig) {
-            int res = orig(self, visit, arg);
-            if (res) return res;
-        }
-    } else {
+    // Recover the original traverse via get_type_need_tp_traverse, skipping
+    // any delegating default (subtype_traverse / PrivateAttr_tp_traverse / our
+    // own wrapper). For a type object the only correct "real" traverse is
+    // CPython's type_traverse; when no real one exists (plain class objects
+    // delegate through subtype_traverse, which would follow the LIVE tp_traverse
+    // slot straight back into this wrapper), we rely on the AllData traversal
+    // below to reach the class's hard self-cycle (tp_dict / tp_mro / tp_bases)
+    // through the type-level private attributes we visit.
+    {
         traverseproc orig = get_type_need_tp_traverse(typ);
         if (orig) {
             int res = orig(self, visit, arg);
@@ -1704,6 +1781,24 @@ PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
         }
     }
 
+    // Mirror CPython's subtype_traverse for the instance->type link.
+    // subtype_traverse(self) does Py_VISIT(Py_TYPE(self)) when the instance is
+    // a heap type and the resolved base traverse does not belong to a heap
+    // type, so cycles between a class object and its (heap) metaclass are
+    // visible to the collector. type_traverse alone does NOT visit ob_type:
+    // it only walks tp_dict / tp_mro / tp_bases, so without this step a cycle
+    // like  M ->(dict attr)-> C  and  C ->(ob_type)-> M  is invisible to GC
+    // and leaks. self here is a TYPE object; its Py_TYPE is the metaclass
+    // (which is a heap type when registered/created by type()). We only emit
+    // the visit when the metaclass is a heap type, matching subtype_traverse's
+    // condition and avoiding the trivial/static type link.
+    {
+        PyTypeObject* meta = Py_TYPE(self);
+        if (meta && (meta->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
+            Py_VISIT((PyObject*)meta);
+        }
+    }
+
     // Traverse PyObjects stored in AllData for this type:
     // - direct type attributes ::AllData::type_attr_dict[typ_id]
     // - attributes stored under parents for this type ::AllData::all_type_subclass_attr[parent_id][typ_id]
@@ -1779,13 +1874,21 @@ PrivateAttrType_tp_clear(PyObject* self) noexcept
     }
     PrivateAttrRecursionGuard guard((uintptr_t)self);
 
-    // Call saved/original clear if exists
-    if (::AllData::all_type_clear.find(typ_id) != ::AllData::all_type_clear.end()) {
-        inquiry orig = ::AllData::all_type_clear[typ_id];
-        if (orig) orig(self);
-    } else {
+    // Recover the original clear via get_type_need_tp_clear, skipping any
+    // delegating default (subtype_clear / PrivateAttr_tp_clear / our own
+    // wrapper). subtype_clear on a type object would clear the class's own
+    // tp_dict (its namespace), which must never happen here; when the walker
+    // finds no real clear, the AllData cleanup below still breaks the cycle by
+    // clearing the type-level private attributes we stored (their PyObjectStorage
+    // DECREFs release the references that keep the class's tp_dict / tp_mro /
+    // ht_module alive), after which CPython's own type_clear runs on the class
+    // once the collector re-visits it.
+    {
         inquiry orig = get_type_need_tp_clear(typ);
-        if (orig) orig(self);
+        if (orig) {
+            int result = orig(self);
+            if (result) return result;
+        }
     }
 
     // Clear AllData entries associated with this type. PyObjectStorage destructor
@@ -1866,10 +1969,11 @@ static PyTypeObject PrivateAttrType = {
     (getattrofunc)PrivateAttrType_getattr,      // tp_getattro
     (setattrofunc)PrivateAttrType_setattr,      // tp_setattro
     0,                                          // tp_as_buffer
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,   // tp_flags
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
+    | Py_TPFLAGS_HAVE_GC,                       // tp_flags
     "metaclass for private attributes",         // tp_doc
-    (traverseproc)PrivateAttrType_tp_traverse,  // tp_travers
-    (inquiry)PrivateAttrType_tp_clear,          // tp_clear
+    PrivateAttrType_tp_traverse,                // tp_travers
+    PrivateAttrType_tp_clear,                   // tp_clear
     0,                                          // tp_richcompare
     0,                                          // tp_weaklistoffset
     0,                                          // tp_iter
@@ -1939,13 +2043,7 @@ type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept
             } else {
                 key = default_random_string(type_id, name);
             }
-            if (::AllData::all_type_mutex.find(type_id) == ::AllData::all_type_mutex.end()) {
-                std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-                ::AllData::all_type_mutex[type_id] = lock;
-            }
-            if (::AllData::type_attr_dict.find(type_id) == ::AllData::type_attr_dict.end()) {
-                ::AllData::type_attr_dict[type_id] = {};
-            }
+            type_create_mutex(type_id);
             std::shared_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[type_id]);
             auto& item_set = ::AllData::type_attr_dict[type_id];
             if (item_set.find(key) != item_set.end()) {
@@ -1980,13 +2078,7 @@ type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept
                                 } else {
                                     key = default_random_string(now_visited_id, name);
                                 }
-                                if (::AllData::all_type_subclass_mutex.find(parent_id) == ::AllData::all_type_subclass_mutex.end()) {
-                                    ::AllData::all_type_subclass_mutex[parent_id] = {};
-                                }
-                                if (::AllData::all_type_subclass_mutex[parent_id].find(now_visited_id) == ::AllData::all_type_subclass_mutex[parent_id].end()) {
-                                    std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-                                    ::AllData::all_type_subclass_mutex[parent_id][now_visited_id] = lock;
-                                }
+                                type_parenttype_create_mutex(parent_id, now_visited_id);
                                 std::shared_lock<std::shared_mutex> lock(*::AllData::all_type_subclass_mutex[parent_id][now_visited_id]);
                                 if (now_mro_dict[now_visited_id].find(key) != now_mro_dict[now_visited_id].end()) {
                                     PyObject* obj = now_mro_dict[now_visited_id][key];
@@ -2010,17 +2102,12 @@ type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept
                     } else {
                         key = default_random_string(parent_id, name);
                     }
-                    if (::AllData::all_type_mutex.find(parent_id) == ::AllData::all_type_mutex.end()) {
-                        std::shared_ptr<std::shared_mutex> lock(new std::shared_mutex());
-                        ::AllData::all_type_mutex[parent_id] = lock;
-                    }
-                    if (::AllData::type_attr_dict.find(parent_id) != ::AllData::type_attr_dict.end()) {
-                        auto& item_set = ::AllData::type_attr_dict[parent_id];
-                        std::shared_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[parent_id]);
-                        if (item_set.find(key) != item_set.end()) {
-                            PyObject* obj = item_set[key];
-                            return obj;
-                        }
+                    type_create_mutex(parent_id);
+                    auto& item_set = ::AllData::type_attr_dict[parent_id];
+                    std::shared_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[parent_id]);
+                    if (item_set.find(key) != item_set.end()) {
+                        PyObject* obj = item_set[key];
+                        return obj;
                     }
                 }
             }
@@ -2497,7 +2584,10 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
                 need_value = value;
             }
             if (data.private_attrs_vector_string.find(attr_name) != data.private_attrs_vector_string.end()) {
-                Py_INCREF(need_value);
+                // PyObjectStorage assignment INCREFs the value (RAII); the
+                // reference is released when need_remove_itself is cleared
+                // (PrivateAttrCreationData::clear). No manual INCREF here,
+                // otherwise the value leaks (+1) when the class is destroyed.
                 data.need_remove_itself[attr_name] = need_value;
                 PyDict_DelItem(data.attrs_copy, key);
                 continue;
@@ -2510,7 +2600,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
                 if (data.need_remove_subclass.find(need_remove_subclass_id) == data.need_remove_subclass.end()) {
                     data.need_remove_subclass[need_remove_subclass_id] = {};
                 }
-                Py_INCREF(need_value);
+                // PyObjectStorage assignment INCREFs (RAII); no manual INCREF.
                 data.need_remove_subclass[need_remove_subclass_id][attr_name] = need_value;
                 PyDict_DelItem(data.attrs_copy, key);
                 continue;
@@ -2567,18 +2657,16 @@ static getattrofunc get_need_tp_getattro(PyTypeObject* cls) noexcept;
 static setattrofunc get_need_tp_setattro(PyTypeObject* cls) noexcept;
 static traverseproc get_need_tp_traverse(PyTypeObject* cls) noexcept;
 static inquiry get_need_tp_clear(PyTypeObject* cls) noexcept;
-static destructor get_need_tp_finalize(PyTypeObject* cls) noexcept;
 
 // instance-level traverse/clear for types that use private attributes
 static int PrivateAttr_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept;
 static int PrivateAttr_tp_clear(PyObject* self) noexcept;
+// shared helper to clear object related data (avoid double clear)
+static void clear_object_related(uintptr_t id_self, uintptr_t typ_id) noexcept;
 // metaclass-level wrappers (if needed)
 static int PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept;
 static int PrivateAttrType_tp_clear(PyObject* self) noexcept;
 
-// shared helper to clear object related data (avoid double clear)
-static void clear_object_related(uintptr_t id_self, uintptr_t typ_id) noexcept;
-
 static void
 ensure_tp(PyTypeObject* type_instance) noexcept
 {
@@ -2657,20 +2745,12 @@ ensure_tp(PyTypeObject* type_instance) noexcept
     }
     {
         if (type_instance->tp_finalize != PrivateAttr_tp_finalize) {
-            if (!type_instance->tp_finalize && ::AllData::all_type_finalize.find(type_id) == ::AllData::all_type_finalize.end()) {
-                ::AllData::all_type_finalize[type_id] = get_need_tp_finalize(type_instance);
+            if (!type_instance->tp_finalize && ::AllData::all_type_del.find(type_id) == ::AllData::all_type_del.end()) {
+                ::AllData::all_type_del[type_id] = get_need_tp_finalize(type_instance);
             } else {
-                ::AllData::all_type_finalize[type_id] = type_instance->tp_finalize;
+                ::AllData::all_type_del[type_id] = type_instance->tp_finalize;
             }
             type_instance->tp_finalize = PrivateAttr_tp_finalize;
-        } else if (::AllData::all_type_finalize.find(type_id) == ::AllData::all_type_finalize.end()) {
-            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;
-            }
         }
     }
 }
@@ -3031,25 +3111,6 @@ get_need_tp_setattro(PyTypeObject* cls) noexcept
     return NULL;
 }
 
-static destructor
-get_need_tp_finalize(PyTypeObject* cls) noexcept
-{
-    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 traverseproc
 get_need_tp_traverse(PyTypeObject* cls) noexcept
 {
@@ -3092,10 +3153,6 @@ get_need_tp_clear(PyTypeObject* cls) noexcept
     return NULL;
 }
 
-// NOTE: register_finalize is defined later in this file; forward-declare it
-// here because get_type_need_tp_finalize() needs to compare against it.
-static void register_finalize(PyObject* cls) noexcept;
-
 // ========================================================================
 // get_type_need_tp_* : find the ORIGINAL slot implementation for METACLASS
 // slots.
@@ -3105,7 +3162,6 @@ static void register_finalize(PyObject* cls) noexcept;
 // wrappers:
 //   tp_getattro -> PrivateAttrType_getattr
 //   tp_setattro -> PrivateAttrType_setattr
-//   tp_finalize -> register_finalize
 //   tp_traverse -> PrivateAttrType_tp_traverse
 //   tp_clear    -> PrivateAttrType_tp_clear
 //
@@ -3155,65 +3211,81 @@ get_type_need_tp_setattro(PyTypeObject* cls) noexcept
     return NULL;
 }
 
-static destructor
-get_type_need_tp_finalize(PyTypeObject* cls) noexcept
-{
-    PyTypeObject* base = cls->tp_base;
-    while (base) {
-        if (base->tp_finalize != register_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 traverseproc
 get_type_need_tp_traverse(PyTypeObject* cls) noexcept
 {
+    // cls is a type object (an instance of a metaclass). CPython only invokes
+    // a real traverse on a tracked type object directly; otherwise it delegates
+    // through subtype_traverse. So walk the metaclass base chain and skip every
+    // delegating default (subtype_traverse, PrivateAttr_tp_traverse, our own
+    // wrapper) AND NULL slots, returning the nearest real implementation.
+    //
+    // For a plain metaclass chain the walk is
+    //   cls -> ... -> PrivateAttrBase -> object -> (tp_base == NULL)
+    // and object->tp_traverse is NULL, so the loop keeps walking to the end and
+    // falls through to the PyType_Type.tp_traverse fallback below: for a type
+    // object the ONLY correct real traverse is CPython's own type_traverse,
+    // which is what makes the class's hard self-cycle (tp_dict / tp_mro /
+    // tp_bases) visible to the cyclic GC. Without that fallback the class
+    // becomes uncollectable. For a REGISTERED metaclass chain the saved-map
+    // branch may find a real implementation before the fallback is reached.
     PyTypeObject* base = cls->tp_base;
     while (base) {
-        if (base->tp_traverse != PrivateAttrType_tp_traverse
-            && base->tp_traverse != ::AllData::captured_subtype_traverse) {
-            return base->tp_traverse;
-        } else if (::AllData::all_type_traverse.find((uintptr_t)base) != ::AllData::all_type_traverse.end()) {
-            traverseproc saved = ::AllData::all_type_traverse[(uintptr_t)base];
-            if (saved && saved != ::AllData::captured_subtype_traverse) {
+        traverseproc slot = base->tp_traverse;
+        if (slot
+            && slot != PrivateAttrType_tp_traverse
+            && slot != ::AllData::captured_subtype_traverse
+            && slot != PrivateAttr_tp_traverse) {
+            return slot;
+        }
+        auto it = ::AllData::all_type_traverse.find((uintptr_t)base);
+        if (it != ::AllData::all_type_traverse.end()) {
+            traverseproc saved = it->second;
+            if (saved
+                && saved != ::AllData::captured_subtype_traverse
+                && saved != PrivateAttr_tp_traverse
+                && saved != PrivateAttrType_tp_traverse) {
                 return saved;
             }
-            base = base->tp_base;
-        } else {
-            base = base->tp_base;
         }
+        base = base->tp_base;
     }
-    return NULL;
+    // Fallback to CPython's real type_traverse (PyType_Type.tp_traverse). A
+    // NULL slot is never a real implementation, so exhausting the chain here
+    // means no custom traverse exists and the only correct original for a type
+    // object is type_traverse itself.
+    return PyType_Type.tp_traverse;
 }
 
 static inquiry
 get_type_need_tp_clear(PyTypeObject* cls) noexcept
 {
+    // Same as get_type_need_tp_traverse: skip every delegating default
+    // (subtype_clear, PrivateAttr_tp_clear, our own wrapper) AND NULL slots,
+    // then fall back to CPython's real type_clear (PyType_Type.tp_clear) so a
+    // plain metaclass chain still breaks the class's hard self-cycle.
     PyTypeObject* base = cls->tp_base;
     while (base) {
-        if (base->tp_clear != PrivateAttrType_tp_clear
-            && base->tp_clear != ::AllData::captured_subtype_clear) {
-            return base->tp_clear;
-        } else if (::AllData::all_type_clear.find((uintptr_t)base) != ::AllData::all_type_clear.end()) {
-            inquiry saved = ::AllData::all_type_clear[(uintptr_t)base];
-            if (saved && saved != ::AllData::captured_subtype_clear) {
+        inquiry slot = base->tp_clear;
+        if (slot
+            && slot != PrivateAttrType_tp_clear
+            && slot != ::AllData::captured_subtype_clear
+            && slot != PrivateAttr_tp_clear) {
+            return slot;
+        }
+        auto it = ::AllData::all_type_clear.find((uintptr_t)base);
+        if (it != ::AllData::all_type_clear.end()) {
+            inquiry saved = it->second;
+            if (saved
+                && saved != ::AllData::captured_subtype_clear
+                && saved != PrivateAttr_tp_clear
+                && saved != PrivateAttrType_tp_clear) {
                 return saved;
             }
-            base = base->tp_base;
-        } else {
-            base = base->tp_base;
         }
+        base = base->tp_base;
     }
-    return NULL;
+    return PyType_Type.tp_clear;
 }
 
 static int
@@ -3308,10 +3380,17 @@ PrivateAttrType_finalize(PyObject* cls) noexcept
     if (::AllData::all_type_setattro.find(typ_id) != ::AllData::all_type_setattro.end()) {
         ::AllData::all_type_setattro.erase(typ_id);
     }
-    if (::AllData::all_type_finalize.find(typ_id) != ::AllData::all_type_finalize.end()) {
-        ::AllData::all_type_finalize.erase(typ_id);
-    }
     ::AllData::all_type_mutex.erase(typ_id);
+    // Clear the per-type buckets of the object-attr tables (created in
+    // PrivateAttrType_postprocess / PrivateAttr_object_init_private_dict);
+    // otherwise every class that ever got instances leaves an empty bucket
+    // behind and all_object_attr / all_object_mutex grow forever.
+    if (::AllData::all_object_attr.find(typ_id) != ::AllData::all_object_attr.end()) {
+        ::AllData::all_object_attr.erase(typ_id);
+    }
+    if (::AllData::all_object_mutex.find(typ_id) != ::AllData::all_object_mutex.end()) {
+        ::AllData::all_object_mutex.erase(typ_id);
+    }
     clear_obj(typ_id);
 }
 
@@ -3521,21 +3600,6 @@ postprocess_for_PrivateAttr(PyObject* /*self*/, PyObject* args) noexcept
     Py_RETURN_NONE;
 }
 
-static void
-register_finalize(PyObject* cls) noexcept
-{
-    Py_ssize_t original_ref = Py_REFCNT(cls);
-    PyTypeObject* base = Py_TYPE(cls)->tp_base;
-    while (base && base->tp_finalize == register_finalize) {
-        base = base->tp_base;
-    }
-    if (base && base->tp_finalize) base->tp_finalize(cls);
-    if (Py_REFCNT(cls) != original_ref) {
-        return;
-    }
-    PrivateAttrType_finalize(cls);
-}
-
 #define METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(name) do {\
     if (::AllData::all_type_##name.find(id) != ::AllData::all_type_##name.end()) {\
         ::AllData::all_type_##name.erase(id);\
@@ -3551,6 +3615,13 @@ metaclass_weakref_callback(PyObject* self, PyObject* /*weakref*/) noexcept
     }
     uintptr_t id = (uintptr_t)pointer;
 
+    // Clean up the class-level AllData owned by this registered metaclass
+    // (type_attr_dict / all_type_subclass_attr / object buckets / caches).
+    // This replaces the old tp_finalize hook (register_finalize) which has
+    // been removed: a weakref callback fires on every death path (refcount and
+    // cyclic GC) without making the metaclass "finalizable".
+    PrivateAttrType_finalize((PyObject*)id);
+
     std::unique_lock lock(::AllData::all_register_new_metaclass_mutex);
 
     auto it = ::AllData::all_register_type_weak_ref.find(id);
@@ -3562,7 +3633,7 @@ metaclass_weakref_callback(PyObject* self, PyObject* /*weakref*/) noexcept
     METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(setattro);
     METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(traverse);
     METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(clear);
-    METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(finalize);
+    METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(del);
 
     Py_RETURN_NONE;
 }
@@ -3654,48 +3725,37 @@ register_metaclass_head(PyObject* metaclass) noexcept
     }
     ::AllData::all_register_type_weak_ref[id] = 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
+    // subtype_traverse/subtype_clear, which a plain heap metaclass inherits)
+    // is never stored as the "original". The walkers skip those defaults and
+    // fall back to PyType_Type.tp_* (the real implementation for a type
+    // object). If an entry already exists for this id, keep it (idempotent).
     // save and replace tp_getattro
     if (mt->tp_getattro != PrivateAttrType_getattr) {
-        if (!mt->tp_getattro && ::AllData::all_type_getattro.find(id) == ::AllData::all_type_getattro.end()) {
+        if (::AllData::all_type_getattro.find(id) == ::AllData::all_type_getattro.end()) {
             ::AllData::all_type_getattro[id] = get_type_need_tp_getattro(mt);
-        } else {
-            ::AllData::all_type_getattro[id] = mt->tp_getattro;
         }
         mt->tp_getattro = PrivateAttrType_getattr;
     }
     // save and replace tp_setattro
     if (mt->tp_setattro != PrivateAttrType_setattr) {
-        if (!mt->tp_setattro && ::AllData::all_type_setattro.find(id) == ::AllData::all_type_setattro.end()) {
+        if (::AllData::all_type_setattro.find(id) == ::AllData::all_type_setattro.end()) {
             ::AllData::all_type_setattro[id] = get_type_need_tp_setattro(mt);
-        } else {
-            ::AllData::all_type_setattro[id] = mt->tp_setattro;
         }
         mt->tp_setattro = PrivateAttrType_setattr;
     }
-    // save and replace tp_finalize
-    if (mt->tp_finalize != register_finalize) {
-        if (!mt->tp_finalize && ::AllData::all_type_finalize.find(id) == ::AllData::all_type_finalize.end()) {
-            ::AllData::all_type_finalize[id] = get_type_need_tp_finalize(mt);
-        } else {
-            ::AllData::all_type_finalize[id] = mt->tp_finalize;
-        }
-        mt->tp_finalize = register_finalize;
-    }
     // save and replace tp_traverse
     if (mt->tp_traverse != PrivateAttrType_tp_traverse) {
-        if (!mt->tp_traverse && ::AllData::all_type_traverse.find(id) == ::AllData::all_type_traverse.end()) {
+        if (::AllData::all_type_traverse.find(id) == ::AllData::all_type_traverse.end()) {
             ::AllData::all_type_traverse[id] = get_type_need_tp_traverse(mt);
-        } else {
-            ::AllData::all_type_traverse[id] = mt->tp_traverse;
         }
         mt->tp_traverse = PrivateAttrType_tp_traverse;
     }
     // save and replace tp_clear
     if (mt->tp_clear != PrivateAttrType_tp_clear) {
-        if (!mt->tp_clear && ::AllData::all_type_clear.find(id) == ::AllData::all_type_clear.end()) {
+        if (::AllData::all_type_clear.find(id) == ::AllData::all_type_clear.end()) {
             ::AllData::all_type_clear[id] = get_type_need_tp_clear(mt);
-        } else {
-            ::AllData::all_type_clear[id] = mt->tp_clear;
         }
         mt->tp_clear = PrivateAttrType_tp_clear;
     }
@@ -3744,43 +3804,31 @@ ensure_metaclass_tp(PyObject* /*self*/, PyObject* metaclass) noexcept
     uintptr_t id = (uintptr_t)metaclass;
     if (::AllData::all_register_type_weak_ref.find(id) != ::AllData::all_register_type_weak_ref.end()) {
         PyTypeObject* mt = (PyTypeObject*)metaclass;
+        // Same as register_metaclass_head: always resolve the ORIGINAL slots
+        // through the get_type_need_tp_* walkers (never store a delegating
+        // default such as subtype_traverse/subtype_clear). Idempotent when an
+        // entry already exists.
         if (mt->tp_getattro != PrivateAttrType_getattr) {
-            if (!mt->tp_getattro && ::AllData::all_type_getattro.find(id) == ::AllData::all_type_getattro.end()) {
+            if (::AllData::all_type_getattro.find(id) == ::AllData::all_type_getattro.end()) {
                 ::AllData::all_type_getattro[id] = get_type_need_tp_getattro(mt);
-            } else {
-                ::AllData::all_type_getattro[id] = mt->tp_getattro;
             }
             mt->tp_getattro = PrivateAttrType_getattr;
         }
         if (mt->tp_setattro != PrivateAttrType_setattr) {
-            if (!mt->tp_setattro && ::AllData::all_type_setattro.find(id) == ::AllData::all_type_setattro.end()) {
+            if (::AllData::all_type_setattro.find(id) == ::AllData::all_type_setattro.end()) {
                 ::AllData::all_type_setattro[id] = get_type_need_tp_setattro(mt);
-            } else {
-                ::AllData::all_type_setattro[id] = mt->tp_setattro;
             }
             mt->tp_setattro = PrivateAttrType_setattr;
         }
-        if (mt->tp_finalize != register_finalize) {
-            if (!mt->tp_finalize && ::AllData::all_type_finalize.find(id) == ::AllData::all_type_finalize.end()) {
-                ::AllData::all_type_finalize[id] = get_type_need_tp_finalize(mt);
-            } else {
-                ::AllData::all_type_finalize[id] = mt->tp_finalize;
-            }
-            mt->tp_finalize = register_finalize;
-        }
         if (mt->tp_traverse != PrivateAttrType_tp_traverse) {
-            if (!mt->tp_traverse && ::AllData::all_type_traverse.find(id) == ::AllData::all_type_traverse.end()) {
+            if (::AllData::all_type_traverse.find(id) == ::AllData::all_type_traverse.end()) {
                 ::AllData::all_type_traverse[id] = get_type_need_tp_traverse(mt);
-            } else {
-                ::AllData::all_type_traverse[id] = mt->tp_traverse;
             }
             mt->tp_traverse = PrivateAttrType_tp_traverse;
         }
         if (mt->tp_clear != PrivateAttrType_tp_clear) {
-            if (!mt->tp_clear && ::AllData::all_type_clear.find(id) == ::AllData::all_type_clear.end()) {
+            if (::AllData::all_type_clear.find(id) == ::AllData::all_type_clear.end()) {
                 ::AllData::all_type_clear[id] = get_type_need_tp_clear(mt);
-            } else {
-                ::AllData::all_type_clear[id] = mt->tp_clear;
             }
             mt->tp_clear = PrivateAttrType_tp_clear;
         }
@@ -4133,6 +4181,12 @@ atexit_register_clean_func(void) noexcept
 PyMODINIT_FUNC
 PyInit_private_attribute(void) noexcept
 {
+    // check if AllData::store_module_self has first value
+    if (AllData::store_module_self.size() >= 1) {
+        PyObject* m = AllData::store_module_self[0];
+        Py_INCREF(m);
+        return m;
+    }
     if (init_all_slots() <0 ||
         atexit_register_clean_func() < 0 ||
         PyType_Ready(&PrivateWrapType) < 0 ||
@@ -4142,19 +4196,28 @@ PyInit_private_attribute(void) noexcept
         PyType_Ready(&PrivateTempType) < 0) {
         return NULL;
     }
+    // Eagerly create PrivateAttrBase so that CPython's subtype_traverse /
+    // subtype_clear pointers are captured at import time (see
+    // PrivateAttrCaptureGuard and ::AllData::captured_subtype_*), instead of
+    // waiting for the first lazy attribute access to the module.
+    PyObject* private_attr_base = PrivateModule_get_PrivateAttrBase(NULL, NULL);
+    if (!private_attr_base) {
+        return NULL;
+    }
     PyObject* all = PyList_New(0);
     if (!all) {
+        Py_DECREF(private_attr_base);
         return NULL;
     }
     PyObject* m = PyModule_Create(&def);
     if (!m) {
         Py_DECREF(all);
+        Py_DECREF(private_attr_base);
         return NULL;
     }
 #ifdef Py_GIL_DISABLED
     PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
 #endif
-
     PyModule_AddObject(m, "__all__", all);
     /* all contains:
      * PrivateWrapProxy
@@ -4176,16 +4239,8 @@ PyInit_private_attribute(void) noexcept
     PyList_AppendString(all, "ensure_metaclass");
     Py_SET_TYPE(m, &PrivateModuleType);
 
-    // Eagerly create PrivateAttrBase so that CPython's subtype_traverse /
-    // subtype_clear pointers are captured at import time (see
-    // PrivateAttrCaptureGuard and ::AllData::captured_subtype_*), instead of
-    // waiting for the first lazy attribute access to the module.
-    PyObject* private_attr_base = PrivateModule_get_PrivateAttrBase(NULL, NULL);
-    if (!private_attr_base) {
-        Py_DECREF(m);
-        return NULL;
-    }
     Py_DECREF(private_attr_base);
+    AllData::store_module_self.push_back(m);    // store module self
 
     return m;
 }

{private_attribute_cpp-2.1.4 → private_attribute_cpp-2.1.6/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.4
+Version: 2.1.6
 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.4 → private_attribute_cpp-2.1.6}/private_attribute_cpp.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ private_attribute_cpp.egg-info/not-zip-safe
 private_attribute_cpp.egg-info/top_level.txt
 tests/test_attr_classify_owner.py
 tests/test_class_private_attrs.py
+tests/test_gc_collect.py
 tests/test_private_abc.py
 tests/test_private_attrs.py
 tests/test_private_func.py

{private_attribute_cpp-2.1.4 → private_attribute_cpp-2.1.6}/setup.py

@@ -18,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='2.1.4',
+    version='2.1.6',
     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.6/tests/test_gc_collect.py

@@ -0,0 +1,145 @@
+"""GC regression tests for the metaclass type_traverse/type_clear fix.
+
+Validates that class objects created by the private-attribute machinery are
+actually reclaimed by the cyclic GC (previously they leaked because the
+metaclass traverse resolved to the instance-level delegating defaults instead
+of CPython's real type_traverse/type_clear).
+
+Run: PYTHONPATH=. python test_gc_collect.py
+"""
+import gc
+import sys
+import unittest
+import weakref
+
+import private_attribute
+from private_attribute import PrivateAttrBase
+
+
+def make_class(i, name="C"):
+    class C(PrivateAttrBase):
+        __private_attrs__ = ("_x",)
+        def __init__(self):
+            self._x = i
+        def get(self):
+            return self._x
+    C.__name__ = name
+    return C
+
+
+def alive_after_del_collect(maker, n):
+    """Create n classes, drop them, collect; return how many are still alive."""
+    refs = []
+    for i in range(n):
+        C = maker(i, f"Probe{i}")
+        refs.append(weakref.ref(C))
+        del C
+    for _ in range(3):
+        gc.collect()
+    return sum(1 for w in refs if w() is not None)
+
+
+class TestClassCollect(unittest.TestCase):
+    def test_empty_class_collected(self):
+        def maker(i, name):
+            class E(PrivateAttrBase):
+                pass
+            E.__name__ = name
+            return E
+        self.assertEqual(alive_after_del_collect(maker, 20), 0)
+
+    def test_class_with_private_attrs_collected(self):
+        self.assertEqual(alive_after_del_collect(make_class, 20), 0)
+
+    def test_class_with_private_value_freed(self):
+        class Holder:
+            pass
+        refs = []
+        for i in range(20):
+            h = Holder()
+            class H(PrivateAttrBase):
+                __private_attrs__ = ("_cv",)
+                _cv = h
+            refs.append(weakref.ref(h))
+            del h, H
+        for _ in range(3):
+            gc.collect()
+        self.assertEqual(sum(1 for w in refs if w() is not None), 0)
+
+    def test_mutual_class_cycle_collected(self):
+        def cyc():
+            class A(PrivateAttrBase):
+                __private_attrs__ = ("_ref",)
+                _ref = None
+                def set_ref(cls, v):
+                    cls._ref = v
+            class B(PrivateAttrBase):
+                __private_attrs__ = ("_ref",)
+                _ref = None
+                def set_ref(cls, v):
+                    cls._ref = v
+            A.set_ref(A, B)
+            B.set_ref(B, A)
+            wa = weakref.ref(A)
+            wb = weakref.ref(B)
+            del A, B
+            for _ in range(3):
+                gc.collect()
+            return wa() is not None, wb() is not None
+        a, b = cyc()
+        self.assertFalse(a)
+        self.assertFalse(b)
+
+    def test_self_referencing_class_collected(self):
+        def cyc():
+            class S(PrivateAttrBase):
+                __private_attrs__ = ("_self_ref",)
+                _self_ref = None
+                def set_self(cls, v):
+                    cls._self_ref = v
+            S.set_self(S, S)
+            w = weakref.ref(S)
+            del S
+            for _ in range(3):
+                gc.collect()
+            return w() is not None
+        self.assertFalse(cyc())
+
+    def test_nested_class_collected(self):
+        def nested():
+            class Outer(PrivateAttrBase):
+                __private_attrs__ = ("_inner",)
+                def make(self):
+                    class Inner(PrivateAttrBase):
+                        __private_attrs__ = ("_v",)
+                        def __init__(self):
+                            self._v = 1
+                    self._inner = Inner
+                    return Inner
+            o = Outer()
+            Inner = o.make()
+            wi = weakref.ref(Inner)
+            wo = weakref.ref(o)
+            del o, Inner
+            for _ in range(3):
+                gc.collect()
+            return wi() is not None, wo() is not None
+        inner, outer = nested()
+        self.assertFalse(inner)
+        self.assertFalse(outer)
+
+    def test_private_attr_semantics_still_work(self):
+        class C(PrivateAttrBase):
+            __private_attrs__ = ("_x",)
+            def __init__(self):
+                self._x = 7
+            def get(self):
+                return self._x
+        c = C()
+        self.assertEqual(c.get(), 7)
+        with self.assertRaises(AttributeError):
+            c._x
+
+
+if __name__ == "__main__":
+    unittest.main()