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

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

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

@@ -225,6 +225,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 +264,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 +490,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;
     }
@@ -575,13 +628,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;
     }
@@ -684,6 +735,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] = {};
         }
@@ -706,13 +759,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;
     }
@@ -1281,14 +1332,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()){
@@ -1313,17 +1371,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()){
@@ -1554,6 +1619,21 @@ PrivateAttr_tp_clear(PyObject* self) noexcept
     return 0;
 }
 
+// get_type_need_tp_* : the metaclass counterparts of get_need_tp_*.
+// get_need_tp_*          -> find the original slots of *types created by* the
+//                            metaclasses (wrapped with the instance-level
+//                            PrivateAttr_tp_* / PrivateAttr_tp_getattro set).
+// get_type_need_tp_*     -> find the original slots of the *metaclasses*
+//                            themselves (wrapped with the metaclass-level
+//                            PrivateAttrType_getattr / PrivateAttrType_setattr /
+//                            register_finalize / PrivateAttrType_tp_traverse /
+//                            PrivateAttrType_tp_clear).
+static getattrofunc get_type_need_tp_getattro(PyTypeObject* cls) noexcept;
+static setattrofunc get_type_need_tp_setattro(PyTypeObject* cls) noexcept;
+static traverseproc get_type_need_tp_traverse(PyTypeObject* cls) noexcept;
+static inquiry get_type_need_tp_clear(PyTypeObject* cls) noexcept;
+static destructor get_type_need_tp_finalize(PyTypeObject* cls) noexcept;
+
 // metaclass-level (type object) traverse/clear: call original if any, and handle AllData-stored type attributes
 static int
 PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
@@ -1575,7 +1655,7 @@ PrivateAttrType_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept
             if (res) return res;
         }
     } else {
-        traverseproc orig = get_need_tp_traverse(typ);
+        traverseproc orig = get_type_need_tp_traverse(typ);
         if (orig) {
             int res = orig(self, visit, arg);
             if (res) return res;
@@ -1662,7 +1742,7 @@ PrivateAttrType_tp_clear(PyObject* self) noexcept
         inquiry orig = ::AllData::all_type_clear[typ_id];
         if (orig) orig(self);
     } else {
-        inquiry orig = get_need_tp_clear(typ);
+        inquiry orig = get_type_need_tp_clear(typ);
         if (orig) orig(self);
     }
 
@@ -1746,8 +1826,8 @@ static PyTypeObject PrivateAttrType = {
     0,                                          // tp_as_buffer
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,   // tp_flags
     "metaclass for private attributes",         // tp_doc
-    0,                                          // tp_travers
-    0,                                          // tp_clear
+    (traverseproc)PrivateAttrType_tp_traverse,  // tp_travers
+    (inquiry)PrivateAttrType_tp_clear,          // tp_clear
     0,                                          // tp_richcompare
     0,                                          // tp_weaklistoffset
     0,                                          // tp_iter
@@ -1796,6 +1876,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()) {
@@ -2084,6 +2168,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;
@@ -2365,6 +2451,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] = {};
                 }
@@ -2427,21 +2516,6 @@ static traverseproc get_need_tp_traverse(PyTypeObject* cls) noexcept;
 static inquiry get_need_tp_clear(PyTypeObject* cls) noexcept;
 static destructor get_need_tp_finalize(PyTypeObject* cls) noexcept;
 
-// get_type_need_tp_* : the metaclass counterparts of get_need_tp_*.
-// get_need_tp_*          -> find the original slots of *types created by* the
-//                            metaclasses (wrapped with the instance-level
-//                            PrivateAttr_tp_* / PrivateAttr_tp_getattro set).
-// get_type_need_tp_*     -> find the original slots of the *metaclasses*
-//                            themselves (wrapped with the metaclass-level
-//                            PrivateAttrType_getattr / PrivateAttrType_setattr /
-//                            register_finalize / PrivateAttrType_tp_traverse /
-//                            PrivateAttrType_tp_clear).
-static getattrofunc get_type_need_tp_getattro(PyTypeObject* cls) noexcept;
-static setattrofunc get_type_need_tp_setattro(PyTypeObject* cls) noexcept;
-static traverseproc get_type_need_tp_traverse(PyTypeObject* cls) noexcept;
-static inquiry get_type_need_tp_clear(PyTypeObject* cls) noexcept;
-static destructor get_type_need_tp_finalize(PyTypeObject* cls) noexcept;
-
 // instance-level traverse/clear for types that use private attributes
 static int PrivateAttr_tp_traverse(PyObject* self, visitproc visit, void* arg) noexcept;
 static int PrivateAttr_tp_clear(PyObject* self) noexcept;
@@ -2661,6 +2735,7 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
     }
 
     if (data.private_func) {
+        Py_INCREF(data.private_func);
         ::AllData::type_need_call[type_id] = data.private_func;
     }
 
@@ -2750,13 +2825,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;
@@ -3097,13 +3180,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;
@@ -3133,8 +3224,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);
+        Py_DECREF(::AllData::type_need_call[typ_id]);
         ::AllData::type_need_call.erase(typ_id);
     }
     if (::AllData::type_attr_dict.find(typ_id) != ::AllData::type_attr_dict.end()) {

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

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

@@ -18,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='2.0.6',
+    version='2.1.1',
     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.6 → private_attribute_cpp-2.1.1}/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.1/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.1/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.6/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.6/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()