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

{private_attribute_cpp-1.4.4/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.4
+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.4 → 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)

{private_attribute_cpp-1.4.4 → 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.4
+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.4 → 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.4 → 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.4',
+    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()