private-attribute-cpp 2.0.5__tar.gz → 2.1.0__tar.gz

{private_attribute_cpp-2.0.5/private_attribute_cpp.egg-info → private_attribute_cpp-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.0.5
+Version: 2.1.0
 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
@@ -250,6 +250,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - Don't use a decorator which will return the `_PrivateWrap` in `PrivateWrapProxy` which will raise `TypeError`.
 - One class defined in another class cannot use another class's private attribute.
 - One parent class defined an attribute which not in `__private_attrs__` or not a `PrivateAttrType` instance, the child class shouldn't contain the attribute in its `__private_attrs__`.
+- Since 2.1.0: the code of a subclass can no longer access the private attributes of its parent classes - a parent's private attribute is only reachable from the parent's own code, or from a class that declares the same name in its own `__private_attrs__`.
+- Since 2.1.0: if a subclass defines an attribute with the same name as a parent's private attribute, they are stored separately (instance attributes per declaring class, class-level attributes in `all_type_subclass_attr[parent][subclass]`). Class-level resolution is per-subject through the parent's code: reading the name on a subclass subject returns the subclass's own value, and the parent's own value is untouched. Such a same-name definition does NOT grant the subclass's own code access to the name.
 - CPython may change "tp_getattro", "tp_setattro" and so on when you change the attribute "\_\_getattribute\_\_", "\_\_setattr\_\_" and so on. If you are fear about it, you can use `ensure_type` to reset those tp slots. For the other metaclasses, you can use `ensure_metaclass` to reset those tp slots. Also, don't set those methods on these classes in your code.
 - `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
 - Don't set `__static_attributes__` in private attribute class, or it will be removed.

{private_attribute_cpp-2.0.5 → private_attribute_cpp-2.1.0}/README.md

@@ -231,6 +231,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - Don't use a decorator which will return the `_PrivateWrap` in `PrivateWrapProxy` which will raise `TypeError`.
 - One class defined in another class cannot use another class's private attribute.
 - One parent class defined an attribute which not in `__private_attrs__` or not a `PrivateAttrType` instance, the child class shouldn't contain the attribute in its `__private_attrs__`.
+- Since 2.1.0: the code of a subclass can no longer access the private attributes of its parent classes - a parent's private attribute is only reachable from the parent's own code, or from a class that declares the same name in its own `__private_attrs__`.
+- Since 2.1.0: if a subclass defines an attribute with the same name as a parent's private attribute, they are stored separately (instance attributes per declaring class, class-level attributes in `all_type_subclass_attr[parent][subclass]`). Class-level resolution is per-subject through the parent's code: reading the name on a subclass subject returns the subclass's own value, and the parent's own value is untouched. Such a same-name definition does NOT grant the subclass's own code access to the name.
 - CPython may change "tp_getattro", "tp_setattro" and so on when you change the attribute "\_\_getattribute\_\_", "\_\_setattr\_\_" and so on. If you are fear about it, you can use `ensure_type` to reset those tp slots. For the other metaclasses, you can use `ensure_metaclass` to reset those tp slots. Also, don't set those methods on these classes in your code.
 - `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
 - Don't set `__static_attributes__` in private attribute class, or it will be removed.

{private_attribute_cpp-2.0.5 → private_attribute_cpp-2.1.0}/private_attribute.cpp

@@ -178,7 +178,11 @@ namespace {
         };
         static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t, PyCodeObject*>> 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;
+        // private_func per type, stored with RAII ownership (PyObjectStorage
+        // INCREFs on assignment and DECREFs on destruction), so the map entry
+        // always owns exactly one reference - no dangling-pointer risk when the
+        // last external reference to the function disappears.
+        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,
@@ -225,6 +229,19 @@ static uintptr_t type_set_attr_long_long_guidance(uintptr_t type, const std::str
 static bool type_private_attr(uintptr_t type, const std::string& name) noexcept;
 static FinalObject type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept;
 
+// Result of classifying an attribute access.
+// - type_id: the node on the MRO chain (a class) whose code is currently running
+//   AND that declares the attribute as private. 0 means "no private owner".
+// - allowed: false means the access must be denied (a private attribute touched
+//   from outside its declaring class, or from a subclass of it).
+struct AttrClassifyResult
+{
+    uintptr_t type_id = 0;
+    bool allowed = true;
+};
+
+static AttrClassifyResult attr_classify(uintptr_t typ_id, const std::string& name, PyCodeObject* code) noexcept;
+
 static bool
 is_class_code(uintptr_t typ_id, PyCodeObject* code) noexcept
 {
@@ -251,27 +268,67 @@ is_type_private(uintptr_t typ_id, const std::string& name) noexcept
     return false;
 }
 
-static bool
+static AttrClassifyResult
 attr_classify(uintptr_t typ_id, const std::string& name, PyCodeObject* code) noexcept
 {
-    if (is_class_code(typ_id, code)) {
-        return true;
+    // Build the MRO chain: the actual class first, then its parents.
+    std::vector<uintptr_t> chain;
+    chain.push_back(typ_id);
+    if (::AllData::all_type_parent_id.find(typ_id) != ::AllData::all_type_parent_id.end()) {
+        auto& parent_ids = ::AllData::all_type_parent_id[typ_id];
+        chain.insert(chain.end(), parent_ids.begin(), parent_ids.end());
     }
-    if (is_type_private(typ_id, name)) {
-        return false;
+
+    // Find the class whose code is currently running (the code owner).
+    uintptr_t code_class = 0;
+    for (auto& node : chain) {
+        if (is_class_code(node, code)) {
+            code_class = node;
+            break;
+        }
     }
-    if (::AllData::all_type_parent_id.find(typ_id) != ::AllData::all_type_parent_id.end()) {
-        std::vector<uintptr_t> parent_ids = ::AllData::all_type_parent_id[typ_id];
-        for (auto& parent_id : parent_ids) {
-            if (is_class_code(parent_id, code)) {
-                return true;
+
+    if (code_class == 0) {
+        // No class code was hit on the whole chain (e.g. the code belongs to a
+        // module-level function or an unrelated class): if the name is private
+        // to any class on the chain, deny the access.
+        for (auto& node : chain) {
+            if (is_type_private(node, name)) {
+                return {0, false};
             }
-            if (is_type_private(parent_id, name)) {
-                return false;
+        }
+        return {0, true};
+    }
+
+    if (is_type_private(code_class, name)) {
+        // Both conditions hold: the code is under this class AND the attribute
+        // is private to this very class -> allowed, and this node of the chain
+        // is the owner of the private attribute.
+        return {code_class, true};
+    }
+
+    // The code belongs to code_class but the name is not private to it: look
+    // upward (toward the base classes). If an ancestor declares the name
+    // private, a subclass is trying to touch a parent's private attribute.
+    // Note: a class-body definition reusing a parent's private name (a
+    // "shadow", stored separately in all_type_subclass_attr[parent][child])
+    // does NOT grant this class's code any access to the name.
+    bool found_code_class = false;
+    for (auto& node : chain) {
+        if (!found_code_class) {
+            if (node == code_class) {
+                found_code_class = true;
             }
+            continue;
+        }
+        if (is_type_private(node, name)) {
+            return {0, false};
         }
     }
-    return true;
+
+    // Not private to the running class nor to any of its ancestors: treat it
+    // as a normal (non-private) attribute access.
+    return {0, true};
 }
 
 static std::string
@@ -437,13 +494,13 @@ static traverseproc get_need_tp_traverse(PyTypeObject* cls) noexcept;
 static inquiry get_need_tp_clear(PyTypeObject* cls) noexcept;
 
 static PyObject*
-id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
+id_getattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
 {
-    uintptr_t obj_id, typ_id, final_id;
-    obj_id = (uintptr_t) obj;
-    typ_id = (uintptr_t) typ;
-    final_id = type_set_attr_long_long_guidance(typ_id, attr_name);
-    FinalObject final_object = type_get_final_attr(typ_id, attr_name);
+    uintptr_t obj_id = (uintptr_t) obj;
+    // Class-level fallback resolves per-subject (the instance's type): a
+    // subclass's separately-stored shadow of a parent's private name is
+    // visible through the per-subject walk in type_get_final_attr.
+    FinalObject final_object = type_get_final_attr((uintptr_t)typ, attr_name);
     if (final_object.status == -2) {
         return NULL;
     }
@@ -488,14 +545,14 @@ id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
         result_typ = Py_TYPE(result);
         if (!result_typ) return NULL;
     }
-    bool has_get = false;
     bool has_set = false;
+    descrgetfunc get = NULL;
     if (result_typ) {
-        has_get = result_typ->tp_descr_get != NULL;
+        get = result_typ->tp_descr_get;
         has_set = result_typ->tp_descr_set != NULL;
     }
-    if (has_get && has_set) {
-        PyObject* final_result = result_typ->tp_descr_get(result, obj, typ);
+    if (get && has_set) {
+        PyObject* final_result = get(result, obj, typ);
         ensure_tp((PyTypeObject*)typ);
         ensure_subclass_tp((PyTypeObject*)typ);
         return final_result;
@@ -512,9 +569,10 @@ id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
             // if obj is a type, call result.__get__(None, obj)
             if (PyType_Check(obj)) {
                 PyTypeObject* obj_type = Py_TYPE(python_obj);
-                if (obj_type->tp_descr_get != NULL) {
+                auto funcptr = obj_type->tp_descr_get;
+                if (funcptr != NULL) {
                     lock.unlock();
-                    return obj_type->tp_descr_get(python_obj, Py_None, obj);
+                    return funcptr(python_obj, Py_None, obj);
                 }
             }
             Py_XINCREF(python_obj);
@@ -522,8 +580,8 @@ id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
         }
     }
 
-    if (has_get) {
-        PyObject* final_result = result_typ->tp_descr_get(result, obj, typ);
+    if (get) {
+        PyObject* final_result = get(result, obj, typ);
         ensure_tp((PyTypeObject*)typ);
         ensure_subclass_tp((PyTypeObject*)typ);
         return final_result;
@@ -554,8 +612,9 @@ type_getattr(PyObject* typ, const std::string& attr_name) noexcept
     }
     if (result) {
         PyTypeObject* type = Py_TYPE(result);
-        if (type->tp_descr_get != NULL) {
-            PyObject* final_result = type->tp_descr_get(result, Py_None, (PyObject*)type);
+        auto funcptr = type->tp_descr_get;
+        if (funcptr) {
+            PyObject* final_result = funcptr(result, Py_None, (PyObject*)type);
             ensure_tp((PyTypeObject*)type);
             ensure_subclass_tp((PyTypeObject*)type);
             return final_result;
@@ -573,13 +632,11 @@ type_getattr(PyObject* typ, const std::string& attr_name) noexcept
 }
 
 static int
-id_setattr(const std::string& attr_name, PyObject* obj, PyObject* typ, PyObject* value) noexcept
+id_setattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyObject* typ, PyObject* value) noexcept
 {
-    uintptr_t obj_id, typ_id, final_id;
-    obj_id = (uintptr_t) obj;
-    typ_id = (uintptr_t) typ;
-    final_id = type_set_attr_long_long_guidance(typ_id, attr_name);
-    FinalObject final_object = type_get_final_attr(typ_id, attr_name);
+    uintptr_t obj_id = (uintptr_t) obj;
+    // Class-level fallback resolves per-subject (the instance's type).
+    FinalObject final_object = type_get_final_attr((uintptr_t)typ, attr_name);
     if (final_object.status == -2) {
         return -1;
     }
@@ -621,8 +678,9 @@ id_setattr(const std::string& attr_name, PyObject* obj, PyObject* typ, PyObject*
     }
     if (result) {
         PyTypeObject* type = Py_TYPE(result);
-        if (type->tp_descr_set != NULL) {
-            if (type->tp_descr_set(result, obj, value) < 0) {
+        auto funcptr = type->tp_descr_set;
+        if (funcptr) {
+            if (funcptr(result, obj, value) < 0) {
                 return -1;
             }
             return 0;
@@ -681,6 +739,8 @@ type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexc
         }
         return 0;
     } 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] = {};
         }
@@ -703,13 +763,11 @@ type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexc
 }
 
 static int
-id_delattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
+id_delattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
 {
-    uintptr_t obj_id, typ_id, final_id;
-    obj_id = (uintptr_t) obj;
-    typ_id = (uintptr_t) typ;
-    final_id = type_set_attr_long_long_guidance(typ_id, attr_name);
-    FinalObject final_object = type_get_final_attr(typ_id, attr_name);
+    uintptr_t obj_id = (uintptr_t) obj;
+    // Class-level fallback resolves per-subject (the instance's type).
+    FinalObject final_object = type_get_final_attr((uintptr_t)typ, attr_name);
     if (final_object.status == -2) {
         return -1;
     }
@@ -751,8 +809,9 @@ id_delattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
     }
     if (result) {
         PyTypeObject* type = Py_TYPE(result);
-        if (type->tp_descr_set != NULL) {
-            if (type->tp_descr_set(result, result, NULL) < 0) {
+        auto funcptr = type->tp_descr_set;
+        if (funcptr) {
+            if (funcptr(result, result, NULL) < 0) {
                 return -1;
             }
             return 0;
@@ -920,12 +979,12 @@ static PyObject*
 PrivateWrap_qualname(PyObject* obj, void* /*closure*/) noexcept
 {
     if (!obj) {
-        return PyUnicode_InternFromString("_PrivateWrap");
+        return PyUnicode_InternFromString("private_attribute._PrivateWrap");
     }
     PyObject* qualname = PyObject_GetAttrString(((PrivateWrapObject*)obj)->result, "__qualname__");
     if (!qualname) {
         PyErr_Clear();
-        return PyUnicode_InternFromString("_PrivateWrap");
+        return PyUnicode_InternFromString("private_attribute._PrivateWrap");
     }
     return qualname;
 }
@@ -1012,8 +1071,9 @@ static PyObject*
 PrivateWrap_descrget(PyObject* obj, PyObject* name, PyObject* cls) noexcept
 {
     PyObject* result = ((PrivateWrapObject*)obj)->result;
-    if (Py_TYPE(result)->tp_descr_get) {
-        return Py_TYPE(result)->tp_descr_get(result, name, cls);
+    auto funcptr = Py_TYPE(result)->tp_descr_get;
+    if (funcptr) {
+        return funcptr(result, name, cls);
     } else {
         Py_INCREF(result);
         return result;
@@ -1024,8 +1084,9 @@ static int
 PrivateWrap_descrset(PyObject* obj, PyObject* name, PyObject* value) noexcept
 {
     PyObject* result = ((PrivateWrapObject*)obj)->result;
-    if (Py_TYPE(result)->tp_descr_set) {
-        return Py_TYPE(result)->tp_descr_set(result, name, value);
+    auto funcptr = Py_TYPE(result)->tp_descr_set;
+    if (funcptr) {
+        return funcptr(result, name, value);
     } else {
         PyErr_SetString(PyExc_AttributeError, "attribute is not settable");
         return -1;
@@ -1275,14 +1336,21 @@ PrivateAttr_tp_getattro(PyObject* self, PyObject* name) noexcept
     std::string name_str = PyUnicode_AsUTF8(name);
     auto code = get_now_code();
     if (type_private_attr(type_id, name_str)) {
-        if (!code || !attr_classify(type_id, name_str, code)){
+        if (!code) {
             Py_XDECREF(code);
             PyErr_SetString(PyExc_AttributeError, "private attribute");
             return NULL;
-        } else {
-            Py_XDECREF(code);
-            return id_getattr(name_str, self, (PyObject*)typ);
         }
+        AttrClassifyResult classify = attr_classify(type_id, name_str, code);
+        Py_XDECREF(code);
+        if (!classify.allowed) {
+            PyErr_SetString(PyExc_AttributeError, "private attribute");
+            return NULL;
+        }
+        if (classify.type_id != 0) {
+            return id_getattr(classify.type_id, name_str, self, (PyObject*)typ);
+        }
+        // owner is 0: not private for this access context -> normal attribute
     }
     Py_XDECREF(code);
     if (::AllData::all_type_getattro.find(type_id) != ::AllData::all_type_getattro.end()){
@@ -1307,17 +1375,24 @@ PrivateAttr_tp_setattro(PyObject* self, PyObject* name, PyObject* value) noexcep
     std::string name_str(c_name);
     auto code = get_now_code();
     if (type_private_attr(typ_id, name_str)) {
-        if (!code || !attr_classify(typ_id, name_str, code)){
+        if (!code) {
             PyErr_SetString(PyExc_AttributeError, "private attribute");
             Py_XDECREF(code);
             return -1;
-        } else {
-            Py_XDECREF(code);
+        }
+        AttrClassifyResult classify = attr_classify(typ_id, name_str, code);
+        Py_XDECREF(code);
+        if (!classify.allowed) {
+            PyErr_SetString(PyExc_AttributeError, "private attribute");
+            return -1;
+        }
+        if (classify.type_id != 0) {
             if (!value) {
-                return id_delattr(name_str, self, (PyObject*)typ);
+                return id_delattr(classify.type_id, name_str, self, (PyObject*)typ);
             }
-            return id_setattr(name_str, self, (PyObject*)typ, value);
+            return id_setattr(classify.type_id, name_str, self, (PyObject*)typ, value);
         }
+        // owner is 0: not private for this access context -> normal attribute
     }
     Py_XDECREF(code);
     if (::AllData::all_type_setattro.find(typ_id) != ::AllData::all_type_setattro.end()){
@@ -1790,6 +1865,10 @@ get_string_hash_tuple2(const std::string& name) noexcept
 static FinalObject
 type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept
 {
+    // type_id is the SUBJECT: the class whose attribute is being accessed.
+    // The walk resolves per-subject: a subclass's separately stored value
+    // (all_type_subclass_attr[parent][subclass]) shadows the parent's own
+    // class-level value, satisfying class-level separate storage.
     TwoStringTuple hash_tuple = get_string_hash_tuple2(name);
     if (::AllData::all_type_attr_set.find(type_id) != ::AllData::all_type_attr_set.end()) {
         if (::AllData::all_type_attr_set[type_id].find(hash_tuple) != ::AllData::all_type_attr_set[type_id].end()) {
@@ -2078,6 +2157,8 @@ struct PrivateAttrCreationData
     std::unordered_set<std::string> private_attrs_vector_string;
     std::vector<uintptr_t> all_need_analyse_base;
     std::unordered_map<std::string, PyObjectStorage> need_remove_itself;
+    // Class-body attributes whose name is private to a parent class: stored
+    // separately in all_type_subclass_attr[parent][this class].
     std::unordered_map<uintptr_t, std::unordered_map<std::string, PyObjectStorage>> need_remove_subclass;
     PyObject* private_func = nullptr;
     PyObject* base_kwds = nullptr;
@@ -2359,6 +2440,9 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
             }
             uintptr_t need_remove_subclass_id = need_remove_to_subclass(attr_name);
             if (need_remove_subclass_id) {
+                // The class body defines an attribute whose name is private to a
+                // parent class. It is stored separately (class-level separate
+                // storage) in all_type_subclass_attr[need_remove_subclass_id][this].
                 if (data.need_remove_subclass.find(need_remove_subclass_id) == data.need_remove_subclass.end()) {
                     data.need_remove_subclass[need_remove_subclass_id] = {};
                 }
@@ -2655,6 +2739,10 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
     }
 
     if (data.private_func) {
+        // PyObjectStorage::operator=(PyObject*) takes its own reference here;
+        // data's reference is released by PrivateAttrCreationData::clear()
+        // right after this, and the map entry's reference is released when the
+        // entry is erased in PrivateAttrType_finalize.
         ::AllData::type_need_call[type_id] = data.private_func;
     }
 
@@ -2744,13 +2832,21 @@ PrivateAttrType_getattr(PyObject* cls, PyObject* name) noexcept
     std::string name_str = PyUnicode_AsUTF8(name);
     PyCodeObject* now_code = get_now_code();
     if (type_private_attr(typ_id, name_str)) {
-        if (!now_code || !attr_classify(typ_id, name_str, now_code)) {
+        if (!now_code) {
             PyErr_SetString(PyExc_AttributeError, "private attribute");
             Py_XDECREF(now_code);
             return NULL;
         }
+        AttrClassifyResult classify = attr_classify(typ_id, name_str, now_code);
         Py_XDECREF(now_code);
-        return type_getattr(cls, name_str);
+        if (!classify.allowed) {
+            PyErr_SetString(PyExc_AttributeError, "private attribute");
+            return NULL;
+        }
+        if (classify.type_id != 0) {
+            return type_getattr(cls, name_str);
+        }
+        // owner is 0: not private for this access context -> normal attribute
     }
     Py_XDECREF(now_code);
     PyTypeObject* base = Py_TYPE(cls)->tp_base;
@@ -3091,13 +3187,21 @@ PrivateAttrType_setattr(PyObject* cls, PyObject* name, PyObject* value) noexcept
     }
     PyCodeObject* now_code = get_now_code();
     if (type_private_attr(typ_id, name_str)) {
-        if (!now_code || !attr_classify(typ_id, name_str, now_code)) {
+        if (!now_code) {
             PyErr_SetString(PyExc_AttributeError, "private attribute");
             Py_XDECREF(now_code);
             return -1;
         }
+        AttrClassifyResult classify = attr_classify(typ_id, name_str, now_code);
         Py_XDECREF(now_code);
-        return type_setattr(cls, name_str, value);
+        if (!classify.allowed) {
+            PyErr_SetString(PyExc_AttributeError, "private attribute");
+            return -1;
+        }
+        if (classify.type_id != 0) {
+            return type_setattr(cls, name_str, value);
+        }
+        // owner is 0: not private for this access context -> normal attribute
     }
     Py_XDECREF(now_code);
     PyTypeObject* base = Py_TYPE(cls)->tp_base;
@@ -3127,8 +3231,7 @@ PrivateAttrType_finalize(PyObject* cls) noexcept
         ::AllData::type_allowed_code_map.erase(typ_id);
     }
     if (::AllData::type_need_call.find(typ_id) != ::AllData::type_need_call.end()) {
-        auto& need_call = ::AllData::type_need_call[typ_id];
-        Py_XDECREF(need_call);
+        // erase() destroys the PyObjectStorage, which DECREFs private_func.
         ::AllData::type_need_call.erase(typ_id);
     }
     if (::AllData::type_attr_dict.find(typ_id) != ::AllData::type_attr_dict.end()) {
@@ -3391,6 +3494,11 @@ register_finalize(PyObject* cls) noexcept
     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);\
+    }\
+} while (0)
 
 static PyObject*
 metaclass_weakref_callback(PyObject* self, PyObject* /*weakref*/) noexcept
@@ -3408,6 +3516,11 @@ metaclass_weakref_callback(PyObject* self, PyObject* /*weakref*/) noexcept
         Py_DECREF(it->second);
         ::AllData::all_register_type_weak_ref.erase(it);
     }
+    METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(getattro);
+    METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(setattro);
+    METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(traverse);
+    METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(clear);
+    METACLASS_WEAKREF_CALLBACK_REMOVE_ITEM(finalize);
 
     Py_RETURN_NONE;
 }
@@ -3664,6 +3777,19 @@ PrivateModule_get_PrivateAttrBase(PyObject* /*self*/, void* /*closure*/) noexcep
     return PrivateAttrBase;
 }
 
+static int
+PyList_AppendString(PyObject* list, const char* str)
+{
+    PyObject* obj = PyUnicode_InternFromString(str);
+    if (!obj) return -1;
+    if (PyList_Append(list, obj) < 0) {
+        Py_DECREF(obj);
+        return -1;
+    }
+    Py_DECREF(obj);
+    return 0;
+}
+
 static PyObject*
 PrivateModule_dir(PyObject* self, PyObject* /*args*/) noexcept
 {
@@ -3674,14 +3800,14 @@ PrivateModule_dir(PyObject* self, PyObject* /*args*/) noexcept
         Py_DECREF(parent_dir);
         return NULL;
     }
-    PyList_Append(attr_list, PyUnicode_InternFromString("PrivateWrapProxy"));
-    PyList_Append(attr_list, PyUnicode_InternFromString("PrivateAttrType"));
-    PyList_Append(attr_list, PyUnicode_InternFromString("PrivateAttrBase"));
-    PyList_Append(attr_list, PyUnicode_InternFromString("prepare"));
-    PyList_Append(attr_list, PyUnicode_InternFromString("postprocess"));
-    PyList_Append(attr_list, PyUnicode_InternFromString("register_metaclass"));
-    PyList_Append(attr_list, PyUnicode_InternFromString("ensure_type"));
-    PyList_Append(attr_list, PyUnicode_InternFromString("ensure_metaclass"));
+    PyList_AppendString(attr_list, "PrivateWrapProxy");
+    PyList_AppendString(attr_list, "PrivateAttrType");
+    PyList_AppendString(attr_list, "PrivateAttrBase");
+    PyList_AppendString(attr_list, "prepare");
+    PyList_AppendString(attr_list, "postprocess");
+    PyList_AppendString(attr_list, "register_metaclass");
+    PyList_AppendString(attr_list, "ensure_type");
+    PyList_AppendString(attr_list, "ensure_metaclass");
     PyObject* result = PySequence_Concat(parent_dir, attr_list);
     Py_DECREF(parent_dir);
     Py_DECREF(attr_list);
@@ -3942,14 +4068,14 @@ PyInit_private_attribute(void) noexcept
      * ensure_type
      * ensure_metaclass
      */
-    PyList_Append(all, PyUnicode_InternFromString("PrivateWrapProxy"));
-    PyList_Append(all, PyUnicode_InternFromString("PrivateAttrType"));
-    PyList_Append(all, PyUnicode_InternFromString("PrivateAttrBase"));
-    PyList_Append(all, PyUnicode_InternFromString("prepare"));
-    PyList_Append(all, PyUnicode_InternFromString("postprocess"));
-    PyList_Append(all, PyUnicode_InternFromString("register_metaclass"));
-    PyList_Append(all, PyUnicode_InternFromString("ensure_type"));
-    PyList_Append(all, PyUnicode_InternFromString("ensure_metaclass"));
+    PyList_AppendString(all, "PrivateWrapProxy");
+    PyList_AppendString(all, "PrivateAttrType");
+    PyList_AppendString(all, "PrivateAttrBase");
+    PyList_AppendString(all, "prepare");
+    PyList_AppendString(all, "postprocess");
+    PyList_AppendString(all, "register_metaclass");
+    PyList_AppendString(all, "ensure_type");
+    PyList_AppendString(all, "ensure_metaclass");
     Py_SET_TYPE(m, &PrivateModuleType);
 
     // Eagerly create PrivateAttrBase so that CPython's subtype_traverse /

{private_attribute_cpp-2.0.5 → private_attribute_cpp-2.1.0/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.0.5
+Version: 2.1.0
 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
@@ -250,6 +250,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - Don't use a decorator which will return the `_PrivateWrap` in `PrivateWrapProxy` which will raise `TypeError`.
 - One class defined in another class cannot use another class's private attribute.
 - One parent class defined an attribute which not in `__private_attrs__` or not a `PrivateAttrType` instance, the child class shouldn't contain the attribute in its `__private_attrs__`.
+- Since 2.1.0: the code of a subclass can no longer access the private attributes of its parent classes - a parent's private attribute is only reachable from the parent's own code, or from a class that declares the same name in its own `__private_attrs__`.
+- Since 2.1.0: if a subclass defines an attribute with the same name as a parent's private attribute, they are stored separately (instance attributes per declaring class, class-level attributes in `all_type_subclass_attr[parent][subclass]`). Class-level resolution is per-subject through the parent's code: reading the name on a subclass subject returns the subclass's own value, and the parent's own value is untouched. Such a same-name definition does NOT grant the subclass's own code access to the name.
 - CPython may change "tp_getattro", "tp_setattro" and so on when you change the attribute "\_\_getattribute\_\_", "\_\_setattr\_\_" and so on. If you are fear about it, you can use `ensure_type` to reset those tp slots. For the other metaclasses, you can use `ensure_metaclass` to reset those tp slots. Also, don't set those methods on these classes in your code.
 - `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
 - Don't set `__static_attributes__` in private attribute class, or it will be removed.

{private_attribute_cpp-2.0.5 → private_attribute_cpp-2.1.0}/setup.py

@@ -18,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='2.0.5',
+    version='2.1.0',
     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.0.5 → private_attribute_cpp-2.1.0}/tests/test_private_abc.py

@@ -26,7 +26,9 @@ class MyClass(ABC, metaclass=PrivateAbcMeta):
         pass
 
 class ConcreteClass(MyClass):
-    __private_attrs__ = ["_secret2"]
+    # 2.1.0: a subclass can no longer access a parent's private attribute.
+    # If it needs the same name, it declares its own -> stored separately.
+    __private_attrs__ = ["_secret1", "_secret2"]
 
     def __init__(self, secret1, secret2):
         self._secret1 = secret1
@@ -49,6 +51,8 @@ class TestPrivateAbc(unittest.TestCase):
         with self.assertRaises(AttributeError):
             MyClass._secret1
         self.assertEqual(MyClass.get_secret1(), 10)
+        # get_secret1 is MyClass's own code, so it reads MyClass's private
+        # attribute even when called through the subclass.
         self.assertEqual(ConcreteClass.get_secret1(), 10)
 
 if __name__ == '__main__':

private_attribute_cpp-2.1.0/tests/test_private_func.py

@@ -0,0 +1,57 @@
+import private_attribute
+import unittest
+
+def my_func(obj_id, attr):
+    return f"Object ID: {obj_id}, String: {attr}"
+
+class MyClass(private_attribute.PrivateAttrBase, private_func=my_func):
+    __private_attrs__ = ["_secret"]
+    __slots__ = ["public_attr"]
+
+    def __init__(self, secret, public_attr):
+        self._secret = secret
+        self.public_attr = public_attr
+
+    def get_secret(self):
+        return self._secret
+
+class TestPrivateFunc(unittest.TestCase):
+    def test_private_func(self):
+        obj = MyClass("12345", "public_value")
+        self.assertEqual(obj.get_secret(), "12345")
+        self.assertEqual(obj.public_attr, "public_value")
+        with self.assertRaises(AttributeError):
+            obj._secret
+
+    def test_private_func_local_function_gc(self):
+        # Regression: a class created with a LOCAL private_func must not leave
+        # a dangling pointer in type_need_call after the function is collected.
+        # Previously this crashed with a segfault in PrivateAttrType_finalize
+        # during gc.collect().
+        import gc
+
+        def local_func(obj_id, attr):
+            return f"local_{obj_id}_{attr}"
+
+        class LocalParent(private_attribute.PrivateAttrBase, private_func=local_func):
+            __private_attrs__ = ["_v"]
+
+            def __init__(self):
+                self._v = 1
+
+            def get_v(self):
+                return self._v
+
+        class LocalChild(LocalParent):
+            __private_attrs__ = []
+
+        obj = LocalChild()
+        self.assertEqual(obj.get_v(), 1)
+        del obj
+        # drop the local classes and the local function, then collect
+        del LocalChild, LocalParent, local_func
+        for _ in range(3):
+            gc.collect()
+
+if __name__ == "__main__":
+    unittest.main()

private_attribute_cpp-2.1.0/tests/test_private_inheritance.py

@@ -0,0 +1,319 @@
+import private_attribute
+import unittest
+
+class BaseClass(private_attribute.PrivateAttrBase):
+    __private_attrs__ = ["_value"]
+    __slots__ = []
+
+    def __init__(self, value):
+        super().__init__()
+        self._value = value
+
+    @property
+    def value(self):
+        return self._value
+
+
+class SubClass(BaseClass):
+    __private_attrs__ = ["_other_value"]
+    __slots__ = []
+
+    def __init__(self, value, other_value):
+        super().__init__(value)
+        self._other_value = other_value
+
+    @property
+    def other_value(self):
+        return self._other_value
+
+
+class TestPrivateInheritance(unittest.TestCase):
+    def test_private_inheritance(self):
+        obj = SubClass(1, 2)
+        self.assertEqual(obj.value, 1)
+        self.assertEqual(obj.other_value, 2)
+        with self.assertRaises(AttributeError):
+            obj._value
+        with self.assertRaises(AttributeError):
+            obj._other_value
+
+    def test_subclass_cannot_access_parent_private(self):
+        # 2.1.0: code of a subclass must not touch a parent's private attribute.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_secret"]
+
+            def __init__(self):
+                self._secret = 1
+
+        class Child(Parent):
+            __private_attrs__ = []
+
+            def read_parent_secret(self):
+                return self._secret
+
+            def write_parent_secret(self):
+                self._secret = 2
+
+        obj = Child()
+        with self.assertRaises(AttributeError):
+            obj.read_parent_secret()
+        with self.assertRaises(AttributeError):
+            obj.write_parent_secret()
+
+    def test_same_name_instance_attrs_stored_separately(self):
+        # 2.1.0: subclass and parent may both declare the same private name;
+        # each class's code accesses its own storage.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self, value):
+                self._value = value
+
+            def get_parent_value(self):
+                return self._value
+
+        class Child(Parent):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self, value):
+                super().__init__(value)      # writes Parent's _value
+                self._value = value * 10     # writes Child's _value
+
+            def get_child_value(self):
+                return self._value
+
+        obj = Child(3)
+        self.assertEqual(obj.get_parent_value(), 3)
+        self.assertEqual(obj.get_child_value(), 30)
+        with self.assertRaises(AttributeError):
+            obj._value
+
+    def test_same_name_class_attrs_stored_separately(self):
+        # A class-body attribute reusing a parent's private name is stored
+        # separately (all_type_subclass_attr[parent][child]) and resolves
+        # per-subject through the PARENT's code. It does NOT grant the
+        # subclass's own code any access to the name.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+            _value = 10
+
+            def get_value(self):
+                return self._value
+
+        class Child(Parent):
+            __private_attrs__ = []
+            _value = 20
+
+            def get_child_value(self):
+                return self._value
+
+        self.assertEqual(Parent().get_value(), 10)
+        obj = Child()
+        # parent's code resolves per-subject: the child's own value
+        self.assertEqual(obj.get_value(), 20)
+        # the subclass's own code is NOT allowed to touch the name
+        with self.assertRaises(AttributeError):
+            obj.get_child_value()
+        with self.assertRaises(AttributeError):
+            obj._value
+        with self.assertRaises(AttributeError):
+            Child._value
+
+    def test_same_name_class_attrs_write_separately(self):
+        # Writes through the parent's code go to the subject's own storage;
+        # the subclass's own code cannot write the name at all.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+            _value = 1
+
+            @classmethod
+            def set_value(cls, v):
+                cls._value = v
+
+            @classmethod
+            def get_value(cls):
+                return cls._value
+
+        class Child(Parent):
+            __private_attrs__ = []
+            _value = 2
+
+            @classmethod
+            def set_own(cls, v):
+                cls._value = v
+
+        self.assertEqual(Parent.get_value(), 1)
+        self.assertEqual(Child.get_value(), 2)
+        # parent's classmethod called on the child writes the child's own storage
+        Child.set_value(99)
+        self.assertEqual(Child.get_value(), 99)
+        self.assertEqual(Parent.get_value(), 1)
+        # the subclass's own code cannot write the parent's private name
+        with self.assertRaises(AttributeError):
+            Child.set_own(7)
+        self.assertEqual(Child.get_value(), 99)
+        # parent's own storage still writable through the parent
+        Parent.set_value(5)
+        self.assertEqual(Parent.get_value(), 5)
+        self.assertEqual(Child.get_value(), 99)
+
+    def test_parent_code_still_works_on_subclass_instance(self):
+        # Parent's own methods keep working on subclass instances.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self, value):
+                self._value = value
+
+            def get_value(self):
+                return self._value
+
+        class Child(Parent):
+            __private_attrs__ = ["_other"]
+
+            def __init__(self, value, other):
+                super().__init__(value)
+                self._other = other
+
+            def get_other(self):
+                return self._other
+
+        obj = Child(5, 6)
+        self.assertEqual(obj.get_value(), 5)
+        self.assertEqual(obj.get_other(), 6)
+
+    def test_multi_level_inheritance(self):
+        # A private attribute is only reachable from the code of the class
+        # that declares it - not from any of its subclasses.
+        class GrandParent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_g"]
+
+            def __init__(self):
+                self._g = 1
+
+            def get_g(self):
+                return self._g
+
+        class Parent(GrandParent):
+            __private_attrs__ = ["_p"]
+
+            def __init__(self):
+                super().__init__()
+                self._p = 2
+
+            def get_p(self):
+                return self._p
+
+            def try_grandparent_private(self):
+                return self._g
+
+        class Child(Parent):
+            __private_attrs__ = []
+
+            def try_parent_private(self):
+                return self._p
+
+            def try_grandparent_private(self):
+                return self._g
+
+        obj = Child()
+        self.assertEqual(obj.get_g(), 1)
+        self.assertEqual(obj.get_p(), 2)
+        with self.assertRaises(AttributeError):
+            obj.try_parent_private()
+        with self.assertRaises(AttributeError):
+            obj.try_grandparent_private()
+        with self.assertRaises(AttributeError):
+            Parent().try_grandparent_private()
+
+    def test_multiple_inheritance(self):
+        class Left(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self):
+                self._value = "left"
+
+            def get_value(self):
+                return self._value
+
+        class Right(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self):
+                self._value = "right"
+
+            def get_value(self):
+                return self._value
+
+        class Both(Left, Right):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self):
+                Left.__init__(self)
+                Right.__init__(self)
+                self._value = "both"
+
+            def get_value(self):
+                return self._value
+
+        obj = Both()
+        self.assertEqual(Left.get_value(obj), "left")
+        self.assertEqual(Right.get_value(obj), "right")
+        self.assertEqual(obj.get_value(), "both")
+        with self.assertRaises(AttributeError):
+            obj._value
+
+    def test_private_func_with_inheritance(self):
+        def gen(obj_id, attr_name):
+            return f"<{attr_name}@{obj_id}>"
+
+        class Parent(private_attribute.PrivateAttrBase, private_func=gen):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self, value):
+                self._value = value
+
+            def get_value(self):
+                return self._value
+
+        class Child(Parent):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self, value):
+                super().__init__(value)
+                self._value = value * 2
+
+            def get_value(self):
+                return self._value
+
+        obj = Child(4)
+        self.assertEqual(Parent.get_value(obj), 4)
+        self.assertEqual(obj.get_value(), 8)
+
+    def test_class_level_del_from_own_code(self):
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+            _value = 1
+
+            @classmethod
+            def del_value(cls):
+                del cls._value
+
+            @classmethod
+            def set_value(cls, v):
+                cls._value = v
+
+            @classmethod
+            def get_value(cls):
+                return cls._value
+
+        self.assertEqual(Parent.get_value(), 1)
+        Parent.del_value()
+        with self.assertRaises(AttributeError):
+            Parent.get_value()
+        # setting again works after deletion
+        Parent.set_value(99)
+        self.assertEqual(Parent.get_value(), 99)
+
+if __name__ == "__main__":
+    unittest.main()

private_attribute_cpp-2.0.5/tests/test_private_func.py

@@ -1,27 +0,0 @@
-import private_attribute
-import unittest
-
-def my_func(obj_id, attr):
-    return f"Object ID: {obj_id}, String: {attr}"
-
-class MyClass(private_attribute.PrivateAttrBase, private_func=my_func):
-    __private_attrs__ = ["_secret"]
-    __slots__ = ["public_attr"]
-
-    def __init__(self, secret, public_attr):
-        self._secret = secret
-        self.public_attr = public_attr
-
-    def get_secret(self):
-        return self._secret
-
-class TestPrivateFunc(unittest.TestCase):
-    def test_private_func(self):
-        obj = MyClass("12345", "public_value")
-        self.assertEqual(obj.get_secret(), "12345")
-        self.assertEqual(obj.public_attr, "public_value")
-        with self.assertRaises(AttributeError):
-            obj._secret
-
-if __name__ == "__main__":
-    unittest.main()

private_attribute_cpp-2.0.5/tests/test_private_inheritance.py

@@ -1,40 +0,0 @@
-import private_attribute
-import unittest
-
-class BaseClass(private_attribute.PrivateAttrBase):
-    __private_attrs__ = ["_value"]
-    __slots__ = []
-
-    def __init__(self, value):
-        super().__init__()
-        self._value = value
-
-class SubClass(BaseClass):
-    __private_attrs__ = ["_other_value"]
-    __slots__ = []
-
-    def __init__(self, value, other_value):
-        super().__init__(value)
-        self._other_value = other_value
-
-    @property
-    def value(self):
-        return self._value
-
-    @property
-    def other_value(self):
-        return self._other_value
-
-
-class TestPrivateInheritance(unittest.TestCase):
-    def test_private_inheritance(self):
-        obj = SubClass(1, 2)
-        self.assertEqual(obj.value, 1)
-        self.assertEqual(obj.other_value, 2)
-        with self.assertRaises(AttributeError):
-            obj._value
-        with self.assertRaises(AttributeError):
-            obj._other_value
-
-if __name__ == "__main__":
-    unittest.main()