private-attribute-cpp 1.4.4__tar.gz → 1.4.6__tar.gz

{private_attribute_cpp-1.4.4/private_attribute_cpp.egg-info → private_attribute_cpp-1.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.4
+Version: 1.4.6
 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,7 +250,8 @@ 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__`.
 - 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 support weakref.
+- `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.
 
 ## License
 

{private_attribute_cpp-1.4.4 → private_attribute_cpp-1.4.6}/README.md

@@ -231,7 +231,8 @@ 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__`.
 - 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 support weakref.
+- `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.
 
 ## License
 

{private_attribute_cpp-1.4.4 → private_attribute_cpp-1.4.6}/private_attribute.cpp

@@ -21,7 +21,7 @@
 #include <memory>
 #include <algorithm>
 
-// python under 3.13 doesn't has PyDict_ContainsString, so we implement it ourselves
+// python under 3.13 doesn't have PyDict_ContainsString, so we implement it ourselves
 #if PY_VERSION_HEX < 0x030D0000
 static int
 PyDict_ContainsString(PyObject *op, const char *key)
@@ -2127,6 +2127,11 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         return (uintptr_t)0;
     };
 
+    // forbidden to have "__static_attributes__" in attrs, because it exposes the private attributes name.
+    if (PyDict_ContainsString(data.attrs_copy, "__static_attributes__")) {
+        PyDict_DelItemString(data.attrs_copy, "__static_attributes__");
+    }
+
     {
         Py_ssize_t pos = 0;
         PyObject* key, *value;
@@ -2335,6 +2340,10 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data)
 
     PyTypeObject* type_instance = (PyTypeObject*)new_type;
     uintptr_t type_id = (uintptr_t)(type_instance);
+    if (PyDict_ContainsString(type_instance->tp_dict, "__static_attributes__")) {
+        PyErr_SetString(PyExc_SystemError, "'__static_attributes__' will expose private attribute names and cannot be used in private attribute types");
+        return false;
+    }
 
     ensure_tp(type_instance);
     if (PyDict_ContainsString(type_instance->tp_dict, "__getattribute__") || PyDict_ContainsString(type_instance->tp_dict, "__getattr__")) {
@@ -2441,12 +2450,6 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data)
         }
     }
 
-    // Python >= 3.13, delete the attr "__static_attributes__"
-#if PY_VERSION_HEX >= 0x030D0000
-    PyDict_DelItemString(type_instance->tp_dict, "__static_attributes__");
-    PyErr_Clear();
-#endif
-
     return true;
 }
 
@@ -2808,6 +2811,7 @@ create_private_attr_base_simple(void)
     PyDict_SetItemString(dict, "__private_attrs__", private_attrs);
     PyDict_SetItemString(dict, "__slots__", private_attrs);
     PyDict_SetItemString(dict, "__doc__", PyUnicode_FromString(PrivateAttrBase_doc));
+    PyDict_SetItemString(dict, "__module__", PyUnicode_FromString("private_attribute"));
     PyObject *args = PyTuple_Pack(3, name, bases, dict);
     PyObject* base_type;
     if (args) {
@@ -2825,8 +2829,6 @@ create_private_attr_base_simple(void)
     if (!base_type) {
         return NULL;
     }
-    // set "__module__"
-    PyType_Type.tp_setattro(base_type, PyUnicode_FromString("__module__"), PyUnicode_FromString("private_attribute"));
     ((PyTypeObject*)base_type)->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
     return base_type;
 }

{private_attribute_cpp-1.4.4 → private_attribute_cpp-1.4.6}/private_attribute.pyi

@@ -71,7 +71,7 @@ class PrivateWrapProxy:
     ```
     """
     def __init__(self, decorator: Callable[[_TVar], _T], orig: _PrivateWrap[Any]|None = None, /) -> None: ...
-    def __call__(self, func: _TVar, /) -> _PrivateWrap[_T]: ...
+    def __call__(self, func: _TVar | _PrivateWrap[_TVar], /) -> _PrivateWrap[_T]: ...
 
 class PrivateAttrType(type):
     "metaclass for private attributes"

{private_attribute_cpp-1.4.4 → private_attribute_cpp-1.4.6/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.4
+Version: 1.4.6
 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,7 +250,8 @@ 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__`.
 - 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 support weakref.
+- `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.
 
 ## License
 

{private_attribute_cpp-1.4.4 → private_attribute_cpp-1.4.6}/private_attribute_cpp.egg-info/SOURCES.txt

@@ -9,4 +9,11 @@ private_attribute_cpp.egg-info/PKG-INFO
 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
+private_attribute_cpp.egg-info/top_level.txt
+tests/test_class_private_attrs.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

{private_attribute_cpp-1.4.4 → private_attribute_cpp-1.4.6}/setup.py

@@ -1,6 +1,5 @@
 from setuptools import setup, Extension
 import sys
-import sysconfig
 
 if sys.platform == "win32":
     extra_compile_args = ['/std:c++17']
@@ -19,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='1.4.4',
+    version='1.4.6',
     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-1.4.6/tests/test_class_private_attrs.py

@@ -0,0 +1,23 @@
+import private_attribute
+import unittest
+
+class MyClass(private_attribute.PrivateAttrBase):
+    __private_attrs__ = ["_secret"]
+    _secret = 1
+
+    @classmethod
+    def get_secret(cls):
+        return cls._secret
+
+class TestClassPrivateAttrs(unittest.TestCase):
+    def test_class_private_attrs(self):
+        self.assertEqual(MyClass.get_secret(), 1)
+        with self.assertRaises(AttributeError):
+            MyClass._secret = 2
+        a = MyClass()
+        with self.assertRaises(AttributeError):
+            a._secret = 2
+        self.assertEqual(a.get_secret(), 1)
+
+if __name__ == "__main__":
+    unittest.main()

private_attribute_cpp-1.4.6/tests/test_private_abc.py

@@ -0,0 +1,55 @@
+from abc import ABCMeta, abstractmethod, ABC
+import private_attribute
+import unittest
+
+
+class PrivateAbcMeta(ABCMeta):
+    def __new__(cls, *args, **kwargs):
+        temp = private_attribute.prepare(*args, **kwargs)
+        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+        private_attribute.postprocess(typ, temp)
+        return typ
+
+
+private_attribute.register_metaclass(PrivateAbcMeta)
+
+class MyClass(ABC, metaclass=PrivateAbcMeta):
+    __private_attrs__ = ["_secret1"]
+    _secret1 = 10
+
+    @classmethod
+    def get_secret1(cls):
+        return cls._secret1
+
+    @abstractmethod
+    def public_method(self):
+        pass
+
+class ConcreteClass(MyClass):
+    __private_attrs__ = ["_secret2"]
+
+    def __init__(self, secret1, secret2):
+        self._secret1 = secret1
+        self._secret2 = secret2
+
+    def public_method(self):
+        return self._secret1, self._secret2
+
+
+class TestPrivateAbc(unittest.TestCase):
+    def test_private_abc(self):
+        c = ConcreteClass("secret1", "secret2")
+        self.assertEqual(c.public_method(), ("secret1", "secret2"))
+        with self.assertRaises(AttributeError):
+            c._secret1
+        with self.assertRaises(AttributeError):
+            c._secret2
+        with self.assertRaises(TypeError):
+            MyClass()
+        with self.assertRaises(AttributeError):
+            MyClass._secret1
+        self.assertEqual(MyClass.get_secret1(), 10)
+        self.assertEqual(ConcreteClass.get_secret1(), 10)
+
+if __name__ == '__main__':
+    unittest.main()

private_attribute_cpp-1.4.6/tests/test_private_attrs.py

@@ -0,0 +1,51 @@
+import private_attribute
+import unittest
+
+class BaseClass(private_attribute.PrivateAttrBase):
+    __private_attrs__ = ["_a", "_b"]
+    __slots__ = ["c", "d"]
+
+    def __init__(self, a, b, c, d):
+        self._a = a
+        self._b = b
+        self.c = c
+        self.d = d
+
+    @property
+    def a(self):
+        return self._a
+
+    @property
+    def b(self):
+        return self._b
+
+    def public_has_a(self):
+        return hasattr(self, "_a")
+
+    def public_has_b(self):
+        return hasattr(self, "_b")
+
+class TestPrivateAttributes(unittest.TestCase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.base_obj = BaseClass(1, 2, 3, 4)
+
+    def test_private_attrs(self):
+        self.assertTrue(self.base_obj.public_has_a())
+        self.assertTrue(self.base_obj.public_has_b())
+        self.assertEqual(self.base_obj.a, 1)
+        self.assertEqual(self.base_obj.b, 2)
+        self.assertEqual(self.base_obj.c, 3)
+        self.assertEqual(self.base_obj.d, 4)
+        self.assertFalse(hasattr(self.base_obj, "_a"))
+        self.assertFalse(hasattr(self.base_obj, "_b"))
+        with self.assertRaises(AttributeError):
+            self.base_obj._a
+        with self.assertRaises(AttributeError):
+            self.base_obj._b
+        self.assertTrue(isinstance(self.base_obj.__private_attrs__, tuple))
+        for i in self.base_obj.__private_attrs__:
+            self.assertTrue(isinstance(i, tuple))
+
+if __name__ == "__main__":
+    unittest.main()

private_attribute_cpp-1.4.6/tests/test_private_func.py

@@ -0,0 +1,27 @@
+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-1.4.6/tests/test_private_inheritance.py

@@ -0,0 +1,40 @@
+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()

private_attribute_cpp-1.4.6/tests/test_private_method.py

@@ -0,0 +1,30 @@
+import private_attribute
+import unittest
+
+class PrivateMethodClass(private_attribute.PrivateAttrBase):
+    __private_attrs__ = ["_secret_method", "_a"]
+    __slots__ = ["public_attr"]
+
+    def __init__(self, a):
+        self._a = a
+        self.public_attr = "public_value"
+
+    def _secret_method(self):
+        return self._a
+
+    def public_method(self):
+        return self._secret_method()
+
+
+class TestPrivateMethod(unittest.TestCase):
+    def test_private_method(self):
+        obj = PrivateMethodClass(1)
+        self.assertEqual(obj.public_method(), 1)
+        with self.assertRaises(AttributeError):
+            obj._secret_method()
+
+        with self.assertRaises(AttributeError):
+            obj._a
+
+if __name__ == "__main__":
+    unittest.main()

private_attribute_cpp-1.4.6/tests/test_private_wrap.py

@@ -0,0 +1,55 @@
+import private_attribute
+import unittest
+
+class MyWrap:
+    def __init__(self, func):
+        self.func1 = func
+        self.index = 1
+
+    def add(self, func):
+        self.index += 1
+        setattr(self, f"func{self.index}", func)
+        return self
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        def wrapper(index, *args, **kwargs):
+            func = getattr(self, f"func{index}")
+            return func.__get__(instance, owner)(*args, **kwargs)
+        return wrapper
+
+class MyClass(private_attribute.PrivateAttrBase):
+    __private_attrs__ = ["_secret1", "_secret2", "_secret3"]
+    def __init__(self, secret1, secret2, secret3):
+        self._secret1 = secret1
+        self._secret2 = secret2
+        self._secret3 = secret3
+
+    @private_attribute.PrivateWrapProxy(MyWrap)
+    def get_secret(self):
+        return self._secret1
+
+    @private_attribute.PrivateWrapProxy(get_secret.result.add, get_secret)
+    def get_secret(self):
+        return self._secret2
+
+    @private_attribute.PrivateWrapProxy(get_secret.result.add, get_secret)
+    def get_secret(self):
+        return self._secret3
+
+class TestPrivateWrap(unittest.TestCase):
+    def test_private_wrap(self):
+        a = MyClass(1, 2, 3)
+        self.assertEqual(a.get_secret(1), 1)
+        self.assertEqual(a.get_secret(2), 2)
+        self.assertEqual(a.get_secret(3), 3)
+        with self.assertRaises(AttributeError):
+            a._secret1
+        with self.assertRaises(AttributeError):
+            a._secret2
+        with self.assertRaises(AttributeError):
+            a._secret3
+
+if __name__ == "__main__":
+    unittest.main()