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

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

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

@@ -1512,6 +1512,92 @@ public:
     }
 };
 
+// ========================================================================
+// __slots__ traversal/clear (mirror of CPython's subtype_traverse slot loop).
+//
+// A private-attribute class's LIVE tp_traverse/tp_clear are replaced with
+// PrivateAttr_tp_traverse / PrivateAttr_tp_clear. The saved "original" is
+// CPython's subtype_traverse/subtype_clear, but because subtype_traverse
+// resolves the nearest base through the LIVE slot, it treats our wrapper as
+// the nearest "different" traverse and skips its own traverse_slots loop. The
+// __slots__ members (Py_T_OBJECT_EX entries in the heap type's member table)
+// therefore become invisible to the collector, so a cycle formed purely
+// through __slots__ members leaks.
+//
+// These helpers walk the member table for each type level whose live
+// traverse/clear slot is still a delegating default (subtype_traverse /
+// subtype_clear or our own wrapper), exactly mirroring the
+// `while (base->tp_traverse == subtype_traverse)` walk in CPython.
+// ========================================================================
+
+// Locate the member table of a heap type in a version-independent way.
+// - 3.12+ : PyObject_GetItemData((PyObject*)type) is the public accessor
+//           (_PyHeapType_GET_MEMBERS is defined as that since 3.12).
+// - <=3.11 : members float right after the PyHeapTypeObject header:
+//           _PyHeapType_GET_MEMBERS(et) == (char*)et + Py_TYPE(et)->tp_basicsize.
+static PyMemberDef*
+PrivateAttr_get_tp_members(PyTypeObject* type) noexcept
+{
+    if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
+        return NULL;
+    }
+#if PY_VERSION_HEX >= 0x030C0000
+    return (PyMemberDef*)PyObject_GetItemData((PyObject*)type);
+#else
+    return (PyMemberDef*)((char*)type + Py_TYPE(type)->tp_basicsize);
+#endif
+}
+
+static int
+PrivateAttr_traverse_slots(PyTypeObject* type, PyObject* self,
+                           visitproc visit, void* arg) noexcept
+{
+    if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
+        return 0;
+    }
+    PyMemberDef* mp = PrivateAttr_get_tp_members(type);
+    if (mp == NULL) {
+        return 0;
+    }
+    Py_ssize_t n = Py_SIZE(type);
+    for (Py_ssize_t i = 0; i < n; i++, mp++) {
+        if (mp->type == T_OBJECT_EX) {
+            char* addr = (char*)self + mp->offset;
+            PyObject* obj = *(PyObject**)addr;
+            if (obj != NULL) {
+                int err = visit(obj, arg);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+static void
+PrivateAttr_clear_slots(PyTypeObject* type, PyObject* self) noexcept
+{
+    if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
+        return;
+    }
+    PyMemberDef* mp = PrivateAttr_get_tp_members(type);
+    if (mp == NULL) {
+        return;
+    }
+    Py_ssize_t n = Py_SIZE(type);
+    for (Py_ssize_t i = 0; i < n; i++, mp++) {
+        if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) {
+            char* addr = (char*)self + mp->offset;
+            PyObject* obj = *(PyObject**)addr;
+            if (obj != NULL) {
+                *(PyObject**)addr = NULL;
+                Py_DECREF(obj);
+            }
+        }
+    }
+}
+
 static int
 PrivateAttr_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
 {
@@ -1540,6 +1626,29 @@ PrivateAttr_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
         }
     }
 
+    // __slots__ visit (mirror of subtype_traverse's slot-walking loop). See
+    // PrivateAttr_traverse_slots above: once the LIVE tp_traverse is this
+    // wrapper, subtype_traverse skips its own loop, so walk the member table
+    // of this type and every delegating base explicitly. Stop at the first
+    // base whose live traverse is a real implementation (it owns its slots).
+    {
+        PyTypeObject* base = typ;
+        while (base) {
+            if (base->tp_traverse == ::AllData::captured_subtype_traverse
+                || base->tp_traverse == PrivateAttr_tp_traverse) {
+                if (Py_SIZE(base)) {
+                    int err = PrivateAttr_traverse_slots(base, self, visit, arg);
+                    if (err) {
+                        return err;
+                    }
+                }
+                base = base->tp_base;
+            } else {
+                break;
+            }
+        }
+    }
+
     // 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
@@ -1645,6 +1754,25 @@ PrivateAttr_tp_clear(PyObject* self) noexcept
         if (orig) orig(self);
     }
 
+    // __slots__ clear (mirror of subtype_clear's clear_slots loop). Same
+    // reasoning as the traverse side: subtype_clear can't run its own loop
+    // once the LIVE tp_clear is this wrapper, so clear the __slots__ members
+    // of this type and every delegating base explicitly.
+    {
+        PyTypeObject* base = typ;
+        while (base) {
+            if (base->tp_clear == ::AllData::captured_subtype_clear
+                || base->tp_clear == PrivateAttr_tp_clear) {
+                if (Py_SIZE(base)) {
+                    PrivateAttr_clear_slots(base, self);
+                }
+                base = base->tp_base;
+            } else {
+                break;
+            }
+        }
+    }
+
     // 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
@@ -1756,8 +1884,8 @@ static inquiry get_type_need_tp_clear(PyTypeObject* cls) noexcept;
 static int
 PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
 {
-    PyTypeObject* typ = (PyTypeObject*)self;
-    uintptr_t typ_id = (uintptr_t)typ;
+    PyTypeObject* typ = Py_TYPE(self);
+    uintptr_t typ_id = (uintptr_t)self;
 
     // Re-entrancy guard: see PrivateAttrRecursionGuard above.
     if (!PrivateAttrRecursionGuard::try_enter((uintptr_t)self)) {
@@ -1793,9 +1921,8 @@ PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
     // 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);
+        if (typ->tp_flags & Py_TPFLAGS_HEAPTYPE) {
+            Py_VISIT((PyObject*)typ);
         }
     }
 
@@ -1865,8 +1992,8 @@ PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
 static int
 PrivateAttrType_tp_clear(PyObject* self) noexcept
 {
-    PyTypeObject* typ = (PyTypeObject*)self;
-    uintptr_t typ_id = (uintptr_t)typ;
+    PyTypeObject* typ = Py_TYPE(self);
+    uintptr_t typ_id = (uintptr_t)self;
 
     // Re-entrancy guard: see PrivateAttrRecursionGuard above.
     if (!PrivateAttrRecursionGuard::try_enter((uintptr_t)self)) {
@@ -3868,7 +3995,7 @@ PrivateModule_get_PrivateAttrBase(PyObject* /*self*/, void* /*closure*/) noexcep
 }
 
 static int
-PyList_AppendString(PyObject* list, const char* str)
+PyList_AppendString(PyObject* list, const char* str) noexcept
 {
     PyObject* obj = PyUnicode_InternFromString(str);
     if (!obj) return -1;

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

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

@@ -18,4 +18,5 @@ tests/test_private_attrs.py
 tests/test_private_func.py
 tests/test_private_inheritance.py
 tests/test_private_method.py
-tests/test_private_wrap.py
+tests/test_private_wrap.py
+tests/test_slots_cycle.py

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

@@ -1,10 +1,15 @@
 from setuptools import setup, Extension
+import os
 import sys
 
 if sys.platform == "win32":
-    extra_compile_args = ['/std:c++17']
+    extra_compile_args = ['/std:c++17', '/GR-']
+    extra_link_args = []
 else:
-    extra_compile_args = ['-std=c++17']
+    extra_compile_args = ['-std=c++17', '-fno-exceptions', '-fno-rtti']
+    extra_link_args = []
+    if os.environ.get('PRIVATE_ATTR_KEEP_DEBUG') != '1':
+        extra_compile_args.append('-g0')
 
 module = Extension(
     'private_attribute',
@@ -12,13 +17,14 @@ module = Extension(
     include_dirs=['.'],
     language='c++',
     extra_compile_args=extra_compile_args,
+    extra_link_args=extra_link_args,
 )
 
 readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='2.1.6',
+    version='2.1.8',
     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.8/tests/test_slots_cycle.py

@@ -0,0 +1,59 @@
+"""Regression test for __slots__ traversal in private-attribute types.
+
+A private-attribute class whose __slots__ member participates in a reference
+cycle must still be collected by the cyclic GC. The instance-level traverse
+wrapper previously skipped the __slots__ storage entirely (it only visited the
+instance __dict__ and AllData-stored private attributes), so a cycle formed
+purely through __slots__ members leaked.
+"""
+import gc
+import unittest
+import weakref
+
+import private_attribute
+from private_attribute import PrivateAttrBase
+
+
+def _collect():
+    for _ in range(3):
+        gc.collect()
+
+
+class TestSlotsCycleCollect(unittest.TestCase):
+    def test_slots_pair_cycle_collected(self):
+        class A(PrivateAttrBase):
+            __private_attrs__ = ("_x",)
+            __slots__ = ("peer", "__weakref__")
+
+            def __init__(self):
+                self._x = 1
+                self.peer = None
+
+        a = A()
+        b = A()
+        a.peer = b
+        b.peer = a
+        wa, wb = weakref.ref(a), weakref.ref(b)
+        del a, b
+        _collect()
+        self.assertIsNone(wa())
+        self.assertIsNone(wb())
+
+    def test_slots_self_cycle_collected(self):
+        class A(PrivateAttrBase):
+            __private_attrs__ = ("_x",)
+            __slots__ = ("self_ref", "__weakref__")
+
+            def __init__(self):
+                self._x = 1
+                self.self_ref = self
+
+        a = A()
+        w = weakref.ref(a)
+        del a
+        _collect()
+        self.assertIsNone(w())
+
+
+if __name__ == "__main__":
+    unittest.main()