private-attribute-cpp 2.1.24__tar.gz → 2.2.0__tar.gz

{private_attribute_cpp-2.1.24/private_attribute_cpp.egg-info → private_attribute_cpp-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.24
+Version: 2.2.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
@@ -253,7 +253,9 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - 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.
+- Since 2.1.0: if a subclass declares a name in its own `__private_attrs__` that is also private to a parent, the two are stored separately (instance attributes per declaring class, class-level attributes per class). 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.
+- Since 2.2.0: a subclass must NOT define an attribute in its namespace (class body) whose name is private to a parent class, unless that name is declared in its own `__private_attrs__` or the class opts in with `use_parents=True`.
+- Since 2.2.0: pass `use_parents=True` in the class definition to inherit all parent classes' private attribute names into the subclass's own private-attribute set. The subclass's code can then read/write those names, but the values are stored in the subclass's own storage (they never overwrite the parent's own values). The Python-level `__private_attrs__` tuple is left unchanged; only the internal private-attribute name set is merged. Default is `False`.
 - 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.1.24 → private_attribute_cpp-2.2.0}/README.md

@@ -232,7 +232,9 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - 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.
+- Since 2.1.0: if a subclass declares a name in its own `__private_attrs__` that is also private to a parent, the two are stored separately (instance attributes per declaring class, class-level attributes per class). 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.
+- Since 2.2.0: a subclass must NOT define an attribute in its namespace (class body) whose name is private to a parent class, unless that name is declared in its own `__private_attrs__` or the class opts in with `use_parents=True`.
+- Since 2.2.0: pass `use_parents=True` in the class definition to inherit all parent classes' private attribute names into the subclass's own private-attribute set. The subclass's code can then read/write those names, but the values are stored in the subclass's own storage (they never overwrite the parent's own values). The Python-level `__private_attrs__` tuple is left unchanged; only the internal private-attribute name set is merged. Default is `False`.
 - 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.1.24 → private_attribute_cpp-2.2.0}/private_attribute.cpp

@@ -328,9 +328,10 @@ struct FinalObject
 
 static TwoStringTuple get_string_hash_tuple2(const std::string& name) noexcept;
 static PyCodeObject* get_now_code() noexcept;
-static uintptr_t type_set_attr_long_long_guidance(uintptr_t type, const std::string& name) noexcept;
+static bool need_analyse_type(PyObject* type) noexcept;
+static const std::vector<uintptr_t>& type_get_parent_ids(uintptr_t type_id) noexcept;
 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;
+static FinalObject type_get_final_attr(uintptr_t main_type, uintptr_t target_type, 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
@@ -377,8 +378,8 @@ attr_classify(uintptr_t typ_id, const std::string& name, PyCodeObject* code) noe
     // 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];
+    {
+        auto& parent_ids = type_get_parent_ids(typ_id);
         chain.insert(chain.end(), parent_ids.begin(), parent_ids.end());
     }
 
@@ -603,7 +604,7 @@ id_getattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
     // 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);
+    FinalObject final_object = type_get_final_attr(final_id, (uintptr_t)typ, attr_name);
     if (final_object.status == -2) {
         return NULL;
     }
@@ -693,10 +694,10 @@ id_getattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
 }
 
 static PyObject*
-type_getattr(PyObject* typ, const std::string& attr_name) noexcept
+type_getattr(uintptr_t main_type, PyObject* typ, const std::string& attr_name) noexcept
 {
     uintptr_t typ_id = (uintptr_t)typ;
-    FinalObject final_object = type_get_final_attr(typ_id, attr_name);
+    FinalObject final_object = type_get_final_attr(main_type, typ_id, attr_name);
     if (final_object.status == -2) {
         return NULL;
     }
@@ -730,7 +731,7 @@ id_setattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
 {
     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);
+    FinalObject final_object = type_get_final_attr(final_id, (uintptr_t)typ, attr_name);
     if (final_object.status == -2) {
         return -1;
     }
@@ -780,50 +781,45 @@ id_setattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
     return 0;
 }
 
-static int type_delattr(PyObject* typ, const std::string& attr_name) noexcept;
+static int type_delattr(uintptr_t main_type, PyObject* typ, const std::string& attr_name) noexcept;
 
 static int
-type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexcept
+type_setattr(uintptr_t main_type, PyObject* typ, const std::string& attr_name, PyObject* value) noexcept
 {
     if (!value) {
-        return type_delattr(typ, attr_name);
+        return type_delattr(main_type, typ, attr_name);
     }
-    uintptr_t typ_id = (uintptr_t) typ;
-    uintptr_t final_id = type_set_attr_long_long_guidance(typ_id, attr_name);
+    uintptr_t target_type = (uintptr_t) typ;
     std::string final_key;
     PyObject* type_need_call;
-    if (::AllData::type_need_call.find(typ_id) != ::AllData::type_need_call.end()) {
-        type_need_call = ::AllData::type_need_call[typ_id];
+    if (::AllData::type_need_call.find(target_type) != ::AllData::type_need_call.end()) {
+        type_need_call = ::AllData::type_need_call[target_type];
     } else {
         type_need_call = NULL;
     }
     if (type_need_call) {
-        auto private_name_result = custom_random_string(typ_id, attr_name, type_need_call);
+        auto private_name_result = custom_random_string(target_type, attr_name, type_need_call);
         if (!private_name_result.ok) {
             return -1;
         }
         final_key = private_name_result.value;
     } else {
-        final_key = default_random_string(typ_id, attr_name);
-    }
-    if (final_id == 0) {
-        PyErr_SetString(PyExc_TypeError, "type not found");
-        return -1;
+        final_key = default_random_string(target_type, attr_name);
     }
-    if (final_id == typ_id) {
-        type_create_mutex(typ_id);
+    if (main_type == target_type) {
+        type_create_mutex(target_type);
         {
-            std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[typ_id]);
-            ::AllData::type_attr_dict[typ_id][final_key] = value;
+            std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[target_type]);
+            ::AllData::type_attr_dict[target_type][final_key] = value;
         }
         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].
-        type_parenttype_create_mutex(final_id, typ_id);
+        // parent's private name separately: all_type_subclass_attr[main_type][target_type].
+        type_parenttype_create_mutex(main_type, target_type);
         {
-            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;
+            std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_subclass_mutex[main_type][target_type]);
+            ::AllData::all_type_subclass_attr[main_type][target_type][final_key] = value;
             return 0;
         }
     }
@@ -834,7 +830,7 @@ id_delattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
 {
     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);
+    FinalObject final_object = type_get_final_attr(final_id, (uintptr_t)typ, attr_name);
     if (final_object.status == -2) {
         return -1;
     }
@@ -892,34 +888,29 @@ id_delattr(uintptr_t final_id, const std::string& attr_name, PyObject* obj, PyOb
 }
 
 static int
-type_delattr(PyObject* typ, const std::string& attr_name) noexcept
+type_delattr(uintptr_t main_type, PyObject* typ, const std::string& attr_name) noexcept
 {
-    uintptr_t typ_id = (uintptr_t) typ;
-    uintptr_t final_id = type_set_attr_long_long_guidance(typ_id, attr_name);
+    uintptr_t target_type = (uintptr_t) typ;
     std::string final_key;
     PyObject* type_need_call;
-    if (::AllData::type_need_call.find(typ_id) != ::AllData::type_need_call.end()) {
-        type_need_call = ::AllData::type_need_call[typ_id];
+    if (::AllData::type_need_call.find(target_type) != ::AllData::type_need_call.end()) {
+        type_need_call = ::AllData::type_need_call[target_type];
     } else {
         type_need_call = NULL;
     }
     if (type_need_call) {
-        auto private_name_result = custom_random_string(typ_id, attr_name, type_need_call);
+        auto private_name_result = custom_random_string(target_type, attr_name, type_need_call);
         if (!private_name_result.ok) {
             return -1;
         }
         final_key = private_name_result.value;
     } else {
-        final_key = default_random_string(typ_id, attr_name);
-    }
-    if (final_id == 0) {
-        PyErr_SetString(PyExc_TypeError, "type not found");
-        return -1;
+        final_key = default_random_string(target_type, attr_name);
     }
-    if (typ_id == final_id) {
-        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()) {
+    if (main_type == target_type) {
+        type_create_mutex(target_type);
+        std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[target_type]);
+        if (::AllData::type_attr_dict[target_type].find(final_key) == ::AllData::type_attr_dict[target_type].end()) {
             const char* type_name = get_name_from_tp_name((PyTypeObject*)typ);
             if (type_name == NULL) {
                 return -1;
@@ -927,11 +918,11 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
             PyErr_Format(PyExc_AttributeError, "type object '%s' has no attribute '%s'", type_name, attr_name.c_str());
             return -1;
         }
-        ::AllData::type_attr_dict[typ_id].erase(final_key);
+        ::AllData::type_attr_dict[target_type].erase(final_key);
     } else {
-        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()) {
+        type_parenttype_create_mutex(main_type, target_type);
+        std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_subclass_mutex[main_type][target_type]);
+        if (::AllData::all_type_subclass_attr[main_type][target_type].find(final_key) == ::AllData::all_type_subclass_attr[main_type][target_type].end()) {
             const char* type_name = get_name_from_tp_name((PyTypeObject*)typ);
             if (type_name == NULL) {
                 return -1;
@@ -939,7 +930,7 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
             PyErr_Format(PyExc_AttributeError, "type object '%s' has no attribute '%s'", type_name, attr_name.c_str());
             return -1;
         }
-        ::AllData::all_type_subclass_attr[final_id][typ_id].erase(final_key);
+        ::AllData::all_type_subclass_attr[main_type][target_type].erase(final_key);
     }
     return 0;
 }
@@ -2470,123 +2461,122 @@ 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_get_final_attr(uintptr_t main_type, uintptr_t target_type, 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()) {
-            PyObject* type_need_call = NULL;
-            if (::AllData::type_need_call.find(type_id) != ::AllData::type_need_call.end()) {
-                type_need_call = ::AllData::type_need_call[type_id];
-            }
-            std::string key;
-            if (type_need_call != NULL) {
-                auto private_name_result = custom_random_string(type_id, name, type_need_call);
-                if (!private_name_result.ok) {
-                    return -2; // -2 means exception
-                }
-                key = private_name_result.value;
-            } else {
-                key = default_random_string(type_id, name);
+    // main_type is the code owner (the class declaring the attribute private);
+    // target_type is the object's type whose attribute is being accessed. Only
+    // type_attr_dict[main_type] and all_type_subclass_attr[main_type][*] are
+    // analysed. Each visited type's own type_need_call drives its key.
+    std::vector<uintptr_t> chain;
+    chain.push_back(target_type);
+    if (::AllData::all_type_parent_id.find(target_type) != ::AllData::all_type_parent_id.end()) {
+        auto& parent_ids = ::AllData::all_type_parent_id[target_type];
+        chain.insert(chain.end(), parent_ids.begin(), parent_ids.end());
+    }
+    for (auto& type : chain) {
+        std::string key;
+        PyObject* need_call = NULL;
+        if (::AllData::type_need_call.find(type) != ::AllData::type_need_call.end()) {
+            need_call = ::AllData::type_need_call[type];
+        }
+        if (need_call != NULL) {
+            auto private_name_result = custom_random_string(type, name, need_call);
+            if (!private_name_result.ok) {
+                return -2; // -2 means exception
             }
-            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];
+            key = private_name_result.value;
+        } else {
+            key = default_random_string(type, name);
+        }
+        if (type == main_type) {
+            type_create_mutex(main_type);
+            std::shared_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[main_type]);
+            auto& item_set = ::AllData::type_attr_dict[main_type];
             if (item_set.find(key) != item_set.end()) {
                 PyObject* obj = item_set[key];
                 return obj;
             }
-        }
-    }
-    std::vector<uintptr_t> now_visited = {type_id};
-    if (::AllData::all_type_parent_id.find(type_id) != ::AllData::all_type_parent_id.end()) {
-        auto& parent_ids = ::AllData::all_type_parent_id[type_id];
-        for (auto& parent_id: parent_ids) {
-            if (::AllData::all_type_attr_set.find(parent_id) != ::AllData::all_type_attr_set.end()) {
-                auto& item_set = ::AllData::all_type_attr_set[parent_id];
-                if (item_set.find(hash_tuple) != item_set.end()) {
-                    if (::AllData::all_type_subclass_attr.find(parent_id) != ::AllData::all_type_subclass_attr.end()) {
-                        auto& now_mro_dict = ::AllData::all_type_subclass_attr[parent_id];
-                        for (auto& now_visited_id: now_visited) {
-                            if (now_mro_dict.find(now_visited_id) != now_mro_dict.end()) {
-                                std::string key;
-                                if (::AllData::type_need_call.find(now_visited_id) != ::AllData::type_need_call.end()) {
-                                    PyObject* func = ::AllData::type_need_call[now_visited_id];
-                                    if (func != NULL) {
-                                        auto private_name_result = custom_random_string(now_visited_id, name, func);
-                                        if (!private_name_result.ok) {
-                                            return -2; // -2 means exception
-                                        }
-                                        key = private_name_result.value;
-                                    } else {
-                                        key = default_random_string(now_visited_id, name);
-                                    }
-                                } else {
-                                    key = default_random_string(now_visited_id, name);
-                                }
-                                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];
-                                    return obj;
-                                }
-                            }
-                        }
-                    }
-                    std::string key;
-                    if (::AllData::type_need_call.find(parent_id) != ::AllData::type_need_call.end()) {
-                        PyObject* func = ::AllData::type_need_call[parent_id];
-                        if (func != NULL) {
-                            auto private_name_result = custom_random_string(parent_id, name, func);
-                            if (!private_name_result.ok) {
-                                return -2; // -2 means exception
-                            }
-                            key = private_name_result.value;
-                        } else {
-                            key = default_random_string(parent_id, name);
-                        }
-                    } else {
-                        key = default_random_string(parent_id, name);
-                    }
-                    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;
-                    }
+            return -1; // main_type has no such attribute -> not found
+        }
+        if (::AllData::all_type_subclass_attr.find(main_type) != ::AllData::all_type_subclass_attr.end()) {
+            auto& now_mro_dict = ::AllData::all_type_subclass_attr[main_type];
+            if (now_mro_dict.find(type) != now_mro_dict.end()) {
+                type_parenttype_create_mutex(main_type, type);
+                std::shared_lock<std::shared_mutex> lock(*::AllData::all_type_subclass_mutex[main_type][type]);
+                if (now_mro_dict[type].find(key) != now_mro_dict[type].end()) {
+                    PyObject* obj = now_mro_dict[type][key];
+                    return obj;
                 }
             }
-            now_visited.push_back(parent_id);
         }
     }
     return -1; // -1 means not found
 }
 
-static uintptr_t
-type_set_attr_long_long_guidance(uintptr_t type_id, const std::string& name) noexcept
+static bool
+need_analyse_type(PyObject* type) noexcept;
+
+static bool
+type_private_attr_declared(uintptr_t type_id, const std::string& name) noexcept
 {
-    TwoStringTuple hash_tuple = get_string_hash_tuple2(name);
-    if (::AllData::all_type_attr_set.find(type_id) != ::AllData::all_type_attr_set.end()) {
-        auto& item_set = ::AllData::all_type_attr_set[type_id];
-        if (item_set.find(hash_tuple) != item_set.end()) {
-            return type_id;
+    // Fallback used while a type is still being created (e.g. inside
+    // __init_subclass__), when all_type_attr_set[type_id] has not been set yet.
+    // Read '__private_attrs__' from the type's tp_dict and check membership
+    // via Python tuple equality.
+    KeepPythonException _;
+    PyTypeObject* tp = (PyTypeObject*)type_id;
+    if (!PyType_Check(tp)) {
+        return false;
+    }
+    PyObject* private_attrs = PyDict_GetItemString(tp->tp_dict, "__private_attrs__");
+    if (!private_attrs || !PySequence_Check(private_attrs)) {
+        return false;
+    }
+    PyObjectStorage hash_tuple = PyObjectStorage::from_new_ref(get_string_hash_tuple(name));
+    if (!hash_tuple) {
+        return false;
+    }
+    Py_ssize_t len = PySequence_Length(private_attrs);
+    for (Py_ssize_t i = 0; i < len; i++) {
+        PyObjectStorage item = PyObjectStorage::from_new_ref(PySequence_GetItem(private_attrs, i));
+        if (!item) {
+            continue;
+        }
+        int eq = PyObject_RichCompareBool(item, hash_tuple, Py_EQ);
+        if (eq < 0) {
+            PyErr_Clear();
+            return false;
+        }
+        if (eq) {
+            return true;
         }
     }
-    if (::AllData::all_type_parent_id.find(type_id) != ::AllData::all_type_parent_id.end()) {
-        auto& parent_id_list = ::AllData::all_type_parent_id[type_id];
-        for (auto& parent_id: parent_id_list) {
-            auto& item_set = ::AllData::all_type_attr_set[parent_id];
-            if (item_set.find(hash_tuple) != item_set.end()) {
-                return parent_id;
+    return false;
+}
+
+static const std::vector<uintptr_t>&
+type_get_parent_ids(uintptr_t type_id) noexcept
+{
+    auto it = ::AllData::all_type_parent_id.find(type_id);
+    if (it != ::AllData::all_type_parent_id.end()) {
+        return it->second;
+    }
+    // The type has not been fully registered yet (e.g. inside __init_subclass__):
+    // build the MRO chain on the fly from tp_mro.
+    std::vector<uintptr_t> mro_vector;
+    PyTypeObject* tp = (PyTypeObject*)type_id;
+    if (PyType_Check(tp) && tp->tp_mro) {
+        Py_ssize_t mro_size = PyTuple_GET_SIZE(tp->tp_mro);
+        for (Py_ssize_t i = 1; i < mro_size; i++) {
+            PyObject* item = PyTuple_GET_ITEM(tp->tp_mro, i);
+            if (!item || !PyType_Check(item) || !need_analyse_type(item)) {
+                continue;
             }
+            mro_vector.push_back((uintptr_t)item);
         }
     }
-    return 0; // 0 means not found
+    ::AllData::all_type_parent_id[type_id] = mro_vector;
+    return ::AllData::all_type_parent_id[type_id];
 }
 
 static bool
@@ -2598,14 +2588,18 @@ type_private_attr(uintptr_t type_id, const std::string& name) noexcept
         if (item_set.find(hash_tuple) != item_set.end()) {
             return true;
         }
+    } else if (type_private_attr_declared(type_id, name)) {
+        return true;
     }
-    if (::AllData::all_type_parent_id.find(type_id) != ::AllData::all_type_parent_id.end()) {
-        auto& parent_id_list = ::AllData::all_type_parent_id[type_id];
-        for (auto& parent_id: parent_id_list) {
+    auto& parent_id_list = type_get_parent_ids(type_id);
+    for (auto& parent_id: parent_id_list) {
+        if (::AllData::all_type_attr_set.find(parent_id) != ::AllData::all_type_attr_set.end()) {
             auto& item_set = ::AllData::all_type_attr_set[parent_id];
             if (item_set.find(hash_tuple) != item_set.end()) {
                 return true;
             }
+        } else if (type_private_attr_declared(parent_id, name)) {
+            return true;
         }
     }
     return false;
@@ -2758,6 +2752,7 @@ struct PrivateAttrCreationData
     PyObject* name = nullptr;
     PyObject* bases = nullptr;
     PyObject* attrs = nullptr;
+    bool use_parents = false;
     bool cleared = false;
 
     void clear() noexcept {
@@ -2857,6 +2852,21 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         return false;
     }
 
+    if (kwds && PyDict_Check(kwds)) {
+        int has_use_parents = PyDict_ContainsString(kwds, "use_parents");
+        if (has_use_parents < 0) {
+            return false;
+        }
+        if (has_use_parents) {
+            PyObject* use_parents_obj = PyDict_GetItemString(kwds, "use_parents");
+            int truth = PyObject_IsTrue(use_parents_obj);
+            if (truth < 0) {
+                return false;
+            }
+            data.use_parents = (truth == 1);
+        }
+    }
+
     PyObjectStorage __private_attrs__;
     if (PyDict_ContainsString(data.attrs, "__private_attrs__")) {
         __private_attrs__ = PyDict_GetItemString(data.attrs, "__private_attrs__");
@@ -2865,6 +2875,10 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         __private_attrs__ = PyObjectStorage::from_new_ref(PyTuple_New(0));
     }
 
+    if (!__private_attrs__) {
+        return false;
+    }
+
     if (PyUnicode_Check(__private_attrs__)) {
         PyObject* new___private_attrs__ = PyTuple_New(1);
         if (!new___private_attrs__) {
@@ -2985,10 +2999,31 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         data.all_need_analyse_base.push_back((uintptr_t)base);
     }
 
+    if (data.use_parents) {
+        // 2.2.0: when use_parents=True, merge every ancestor's private attribute
+        // names into this class's own private-attr set (the TwoStringTuple set).
+        // The Python-level '__private_attrs__' tuple is left untouched; only
+        // AllData::all_type_attr_set[this] gains the inherited names.
+        std::vector<uintptr_t> all_ancestors;
+        for (auto& base : data.all_need_analyse_base) {
+            all_ancestors.push_back(base);
+            if (::AllData::all_type_parent_id.find(base) != ::AllData::all_type_parent_id.end()) {
+                auto& ancestor_ids = ::AllData::all_type_parent_id[base];
+                all_ancestors.insert(all_ancestors.end(), ancestor_ids.begin(), ancestor_ids.end());
+            }
+        }
+        for (auto& ancestor : all_ancestors) {
+            if (::AllData::all_type_attr_set.find(ancestor) != ::AllData::all_type_attr_set.end()) {
+                auto& ancestor_set = ::AllData::all_type_attr_set[ancestor];
+                data.private_attrs_set.insert(ancestor_set.begin(), ancestor_set.end());
+            }
+        }
+    }
+
     std::function<uintptr_t(std::string)> need_remove_to_subclass = [&data](std::string attr_name){
         for (auto& base: data.all_need_analyse_base) {
             if (type_private_attr(base, attr_name)) {
-                return type_set_attr_long_long_guidance(base, attr_name);
+                return base;
             }
         }
         return (uintptr_t)0;
@@ -3027,13 +3062,19 @@ 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] = {};
+                // parent class and is not declared in this class's own
+                // '__private_attrs__'.
+                if (!data.use_parents) {
+                    // 2.2.0: forbidden unless the parent private attribute is
+                    // explicitly inherited via use_parents=True.
+                    PyErr_Format(PyExc_TypeError,
+                        "cannot define '%s' in class '%s': it is private to a parent class and not declared in this class's '__private_attrs__' (set use_parents=True to inherit parent private attributes)",
+                        attr_name.c_str(), data.class_name.c_str());
+                    return false;
                 }
-                // PyObjectStorage assignment INCREFs (RAII); no manual INCREF.
-                data.need_remove_subclass[need_remove_subclass_id][attr_name] = need_value;
+                // use_parents=True: store the value into this class's own private
+                // attribute storage (type_attr_dict[this]) instead of the parent's.
+                data.need_remove_itself[attr_name] = need_value;
                 if (PyDict_DelItem(data.attrs_copy, key)) return false;
                 continue;
             }
@@ -3057,6 +3098,9 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         if (has_private_func) {
             if (PyDict_DelItemString(data.base_kwds, "private_func") < 0) return false;
         }
+        if (PyDict_ContainsString(kwds, "use_parents")) {
+            if (PyDict_DelItemString(data.base_kwds, "use_parents") < 0) return false;
+        }
     }
 
     return true;
@@ -3269,8 +3313,15 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
         if (::AllData::all_type_subclass_mutex.find(i) == ::AllData::all_type_subclass_mutex.end()) {
             ::AllData::all_type_subclass_mutex[i].clear();
         }
-        ::AllData::all_type_subclass_attr[i][type_id] = {};
-        ::AllData::all_type_subclass_mutex[i][type_id] = std::make_unique<std::shared_mutex>();
+        // Do not wipe a parent's shadow already written for this class during
+        // __init_subclass__ (e.g. `cls._value = ...` inside the parent's
+        // __init_subclass__ runs inside tp_new, before postprocess).
+        if (::AllData::all_type_subclass_attr[i].find(type_id) == ::AllData::all_type_subclass_attr[i].end()) {
+            ::AllData::all_type_subclass_attr[i][type_id] = {};
+        }
+        if (::AllData::all_type_subclass_mutex[i].find(type_id) == ::AllData::all_type_subclass_mutex[i].end()) {
+            ::AllData::all_type_subclass_mutex[i][type_id] = std::make_unique<std::shared_mutex>();
+        }
     }
 
     for (auto& [key, value]: data.need_remove_itself) {
@@ -3418,7 +3469,7 @@ PrivateAttrType_getattr(PyObject* cls, PyObject* name) noexcept
                 return NULL;
             }
             if (classify.type_id != 0) {
-                return type_getattr(cls, name_str);
+                return type_getattr(classify.type_id, cls, name_str);
             }
         }
     }
@@ -3766,7 +3817,7 @@ PrivateAttrType_setattr(PyObject* cls, PyObject* name, PyObject* value) noexcept
                 return -1;
             }
             if (classify.type_id != 0) {
-                return type_setattr(cls, name_str, value);
+                return type_setattr(classify.type_id, cls, name_str, value);
             }
             // owner is 0: not private for this access context -> normal attribute
         }

{private_attribute_cpp-2.1.24 → private_attribute_cpp-2.2.0}/private_attribute.pyi

@@ -99,7 +99,8 @@ class PrivateAttrType(type):
     "metaclass for private attributes"
     def __new__(cls, name: str, bases: tuple,
                 attrs: _PrivateAttrDict, /, *,
-                private_func: Callable[[int, str], str]|None = None) -> PrivateAttrType: ...
+                private_func: Callable[[int, str], str]|None = None,
+                use_parents: bool = False) -> PrivateAttrType: ...
 
 class PrivateAttrBase(metaclass=PrivateAttrType):
     "The class to help creating private attribute. It does not have any special behavior."
@@ -146,6 +147,13 @@ def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _Pri
 
     private_attribute.register_metaclass(PrivateAbcMeta)
     ```
+
+    Optional keyword arguments:
+    - private_func: custom hidden-name generator `(obj_id, attr_name) -> str`.
+    - use_parents: when True, merge every parent class's private attribute names
+      into this class's own private-attribute set, so the subclass's code may
+      read/write those names (stored in the subclass's own storage). Default
+      False.
     """
     ...
 

{private_attribute_cpp-2.1.24 → private_attribute_cpp-2.2.0/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.24
+Version: 2.2.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
@@ -253,7 +253,9 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - 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.
+- Since 2.1.0: if a subclass declares a name in its own `__private_attrs__` that is also private to a parent, the two are stored separately (instance attributes per declaring class, class-level attributes per class). 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.
+- Since 2.2.0: a subclass must NOT define an attribute in its namespace (class body) whose name is private to a parent class, unless that name is declared in its own `__private_attrs__` or the class opts in with `use_parents=True`.
+- Since 2.2.0: pass `use_parents=True` in the class definition to inherit all parent classes' private attribute names into the subclass's own private-attribute set. The subclass's code can then read/write those names, but the values are stored in the subclass's own storage (they never overwrite the parent's own values). The Python-level `__private_attrs__` tuple is left unchanged; only the internal private-attribute name set is merged. Default is `False`.
 - 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.1.24 → private_attribute_cpp-2.2.0}/private_attribute_cpp.egg-info/SOURCES.txt

@@ -13,10 +13,12 @@ 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_init_subclass.py
 tests/test_private_abc.py
 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_slots_cycle.py
+tests/test_slots_cycle.py
+tests/test_use_parents.py

{private_attribute_cpp-2.1.24 → private_attribute_cpp-2.2.0}/setup.py

@@ -24,7 +24,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='2.1.24',
+    version='2.2.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.1.24 → private_attribute_cpp-2.2.0}/tests/test_attr_classify_owner.py

@@ -80,24 +80,24 @@ class TestCodeSwapOwnership(unittest.TestCase):
 
 
 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."""
+    """Parent code always reads the parent's own storage, even when a subclass
+    shadows the name in its own class-level storage."""
 
-    def test_unwritten_read_falls_back_per_subject(self):
+    def test_unwritten_read_uses_parent_storage(self):
         class FreshChild(Parent):
             __private_attrs__ = ["_n"]
             _n = 100
             f = Parent.inc
 
         c = FreshChild()
-        self.assertEqual(c.peek(), 100)
+        self.assertEqual(c.peek(), 0)
         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."""
+    storage, parent's code reads the parent's own storage (0)."""
 
     def test_child_own_code_uses_child_storage(self):
         class NormChild(Parent):
@@ -110,7 +110,7 @@ class TestNormalUsageRegression(unittest.TestCase):
 
         c = NormChild()
         self.assertEqual(c.own_inc(), 101)
-        self.assertEqual(c.peek(), 100)
+        self.assertEqual(c.peek(), 0)
         self.assertEqual(Parent().peek(), 0)
 
 

private_attribute_cpp-2.2.0/tests/test_init_subclass.py

@@ -0,0 +1,85 @@
+import private_attribute
+import unittest
+
+
+class TestInitSubclassWrite(unittest.TestCase):
+    """A parent may write a private attribute into a subclass (e.g. via
+    __init_subclass__); later, the parent's own code reading the subclass (or
+    an instance of it) must see the parent-stored value, while the subclass's
+    own same-name private storage stays independent."""
+
+    def test_init_subclass_write_visible_to_parent_code(self):
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+            _value = "parent_own"
+
+            def __init_subclass__(cls, **kw):
+                super().__init_subclass__(**kw)
+                cls._value = "from_parent"
+
+            @classmethod
+            def get_cls_value(cls):
+                return cls._value
+
+            def get_value(self):
+                return self._value
+
+        class Child(Parent):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self):
+                super().__init__()
+                self._value = "child_own"
+
+            def get_own(self):
+                return self._value
+
+        # parent code reading the subclass class / instance sees the
+        # parent-stored value
+        self.assertEqual(Child.get_cls_value(), "from_parent")
+        self.assertEqual(Child().get_value(), "from_parent")
+        # the subclass's own code reads/writes its own independent storage
+        self.assertEqual(Child().get_own(), "child_own")
+        # the parent's own storage is untouched
+        self.assertEqual(Parent().get_value(), "parent_own")
+        # private attribute stays hidden from outside
+        with self.assertRaises(AttributeError):
+            Child()._value
+        with self.assertRaises(AttributeError):
+            Child._value
+
+    def test_parent_writes_child_after_creation(self):
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+            _value = "parent_own"
+
+            @classmethod
+            def write_child(cls, child_cls, v):
+                child_cls._value = v
+
+            def get_value(self):
+                return self._value
+
+            @classmethod
+            def get_cls_value(cls):
+                return cls._value
+
+        class Child(Parent):
+            __private_attrs__ = ["_value"]
+
+            def __init__(self):
+                super().__init__()
+                self._value = "child_own"
+
+            def get_own(self):
+                return self._value
+
+        Parent.write_child(Child, "from_parent")
+        self.assertEqual(Child.get_cls_value(), "from_parent")
+        self.assertEqual(Child().get_value(), "from_parent")
+        self.assertEqual(Child().get_own(), "child_own")
+        self.assertEqual(Parent().get_value(), "parent_own")
+
+
+if __name__ == "__main__":
+    unittest.main()

{private_attribute_cpp-2.1.24 → private_attribute_cpp-2.2.0}/tests/test_private_inheritance.py

@@ -88,11 +88,9 @@ class TestPrivateInheritance(unittest.TestCase):
         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.
+    def test_same_name_class_attrs_require_use_parents(self):
+        # 2.2.0: a class body may not define a name that is private to a parent
+        # unless it declares the name itself or opts in via use_parents=True.
         class Parent(private_attribute.PrivateAttrBase):
             __private_attrs__ = ["_value"]
             _value = 10
@@ -100,7 +98,24 @@ class TestPrivateInheritance(unittest.TestCase):
             def get_value(self):
                 return self._value
 
-        class Child(Parent):
+        with self.assertRaises(TypeError):
+            class Child(Parent):
+                __private_attrs__ = []
+                _value = 20
+
+    def test_use_parents_class_attrs(self):
+        # 2.2.0: use_parents=True lets a subclass define a parent's private
+        # name in its own body; the value is stored in the subclass's own
+        # storage and the parent's value is untouched. Parent code always
+        # reads the parent's own storage.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+            _value = 10
+
+            def get_value(self):
+                return self._value
+
+        class Child(Parent, use_parents=True):
             __private_attrs__ = []
             _value = 20
 
@@ -109,19 +124,20 @@ class TestPrivateInheritance(unittest.TestCase):
 
         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()
+        # parent's code reads the parent's own storage, not the child's shadow
+        self.assertEqual(obj.get_value(), 10)
+        # the subclass's own code reads its own value
+        self.assertEqual(obj.get_child_value(), 20)
         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.
+    def test_use_parents_class_attrs_write_separately(self):
+        # 2.2.0: with use_parents=True, parent code (set_value/get_value) writes
+        # and reads the parent's own shadow of the child's storage
+        # (all_type_subclass_attr[Parent][Child]); the subclass's own code
+        # operates on the child's own storage (type_attr_dict[Child]).
         class Parent(private_attribute.PrivateAttrBase):
             __private_attrs__ = ["_value"]
             _value = 1
@@ -134,7 +150,7 @@ class TestPrivateInheritance(unittest.TestCase):
             def get_value(cls):
                 return cls._value
 
-        class Child(Parent):
+        class Child(Parent, use_parents=True):
             __private_attrs__ = []
             _value = 2
 
@@ -142,16 +158,22 @@ class TestPrivateInheritance(unittest.TestCase):
             def set_own(cls, v):
                 cls._value = v
 
+            @classmethod
+            def get_own(cls):
+                return cls._value
+
         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
+        # parent code reads the parent's shadow (empty -> falls back to parent storage)
+        self.assertEqual(Child.get_value(), 1)
+        # parent's classmethod called on the child writes the parent's shadow
         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)
+        # the subclass's own code writes its own storage
+        Child.set_own(7)
+        self.assertEqual(Child.get_own(), 7)
         self.assertEqual(Child.get_value(), 99)
+        self.assertEqual(Parent.get_value(), 1)
         # parent's own storage still writable through the parent
         Parent.set_value(5)
         self.assertEqual(Parent.get_value(), 5)

private_attribute_cpp-2.2.0/tests/test_use_parents.py

@@ -0,0 +1,129 @@
+import private_attribute
+import unittest
+
+
+class TestUseParents(unittest.TestCase):
+    def test_forbidden_parent_private_in_namespace(self):
+        # 2.2.0: a subclass must not write a parent-private attribute into its
+        # own namespace unless it is declared in __private_attrs__ or
+        # use_parents=True is set.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_secret"]
+
+            def __init__(self):
+                self._secret = 1
+
+        with self.assertRaises(TypeError):
+            class Child(Parent):
+                __private_attrs__ = []
+                _secret = 999
+
+    def test_use_parents_instance_storage(self):
+        # 2.2.0: use_parents=True lets the subclass code read/write the
+        # parent's private name, but the value lives in the subclass's own
+        # storage; the parent's own storage is untouched.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_secret"]
+
+            def __init__(self):
+                self._secret = 1
+
+            def get_secret(self):
+                return self._secret
+
+        class Child(Parent, use_parents=True):
+            __private_attrs__ = []
+
+            def __init__(self):
+                super().__init__()
+                self._secret = 99
+
+            def read_own(self):
+                return self._secret
+
+            def write_own(self, v):
+                self._secret = v
+
+        obj = Child()
+        # parent's code sees the parent's own value
+        self.assertEqual(obj.get_secret(), 1)
+        # child's code sees its own value
+        self.assertEqual(obj.read_own(), 99)
+        # child writes into its own storage only
+        obj.write_own(7)
+        self.assertEqual(obj.read_own(), 7)
+        self.assertEqual(obj.get_secret(), 1)
+        with self.assertRaises(AttributeError):
+            obj._secret
+
+    def test_use_parents_class_body_value(self):
+        # 2.2.0: with use_parents=True a subclass may define a parent-private
+        # name in its own body; it is stored in the subclass's own storage.
+        # Parent code always reads the parent's own storage.
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_value"]
+            _value = 10
+
+            def get_value(self):
+                return self._value
+
+        class Child(Parent, use_parents=True):
+            __private_attrs__ = []
+            _value = 20
+
+            def get_own(self):
+                return self._value
+
+        self.assertEqual(Parent().get_value(), 10)
+        obj = Child()
+        self.assertEqual(obj.get_value(), 10)
+        self.assertEqual(obj.get_own(), 20)
+        with self.assertRaises(AttributeError):
+            obj._value
+
+    def test_use_parents_not_inherited_by_grandchild(self):
+        # 2.2.0: use_parents merges the ancestor sets only into the class that
+        # opts in; a grandchild without use_parents neither sees nor may
+        # define the grandparent's private name.
+        class GrandParent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_g"]
+
+        class Parent(GrandParent, use_parents=True):
+            __private_attrs__ = []
+            _g = 1
+
+        # Child (no use_parents) cannot define the grandparent-private name.
+        with self.assertRaises(TypeError):
+            class Child(Parent):
+                __private_attrs__ = []
+                _g = 2
+
+        class Child2(Parent):
+            __private_attrs__ = []
+
+            def read_g(self):
+                return self._g
+
+        c = Child2()
+        with self.assertRaises(AttributeError):
+            c.read_g()
+
+    def test_use_parents_false_is_default(self):
+        class Parent(private_attribute.PrivateAttrBase):
+            __private_attrs__ = ["_secret"]
+
+        # default (no kwarg) behaves like use_parents=False
+        with self.assertRaises(TypeError):
+            class Child(Parent):
+                __private_attrs__ = []
+                _secret = 1
+
+        # explicit False behaves the same
+        with self.assertRaises(TypeError):
+            class Child2(Parent, use_parents=False):
+                __private_attrs__ = []
+                _secret = 1
+
+
+if __name__ == "__main__":
+    unittest.main()