private-attribute-cpp 2.1.1__tar.gz → 2.1.3__tar.gz

{private_attribute_cpp-2.1.1/private_attribute_cpp.egg-info → private_attribute_cpp-2.1.3}/PKG-INFO

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

@@ -125,6 +125,10 @@ public:
     PyObjectStorage(PyObject* obj) noexcept : obj(obj) {
         Py_XINCREF(obj);
     }
+    // support for PyCodeObject*
+    PyObjectStorage(PyCodeObject* obj) noexcept : obj(reinterpret_cast<PyObject*>(obj)) {
+        Py_XINCREF(obj);
+    }
     PyObjectStorage(const PyObjectStorage& other) noexcept : obj(other.obj) {
         Py_XINCREF(obj);
     }
@@ -155,13 +159,26 @@ public:
         obj = new_obj;
         return *this;
     }
-    ~PyObjectStorage() noexcept {
+    PyObjectStorage& operator=(PyCodeObject* new_obj) noexcept {
+        Py_XINCREF(reinterpret_cast<PyObject*>(new_obj));
         Py_XDECREF(obj);
+        obj = reinterpret_cast<PyObject*>(new_obj);
+        return *this;
+    }
+    ~PyObjectStorage() noexcept {
+        // if python has exit we don't do anything
+        if (Py_IsInitialized()) {
+            Py_XDECREF(obj);
+        }
     }
 
     operator PyObject*() const noexcept {
         return obj;
     }
+
+    operator PyCodeObject*() const noexcept {
+        return reinterpret_cast<PyCodeObject*>(obj);
+    }
     PyObject* get() const noexcept {
         return obj;
     }
@@ -176,9 +193,9 @@ namespace {
         namespace {
             static std::unordered_map<uintptr_t, std::unordered_map<std::string, PyObjectStorage>> type_attr_dict;
         };
-        static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t, PyCodeObject*>> type_allowed_code_map;
+        static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t, PyObjectStorage>> type_allowed_code_map;
         static std::unordered_map<uintptr_t, std::shared_ptr<std::shared_mutex>> all_type_mutex;
-        static std::unordered_map<uintptr_t, PyObject*> type_need_call;
+        static std::unordered_map<uintptr_t, PyObjectStorage> type_need_call;
         static std::unordered_map<uintptr_t, std::unordered_set<TwoStringTuple>> all_type_attr_set;
         namespace {
             static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t,
@@ -206,9 +223,34 @@ namespace {
         static std::unordered_map<uintptr_t, destructor> all_type_finalize;
 
         static std::shared_mutex all_register_new_metaclass_mutex;
-        static std::unordered_map<uintptr_t, PyObject*> all_register_type_weak_ref;
+        static std::unordered_map<uintptr_t, PyObjectStorage> all_register_type_weak_ref;
     };
 };
+
+static void
+clean_all_storages() noexcept
+{
+    AllData::cache.clear();
+    AllData::all_exist_name.clear();
+    AllData::obj_attr_keys.clear();
+    AllData::type_attr_dict.clear();
+    AllData::type_allowed_code_map.clear();
+    AllData::all_type_mutex.clear();
+    AllData::type_need_call.clear();
+    AllData::all_type_attr_set.clear();
+    AllData::all_object_attr.clear();
+    AllData::all_type_subclass_attr.clear();
+    AllData::all_object_mutex.clear();
+    AllData::all_type_subclass_mutex.clear();
+    AllData::all_type_parent_id.clear();
+    AllData::all_type_getattro.clear();
+    AllData::all_type_setattro.clear();
+    AllData::all_type_traverse.clear();
+    AllData::all_type_clear.clear();
+    AllData::all_type_finalize.clear();
+    AllData::all_register_type_weak_ref.clear();
+}
+
 struct FinalObject
 {
     PyObjectStorage result;
@@ -275,11 +317,11 @@ attr_classify(uintptr_t typ_id, const std::string& name, PyCodeObject* code) noe
         chain.insert(chain.end(), parent_ids.begin(), parent_ids.end());
     }
 
-    // Find the class whose code is currently running (the code owner).
+    // Find the class whose code is currently running (the code owner, parent first).
     uintptr_t code_class = 0;
-    for (auto& node : chain) {
-        if (is_class_code(node, code)) {
-            code_class = node;
+    for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
+        if (is_class_code(*it, code)) {
+            code_class = *it;  // first hit from the base-most end
             break;
         }
     }
@@ -2059,7 +2101,7 @@ try_get_attr_string(PyObject* obj, const char* name) noexcept
 }
 
 static void
-analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyCodeObject*>& map, std::unordered_set<uintptr_t>& _seen) noexcept
+analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyObjectStorage>& map, std::unordered_set<uintptr_t>& _seen) noexcept
 {
     uintptr_t obj_id = (uintptr_t)obj;
     if (_seen.find(obj_id) != _seen.end()) {
@@ -2067,8 +2109,7 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyCodeObject*>& ma
     }
     _seen.insert(obj_id);
     if (PyObject_TypeCheck(obj, &PyCode_Type)) {
-        Py_INCREF(obj);
-        map[(uintptr_t)obj] = (PyCodeObject*)obj;
+        map[(uintptr_t)obj] = obj;
         PyObject* co_contain = try_get_attr_string(obj, "co_consts");
         if (co_contain && PySequence_Check(co_contain)) {
             Py_ssize_t len = PySequence_Length(co_contain);
@@ -2229,11 +2270,11 @@ need_analyse_type(PyObject* type) noexcept
     }
     std::shared_lock lock(::AllData::all_register_new_metaclass_mutex);
     for (auto& [id, metaclassref]: ::AllData::all_register_type_weak_ref){
-        if (!PyWeakref_CheckRef(metaclassref)) {
+        if (!PyWeakref_CheckRef((PyObject*)metaclassref)) {
             continue;
         }
 #if PY_VERSION_HEX < 0x030D0000
-        PyObject* metaclass = PyWeakref_GET_OBJECT(metaclassref);
+        PyObject* metaclass = PyWeakref_GET_OBJECT((PyObject*)metaclassref);
         if (type == metaclass) continue;
         if (PyObject_IsInstance(type, metaclass)) {
             return true;
@@ -3218,13 +3259,9 @@ PrivateAttrType_finalize(PyObject* cls) noexcept
         ::AllData::all_type_attr_set.erase(typ_id);
     }
     if (::AllData::type_allowed_code_map.find(typ_id) != ::AllData::type_allowed_code_map.end()) {
-        for (auto& [id, obj] : ::AllData::type_allowed_code_map[typ_id]) {
-            Py_XDECREF(obj);
-        }
         ::AllData::type_allowed_code_map.erase(typ_id);
     }
     if (::AllData::type_need_call.find(typ_id) != ::AllData::type_need_call.end()) {
-        Py_DECREF(::AllData::type_need_call[typ_id]);
         ::AllData::type_need_call.erase(typ_id);
     }
     if (::AllData::type_attr_dict.find(typ_id) != ::AllData::type_attr_dict.end()) {
@@ -3534,7 +3571,7 @@ is_class_of_registed_type(PyObject* metaclass) noexcept
             continue;
         }
 #if PY_VERSION_HEX < 0x030D0000
-        PyObject* instance = PyWeakref_GET_OBJECT(instanceref);
+        PyObject* instance = PyWeakref_GET_OBJECT((PyObject*)instanceref);
         if (instance == metaclass) continue;
         if (PyObject_IsInstance(instance, metaclass)) {
             return true;
@@ -4026,10 +4063,66 @@ static PyModuleDef def = {
     NULL
 };
 
+static PyObject*
+AtExit_clean_storage(PyObject* /*self*/, PyObject* /*obj*/) noexcept
+{
+    clean_all_storages();
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef clean_storage = {
+    "clean_storage",
+    (PyCFunction)AtExit_clean_storage,
+    METH_NOARGS,
+    "Clean all storages"
+};
+
+static int
+atexit_register_clean_func(void) noexcept
+{
+    PyObject* atexit = PyImport_ImportModule("atexit");
+    if (!atexit) {
+        return -1;
+    }
+    PyObject* register_func = PyObject_GetAttrString(atexit, "register");
+    if (!register_func) {
+        Py_DECREF(atexit);
+        return -1;
+    }
+
+    PyObject* func = PyCFunction_New(&clean_storage, NULL);
+    if (!func) {
+        Py_DECREF(register_func);
+        Py_DECREF(atexit);
+        return -1;
+    }
+    PyObject* args = PyTuple_New(1);
+    if (!args) {
+        Py_DECREF(func);
+        Py_DECREF(register_func);
+        Py_DECREF(atexit);
+        return -1;
+    }
+    PyTuple_SET_ITEM(args, 0, func);
+    PyObject* result = PyObject_CallObject(register_func, args);
+    if (result == NULL) {
+        Py_DECREF(args);
+        Py_DECREF(register_func);
+        Py_DECREF(atexit);
+        return -1;
+    }
+    Py_DECREF(args);
+    Py_DECREF(register_func);
+    Py_DECREF(atexit);
+    Py_DECREF(result);
+    return 0;
+}
+
 PyMODINIT_FUNC
 PyInit_private_attribute(void) noexcept
 {
     if (init_all_slots() <0 ||
+        atexit_register_clean_func() < 0 ||
         PyType_Ready(&PrivateWrapType) < 0 ||
         PyType_Ready(&PrivateWrapProxyType) < 0 ||
         PyType_Ready(&PrivateAttrType) < 0 ||

{private_attribute_cpp-2.1.1 → private_attribute_cpp-2.1.3/private_attribute_cpp.egg-info}/PKG-INFO

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

@@ -10,6 +10,7 @@ private_attribute_cpp.egg-info/SOURCES.txt
 private_attribute_cpp.egg-info/dependency_links.txt
 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_private_abc.py
 tests/test_private_attrs.py

{private_attribute_cpp-2.1.1 → private_attribute_cpp-2.1.3}/setup.py

@@ -18,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='2.1.1',
+    version='2.1.3',
     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.3/tests/test_attr_classify_owner.py

@@ -0,0 +1,137 @@
+"""attr_classify ownership rule (v2.1.3).
+
+When a code object is owned by several classes on the MRO chain (e.g. a
+subclass aliases a parent method with `f = g`, or copies a parent method's
+bytecode with `f.__code__ = g.__code__`), attr_classify must attribute the
+code to the base-most (declaring, parent) class. Otherwise the parent code's
+private attribute accesses get split across two storages: the tampered method
+writes the subclass's storage while the untampered parent method reads the
+parent's storage, corrupting the parent's behavior.
+
+Key invariant: parent methods inc() (tampered by the child) and peek() (not
+tampered) must ALWAYS see the same storage on a child instance.
+"""
+import unittest
+
+import private_attribute
+
+
+class Parent(private_attribute.PrivateAttrBase):
+    __private_attrs__ = ["_n"]
+    _n = 0
+
+    def inc(self):
+        self._n += 1
+        return self._n
+
+    def peek(self):
+        return self._n
+
+
+class TestAliasCodeOwnership(unittest.TestCase):
+    """`f = g` in the class body registers the same function object with both
+    classes; the aliased and the untampered parent methods must stay
+    consistent on a child instance."""
+
+    def test_alias_method_sees_same_storage_as_untampered(self):
+        class AliasChild(Parent):
+            __private_attrs__ = ["_n"]
+            _n = 100
+            f = Parent.inc          # same function object in both class dicts
+
+        c = AliasChild()
+        v1 = c.f()                  # parent code, double-owned
+        v2 = c.peek()               # parent code, single-owned
+        self.assertEqual(v1, v2)
+        c.f()
+        self.assertEqual(c.peek(), v2 + 1)
+        self.assertEqual(Parent().peek(), 0)
+
+    def test_alias_without_shadow_works(self):
+        class AliasChild2(Parent):
+            __private_attrs__ = []
+            f = Parent.inc
+
+        c = AliasChild2()
+        v1 = c.f()
+        self.assertEqual(v1, c.peek())
+
+
+class TestCodeSwapOwnership(unittest.TestCase):
+    """`f.__code__ = g.__code__` inside the class body; the swapped method
+    must behave exactly like the parent's method (same storage)."""
+
+    def test_code_swap_sees_same_storage_as_untampered(self):
+        class CodeChild(Parent):
+            __private_attrs__ = ["_n"]
+            _n = 100
+
+            def f(self):
+                return None
+
+            f.__code__ = Parent.inc.__code__
+
+        c = CodeChild()
+        v1 = c.f()
+        v2 = c.peek()
+        self.assertEqual(v1, v2)
+        c.f()
+        self.assertEqual(c.peek(), v2 + 1)
+
+
+class TestFallbackSemantics(unittest.TestCase):
+    """Per-subject fallback is preserved: an unwritten read resolves to the
+    subject's own class-level default, consistently for both methods."""
+
+    def test_unwritten_read_falls_back_per_subject(self):
+        class FreshChild(Parent):
+            __private_attrs__ = ["_n"]
+            _n = 100
+            f = Parent.inc
+
+        c = FreshChild()
+        self.assertEqual(c.peek(), 100)
+        v1 = c.f()
+        self.assertEqual(v1, c.peek())
+
+
+class TestNormalUsageRegression(unittest.TestCase):
+    """Without tampering, nothing changes: child's own code uses child
+    storage, parent's code keeps its per-subject view."""
+
+    def test_child_own_code_uses_child_storage(self):
+        class NormChild(Parent):
+            __private_attrs__ = ["_n"]
+            _n = 100
+
+            def own_inc(self):
+                self._n += 1
+                return self._n
+
+        c = NormChild()
+        self.assertEqual(c.own_inc(), 101)
+        self.assertEqual(c.peek(), 100)
+        self.assertEqual(Parent().peek(), 0)
+
+
+class TestIsolationIntact(unittest.TestCase):
+    """The v2.1.0 isolation rule still holds: the subclass's own code must
+    not touch a parent's private attribute."""
+
+    def test_subclass_own_code_denied(self):
+        class IsoParent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_secret"]
+            _secret = 1
+
+        class IsoChild(IsoParent):
+            __private_attrs__ = []
+
+            def read_secret(self):
+                return self._secret
+
+        with self.assertRaises(AttributeError):
+            IsoChild().read_secret()
+
+
+if __name__ == "__main__":
+    unittest.main()