private-attribute-cpp 2.1.2__tar.gz → 2.1.4__tar.gz

{private_attribute_cpp-2.1.2/private_attribute_cpp.egg-info → private_attribute_cpp-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.2
+Version: 2.1.4
 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
@@ -75,7 +75,7 @@ print(obj.expensive_api_call(10))   # works with all decorators applied
 | 1 | PrivateWrapProxy | Decorator wrapper for arbitrary decorators | When needed |
 | 2 | private_func=callable | Custom hidden-name generator | Optional |
 | 3 | Pass private_func in class definition | Same as above | Optional |
-| 4 | \_\_private_attrs\_\_ list | Declare which attributes are private | Yes |
+| 4 | \_\_private_attrs\_\_ list | Declare which attributes are private | Optional (changed in 2.1.4) |
 | 5 | @PrivateWrapProxy(...) | Make any decorator compatible with private attributes | When needed |
 | 6 | method.result.xxx chain + dummy wrap | Fix decorator order and name conflicts | When needed |
 
@@ -240,8 +240,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 
 ## Notes
 
-- All of the private attributes class must contain the `__private_attrs__` attribute.
-- The `__private_attrs__` attribute must be a sequence of strings.
+- ~~All of the private attributes class must contain the `__private_attrs__` attribute.~~(changed in 2.1.4)
+- The `__private_attrs__` attribute must be a sequence of strings or just one string.
 - You cannot define the name which in `__slots__` to `__private_attrs__`.
 - When you define `__slots__` and `__private_attrs__` in one class, the attributes in `__private_attrs__` can also be defined in the methods, even though they are not in `__slots__`.
 - All of the object that is the instance of the class "PrivateAttrBase" or its subclass are default to be unable to be pickled.
@@ -266,4 +266,4 @@ This package require the c++ module "[picosha2](https://github.com/okdshin/PicoS
 
 ## Support
 
-Now it doesn't support "PyPy".
+Now it only support Cpython.

{private_attribute_cpp-2.1.2 → private_attribute_cpp-2.1.4}/README.md

@@ -56,7 +56,7 @@ print(obj.expensive_api_call(10))   # works with all decorators applied
 | 1 | PrivateWrapProxy | Decorator wrapper for arbitrary decorators | When needed |
 | 2 | private_func=callable | Custom hidden-name generator | Optional |
 | 3 | Pass private_func in class definition | Same as above | Optional |
-| 4 | \_\_private_attrs\_\_ list | Declare which attributes are private | Yes |
+| 4 | \_\_private_attrs\_\_ list | Declare which attributes are private | Optional (changed in 2.1.4) |
 | 5 | @PrivateWrapProxy(...) | Make any decorator compatible with private attributes | When needed |
 | 6 | method.result.xxx chain + dummy wrap | Fix decorator order and name conflicts | When needed |
 
@@ -221,8 +221,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 
 ## Notes
 
-- All of the private attributes class must contain the `__private_attrs__` attribute.
-- The `__private_attrs__` attribute must be a sequence of strings.
+- ~~All of the private attributes class must contain the `__private_attrs__` attribute.~~(changed in 2.1.4)
+- The `__private_attrs__` attribute must be a sequence of strings or just one string.
 - You cannot define the name which in `__slots__` to `__private_attrs__`.
 - When you define `__slots__` and `__private_attrs__` in one class, the attributes in `__private_attrs__` can also be defined in the methods, even though they are not in `__slots__`.
 - All of the object that is the instance of the class "PrivateAttrBase" or its subclass are default to be unable to be pickled.
@@ -247,4 +247,4 @@ This package require the c++ module "[picosha2](https://github.com/okdshin/PicoS
 
 ## Support
 
-Now it doesn't support "PyPy".
+Now it only support Cpython.

{private_attribute_cpp-2.1.2 → private_attribute_cpp-2.1.4}/private_attribute.cpp

@@ -317,11 +317,11 @@ attr_classify(uintptr_t typ_id, const std::string& name, PyCodeObject* code) noe
         chain.insert(chain.end(), parent_ids.begin(), parent_ids.end());
     }
 
-    // Find the class whose code is currently running (the code owner).
+    // Find the class whose code is currently running (the code owner, parent first).
     uintptr_t code_class = 0;
-    for (auto& node : chain) {
-        if (is_class_code(node, code)) {
-            code_class = node;
+    for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
+        if (is_class_code(*it, code)) {
+            code_class = *it;  // first hit from the base-most end
             break;
         }
     }
@@ -2333,10 +2333,23 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         return false;
     }
 
-    PyObject* __private_attrs__ = PyDict_GetItemString(data.attrs, "__private_attrs__");
-    if (!__private_attrs__) {
-        PyErr_SetString(PyExc_TypeError, "'__private_attrs__' is needed for type 'PrivateAttrType'");
-        return false;
+    PyObjectStorage __private_attrs__;
+    if (PyDict_ContainsString(data.attrs, "__private_attrs__")) {
+        __private_attrs__ = PyDict_GetItemString(data.attrs, "__private_attrs__");
+    }
+    else {
+        __private_attrs__ = PyTuple_New(0);
+        Py_DECREF(__private_attrs__);
+    }
+
+    if (PyUnicode_Check(__private_attrs__)) {
+        PyObject* new___private_attrs__ = PyTuple_New(1);
+        if (!new___private_attrs__) {
+            return false;
+        }
+        PyTuple_SET_ITEM(new___private_attrs__, 0, __private_attrs__);
+        __private_attrs__ = new___private_attrs__;
+        Py_DECREF(__private_attrs__);
     }
 
     if (!PySequence_Check(__private_attrs__)) {
@@ -2379,8 +2392,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
 
         for (const char** p = invalid_name; *p != NULL; p++) {
             if (strcmp(attr_str.c_str(), *p) == 0) {
-                std::string error_msg = "invalid attribute name: '" + std::string(*p) + "'";
-                PyErr_SetString(PyExc_TypeError, error_msg.c_str());
+                PyErr_Format(PyExc_TypeError, "Invalid name '%s' in '__private_attrs__'", attr_str.c_str());
                 return false;
             }
         }
@@ -2421,7 +2433,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
                 }
                 slot_seq = keys;
             } else {
-                slot_seq = PySequence_Fast(all_slots, "__slots__ must be a sequence");
+                slot_seq = PySequence_Fast(all_slots, "__slots__ must be a string, dict or sequence");
             }
             if (!slot_seq) {
                 return false;
@@ -2433,9 +2445,9 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
                 PyObject* slot = PySequence_Fast_GET_ITEM(slot_seq, j);
                 if (PyUnicode_Check(slot)) {
                     const char* slot_cstr = PyUnicode_AsUTF8(slot);
-                    if (data.private_attrs_vector_string.find((std::string)slot_cstr) != data.private_attrs_vector_string.end()){
-                        std::string error_msg = "'__slots__' and '__private_attrs__' cannot have the same attribute name: '" + std::string(slot_cstr) + "'";
-                        PyErr_SetString(PyExc_TypeError, error_msg.c_str());
+                    std::string final_name = real_class_name(slot_cstr, data.class_name);
+                    if (data.private_attrs_vector_string.find(final_name) != data.private_attrs_vector_string.end()){
+                        PyErr_Format(PyExc_TypeError, "'__slots__' and '__private_attrs__' cannot have the same attribute name: '%s'", final_name.c_str());
                         Py_DECREF(slot_seq);
                         return false;
                     }

{private_attribute_cpp-2.1.2 → private_attribute_cpp-2.1.4}/private_attribute.pyi

@@ -15,12 +15,12 @@ class MyClass(PrivateAttrBase):
         return self._private_attr1
 ```
 """
-from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic
+from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic, Optional
 from types import FunctionType
 
 # define the dict that must have a key "__private_attrs__" and value must be the sequence of strings
 class _PrivateAttrDict(TypedDict):
-    __private_attrs__: Sequence[str]
+    __private_attrs__: Optional[Sequence[str]]
 
 _T = TypeVar('T')
 

{private_attribute_cpp-2.1.2 → private_attribute_cpp-2.1.4/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.2
+Version: 2.1.4
 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
@@ -75,7 +75,7 @@ print(obj.expensive_api_call(10))   # works with all decorators applied
 | 1 | PrivateWrapProxy | Decorator wrapper for arbitrary decorators | When needed |
 | 2 | private_func=callable | Custom hidden-name generator | Optional |
 | 3 | Pass private_func in class definition | Same as above | Optional |
-| 4 | \_\_private_attrs\_\_ list | Declare which attributes are private | Yes |
+| 4 | \_\_private_attrs\_\_ list | Declare which attributes are private | Optional (changed in 2.1.4) |
 | 5 | @PrivateWrapProxy(...) | Make any decorator compatible with private attributes | When needed |
 | 6 | method.result.xxx chain + dummy wrap | Fix decorator order and name conflicts | When needed |
 
@@ -240,8 +240,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 
 ## Notes
 
-- All of the private attributes class must contain the `__private_attrs__` attribute.
-- The `__private_attrs__` attribute must be a sequence of strings.
+- ~~All of the private attributes class must contain the `__private_attrs__` attribute.~~(changed in 2.1.4)
+- The `__private_attrs__` attribute must be a sequence of strings or just one string.
 - You cannot define the name which in `__slots__` to `__private_attrs__`.
 - When you define `__slots__` and `__private_attrs__` in one class, the attributes in `__private_attrs__` can also be defined in the methods, even though they are not in `__slots__`.
 - All of the object that is the instance of the class "PrivateAttrBase" or its subclass are default to be unable to be pickled.
@@ -266,4 +266,4 @@ This package require the c++ module "[picosha2](https://github.com/okdshin/PicoS
 
 ## Support
 
-Now it doesn't support "PyPy".
+Now it only support Cpython.

{private_attribute_cpp-2.1.2 → private_attribute_cpp-2.1.4}/private_attribute_cpp.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ private_attribute_cpp.egg-info/SOURCES.txt
 private_attribute_cpp.egg-info/dependency_links.txt
 private_attribute_cpp.egg-info/not-zip-safe
 private_attribute_cpp.egg-info/top_level.txt
+tests/test_attr_classify_owner.py
 tests/test_class_private_attrs.py
 tests/test_private_abc.py
 tests/test_private_attrs.py

{private_attribute_cpp-2.1.2 → private_attribute_cpp-2.1.4}/setup.py

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

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