private-attribute-cpp 1.4.3__tar.gz → 1.4.5__tar.gz

{private_attribute_cpp-1.4.3/private_attribute_cpp.egg-info → private_attribute_cpp-1.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.3
+Version: 1.4.5
 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

{private_attribute_cpp-1.4.3 → private_attribute_cpp-1.4.5}/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)
@@ -231,7 +231,7 @@ generate_private_attr_name(uintptr_t obj_id, const std::string& attr_name)
     "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
 
     std::uniform_int_distribution<long long> dist(0, printable_chars.size() - 1);
-    
+
     auto generate_random_ascii = [&](int length) {
         std::string result;
         for(int i = 0; i < length; i++) {
@@ -2440,7 +2440,13 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data)
             analyse_all_code(original_value, ::AllData::type_allowed_code_map[type_id], set);
         }
     }
-    
+
+    // 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;
 }
 
@@ -3206,7 +3212,7 @@ static PyMethodDef PrivateModule_methods[] = {
 static PyTypeObject PrivateModuleType = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "private_attribute_module", //tp_name
-    PyModule_Type.tp_basicsize + 8, //tp_basicsize   size of module object + 8 bytes for flag to avoid change attribute '__class__'
+    PyModule_Type.tp_basicsize + 8, //tp_basicsize   size of module object + 8 bytes for basicsize to avoid changing attribute '__class__'
     0, //tp_itemsize
     0, //tp_dealloc
     0, //tp_print
@@ -3279,14 +3285,38 @@ PyInit_private_attribute(void)
         PyType_Ready(&PrivateTempType) < 0) {
         return NULL;
     }
-
+    PyObject* all = PyList_New(0);
+    if (!all) {
+        return NULL;
+    }
     PyObject* m = PyModule_Create(&def);
     if (!m) {
+        Py_DECREF(all);
         return NULL;
     }
 #ifdef Py_GIL_DISABLED
     PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
 #endif
+
+    PyModule_AddObject(m, "__all__", all);
+    /* all contains:
+     * PrivateWrapProxy
+     * PrivateAttrType
+     * PrivateAttrBase
+     * prepare
+     * postprocess
+     * register_metaclass
+     * ensure_type
+     * ensure_metaclass
+     */
+    PyList_Append(all, PyUnicode_FromString("PrivateWrapProxy"));
+    PyList_Append(all, PyUnicode_FromString("PrivateAttrType"));
+    PyList_Append(all, PyUnicode_FromString("PrivateAttrBase"));
+    PyList_Append(all, PyUnicode_FromString("prepare"));
+    PyList_Append(all, PyUnicode_FromString("postprocess"));
+    PyList_Append(all, PyUnicode_FromString("register_metaclass"));
+    PyList_Append(all, PyUnicode_FromString("ensure_type"));
+    PyList_Append(all, PyUnicode_FromString("ensure_metaclass"));
     Py_SET_TYPE(m, &PrivateModuleType);
     return m;
 }

{private_attribute_cpp-1.4.3 → private_attribute_cpp-1.4.5}/private_attribute.pyi

@@ -19,14 +19,14 @@ from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic
 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):
+class _PrivateAttrDict(TypedDict):
     __private_attrs__: Sequence[str]
 
-T = TypeVar('T')
+_T = TypeVar('T')
 
-class _PrivateWrap(Generic[T]):
+class _PrivateWrap(Generic[_T]):
     @property
-    def result(self) -> T:
+    def result(self) -> _T:
         "the final result of decorating"
         ...
 
@@ -38,7 +38,7 @@ class _PrivateWrap(Generic[T]):
     def __getattr__(self, name: str) -> Any:
         return getattr(self.result, name)
 
-TVar = TypeVar('TVar')
+_TVar = TypeVar('TVar')
 
 class PrivateWrapProxy:
     """
@@ -70,13 +70,13 @@ class PrivateWrapProxy:
         def my_method(self): ...
     ```
     """
-    def __init__(self, decorator: Callable[[TVar], T], orig: _PrivateWrap[Any]|None = None, /) -> None: ...
-    def __call__(self, func: TVar, /) -> _PrivateWrap[T]: ...
+    def __init__(self, decorator: Callable[[_TVar], _T], orig: _PrivateWrap[Any]|None = None, /) -> None: ...
+    def __call__(self, func: _TVar, /) -> _PrivateWrap[_T]: ...
 
 class PrivateAttrType(type):
     "metaclass for private attributes"
     def __new__(cls, name: str, bases: tuple,
-                attrs: PrivateAttrDict, /,
+                attrs: _PrivateAttrDict, /,
                 private_func: Callable[[int, str], str]|None = None) -> PrivateAttrType: ...
 
 class PrivateAttrBase(metaclass=PrivateAttrType):
@@ -95,7 +95,7 @@ class _PrivateTemp:
     @property
     def kwds(self) -> dict[str, Any]: ...
 
-def prepare(name: str, bases: tuple, attrs: PrivateAttrDict, /, **kwds) -> _PrivateTemp:
+def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _PrivateTemp:
     """
     function for custom metaclass to create private attributes class.
 

{private_attribute_cpp-1.4.3 → private_attribute_cpp-1.4.5/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.3
+Version: 1.4.5
 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

{private_attribute_cpp-1.4.3 → private_attribute_cpp-1.4.5}/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.3 → private_attribute_cpp-1.4.5}/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.3',
+    version='1.4.5',
     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.5/tests/test_class_private_attrs.py

@@ -0,0 +1,22 @@
+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.5/tests/test_private_abc.py

@@ -0,0 +1,53 @@
+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.5/tests/test_private_attrs.py

@@ -0,0 +1,50 @@
+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.5/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.5/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.5/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.5/tests/test_private_wrap.py

@@ -0,0 +1,51 @@
+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, index, instance, owner):
+        func =  getattr(self, f"func{index}")
+        return func.__get__(instance, owner)
+
+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.get(1, a, MyClass)(), 1)
+        self.assertEqual(a.get_secret.get(2, a, MyClass)(), 2)
+        self.assertEqual(a.get_secret.get(3, a, MyClass)(), 3)
+        with self.assertRaises(AttributeError):
+            a._secret1
+        with self.assertRaises(AttributeError):
+            a._secret2
+        with self.assertRaises(AttributeError):
+            a._secret3
+
+if __name__ == "__main__":
+    unittest.main()