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

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

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

@@ -57,7 +57,7 @@ private:
     std::string attr_onehash;
     std::string another_string_hash;
 public:
-    AllPyobjectAttrCacheKey(uintptr_t obj_id, std::string attr_name) : obj_id(obj_id) {
+    AllPyobjectAttrCacheKey(uintptr_t obj_id, const std::string& attr_name) : obj_id(obj_id) {
         std::string one_name = "_" + std::to_string(obj_id) + "_" + attr_name;
         std::string another_name = "_" + module_running_time_string + attr_name;
         picosha2::hash256_hex_string(one_name, attr_onehash);
@@ -82,7 +82,7 @@ private:
     std::string first;
     std::string second;
 public:
-    TwoStringTuple(std::string first, std::string second) : first(first), second(second) {}
+    TwoStringTuple(const std::string& first, const std::string& second) : first(first), second(second) {}
     bool operator==(const TwoStringTuple& other) const {
         return this->first == other.first && this->second == other.second;
     }
@@ -162,11 +162,11 @@ struct FinalObject
     }
 };
 
-static TwoStringTuple get_string_hash_tuple2(std::string name);
+static TwoStringTuple get_string_hash_tuple2(const std::string& name);
 static PyCodeObject* get_now_code();
-static uintptr_t type_set_attr_long_long_guidance(uintptr_t type, std::string name);
-static bool type_private_attr(uintptr_t type, std::string name);
-static FinalObject type_get_final_attr(uintptr_t type_id, std::string name);
+static uintptr_t type_set_attr_long_long_guidance(uintptr_t type, const std::string& name);
+static bool type_private_attr(uintptr_t type, const std::string& name);
+static FinalObject type_get_final_attr(uintptr_t type_id, const std::string& name);
 
 static bool
 is_class_code(uintptr_t typ_id, PyCodeObject* code)
@@ -182,7 +182,7 @@ is_class_code(uintptr_t typ_id, PyCodeObject* code)
 }
 
 static bool
-is_type_private(uintptr_t typ_id, std::string name)
+is_type_private(uintptr_t typ_id, const std::string& name)
 {
     if (::AllData::all_type_attr_set.find(typ_id) != ::AllData::all_type_attr_set.end()){
         auto& attr_set = ::AllData::all_type_attr_set[typ_id];
@@ -195,7 +195,7 @@ is_type_private(uintptr_t typ_id, std::string name)
 }
 
 static bool
-attr_classify(uintptr_t typ_id, std::string name, PyCodeObject* code)
+attr_classify(uintptr_t typ_id, const std::string& name, PyCodeObject* code)
 {
     if (is_class_code(typ_id, code)) {
         return true;
@@ -248,7 +248,7 @@ generate_private_attr_name(uintptr_t obj_id, const std::string& attr_name)
 }
 
 static std::string
-default_random_string(uintptr_t obj_id, std::string attr_name)
+default_random_string(uintptr_t obj_id, const std::string& attr_name)
 {
     AllPyobjectAttrCacheKey key(obj_id, attr_name);
     std::string result;
@@ -262,7 +262,7 @@ default_random_string(uintptr_t obj_id, std::string attr_name)
             lock.unlock();
             result = generate_private_attr_name(obj_id, attr_name);
             std::string original_result = result;
-            int i = 1;
+            unsigned long long i = 1;
             std::unique_lock<std::shared_mutex> lock2(::AllData::cache_mutex);
             auto it = ::AllData::cache.find(key); // twice check
             if (it != ::AllData::cache.end()) {
@@ -333,7 +333,7 @@ private:
 };
 
 static std::string
-custom_random_string(uintptr_t obj_id, std::string attr_name, PyObject* func)
+custom_random_string(uintptr_t obj_id, const std::string& attr_name, PyObject* func)
 {
     AllPyobjectAttrCacheKey key(obj_id, attr_name);
     std::string result;
@@ -363,7 +363,7 @@ custom_random_string(uintptr_t obj_id, std::string attr_name, PyObject* func)
                 result = PyUnicode_AsUTF8(python_result);
                 Py_DECREF(python_result);
                 std::string original_result = result;
-                int i = 1;
+                unsigned long long i = 1;
                 std::unique_lock<std::shared_mutex> lock2(::AllData::cache_mutex);
                 auto it = ::AllData::cache.find(key); // twice check
                 if (it != ::AllData::cache.end()) {
@@ -426,7 +426,7 @@ static void ensure_tp(PyTypeObject* type_instance);
 static void ensure_subclass_tp(PyTypeObject* type_instance);
 
 static PyObject*
-id_getattr(std::string attr_name, PyObject* obj, PyObject* typ)
+id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ)
 {
     uintptr_t obj_id, typ_id, final_id;
     obj_id = (uintptr_t) obj;
@@ -533,7 +533,7 @@ id_getattr(std::string attr_name, PyObject* obj, PyObject* typ)
 }
 
 static PyObject*
-type_getattr(PyObject* typ, std::string attr_name)
+type_getattr(PyObject* typ, const std::string& attr_name)
 {
     uintptr_t typ_id = (uintptr_t)typ;
     FinalObject final_object = type_get_final_attr(typ_id, attr_name);
@@ -567,7 +567,7 @@ type_getattr(PyObject* typ, std::string attr_name)
 }
 
 static int
-id_setattr(std::string attr_name, PyObject* obj, PyObject* typ, PyObject* value)
+id_setattr(const std::string& attr_name, PyObject* obj, PyObject* typ, PyObject* value)
 {
     uintptr_t obj_id, typ_id, final_id;
     obj_id = (uintptr_t) obj;
@@ -636,10 +636,10 @@ id_setattr(std::string attr_name, PyObject* obj, PyObject* typ, PyObject* value)
     return 0;
 }
 
-static int type_delattr(PyObject* typ, std::string attr_name);
+static int type_delattr(PyObject* typ, const std::string& attr_name);
 
 static int
-type_setattr(PyObject* typ, std::string attr_name, PyObject* value)
+type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value)
 {
     if (!value) {
         return type_delattr(typ, attr_name);
@@ -711,7 +711,7 @@ type_setattr(PyObject* typ, std::string attr_name, PyObject* value)
 }
 
 static int
-id_delattr(std::string attr_name, PyObject* obj, PyObject* typ)
+id_delattr(const std::string& attr_name, PyObject* obj, PyObject* typ)
 {
     uintptr_t obj_id, typ_id, final_id;
     obj_id = (uintptr_t) obj;
@@ -789,7 +789,7 @@ id_delattr(std::string attr_name, PyObject* obj, PyObject* typ)
 }
 
 static int
-type_delattr(PyObject* typ, std::string attr_name)
+type_delattr(PyObject* typ, const std::string& attr_name)
 {
     uintptr_t typ_id = (uintptr_t) typ;
     uintptr_t final_id = type_set_attr_long_long_guidance(typ_id, attr_name);
@@ -1438,7 +1438,7 @@ static PyTypeObject PrivateAttrType = {
 };
 
 static PyObject*
-get_string_hash_tuple(std::string name)
+get_string_hash_tuple(const std::string& name)
 {
     std::string name1;
     std::string name2;
@@ -1452,7 +1452,7 @@ get_string_hash_tuple(std::string name)
 }
 
 static TwoStringTuple
-get_string_hash_tuple2(std::string name)
+get_string_hash_tuple2(const std::string& name)
 {
     std::string name1;
     std::string name2;
@@ -1466,7 +1466,7 @@ get_string_hash_tuple2(std::string name)
 }
 
 static FinalObject
-type_get_final_attr(uintptr_t type_id, std::string name)
+type_get_final_attr(uintptr_t type_id, const std::string& name)
 {
     TwoStringTuple hash_tuple = get_string_hash_tuple2(name);
     if (::AllData::all_type_attr_set.find(type_id) != ::AllData::all_type_attr_set.end()) {
@@ -1580,7 +1580,7 @@ type_get_final_attr(uintptr_t type_id, std::string name)
 }
 
 static uintptr_t
-type_set_attr_long_long_guidance(uintptr_t type_id, std::string name)
+type_set_attr_long_long_guidance(uintptr_t type_id, const std::string& name)
 {
     TwoStringTuple hash_tuple = get_string_hash_tuple2(name);
     if (::AllData::all_type_attr_set.find(type_id) != ::AllData::all_type_attr_set.end()) {
@@ -1602,7 +1602,7 @@ type_set_attr_long_long_guidance(uintptr_t type_id, std::string name)
 }
 
 static bool
-type_private_attr(uintptr_t type_id, std::string name)
+type_private_attr(uintptr_t type_id, const std::string& name)
 {
     TwoStringTuple hash_tuple = get_string_hash_tuple2(name);
     if (::AllData::all_type_attr_set.find(type_id) != ::AllData::all_type_attr_set.end()) {
@@ -1722,7 +1722,7 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyCodeObject*>& ma
 }
 
 static std::string
-real_class_name(std::string name, std::string class_name)
+real_class_name(const std::string& name, const std::string& class_name)
 {
     // if the name starts with "__" but does not end with "__", change to _ClassName__name
     if (name.length() >= 2 && name.substr(0, 2) == "__" && name.substr(name.length() - 2) != "__") {
@@ -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.5 → private_attribute_cpp-1.4.7}/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.5 → private_attribute_cpp-1.4.7/private_attribute_cpp.egg-info}/PKG-INFO

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

@@ -18,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='1.4.5',
+    version='1.4.7',
     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 → private_attribute_cpp-1.4.7}/tests/test_class_private_attrs.py

@@ -4,6 +4,7 @@ import unittest
 class MyClass(private_attribute.PrivateAttrBase):
     __private_attrs__ = ["_secret"]
     _secret = 1
+
     @classmethod
     def get_secret(cls):
         return cls._secret
@@ -19,4 +20,4 @@ class TestClassPrivateAttrs(unittest.TestCase):
         self.assertEqual(a.get_secret(), 1)
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()

{private_attribute_cpp-1.4.5 → private_attribute_cpp-1.4.7}/tests/test_private_abc.py

@@ -16,6 +16,7 @@ private_attribute.register_metaclass(PrivateAbcMeta)
 class MyClass(ABC, metaclass=PrivateAbcMeta):
     __private_attrs__ = ["_secret1"]
     _secret1 = 10
+
     @classmethod
     def get_secret1(cls):
         return cls._secret1
@@ -26,6 +27,7 @@ class MyClass(ABC, metaclass=PrivateAbcMeta):
 
 class ConcreteClass(MyClass):
     __private_attrs__ = ["_secret2"]
+
     def __init__(self, secret1, secret2):
         self._secret1 = secret1
         self._secret2 = secret2
@@ -50,4 +52,4 @@ class TestPrivateAbc(unittest.TestCase):
         self.assertEqual(ConcreteClass.get_secret1(), 10)
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

{private_attribute_cpp-1.4.5 → private_attribute_cpp-1.4.7}/tests/test_private_attrs.py

@@ -4,6 +4,7 @@ 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
@@ -47,4 +48,4 @@ class TestPrivateAttributes(unittest.TestCase):
             self.assertTrue(isinstance(i, tuple))
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()

{private_attribute_cpp-1.4.5 → private_attribute_cpp-1.4.7}/tests/test_private_func.py

@@ -24,4 +24,4 @@ class TestPrivateFunc(unittest.TestCase):
             obj._secret
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()

{private_attribute_cpp-1.4.5 → private_attribute_cpp-1.4.7}/tests/test_private_inheritance.py

@@ -37,4 +37,4 @@ class TestPrivateInheritance(unittest.TestCase):
             obj._other_value
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()

{private_attribute_cpp-1.4.5 → private_attribute_cpp-1.4.7}/tests/test_private_method.py

@@ -27,4 +27,4 @@ class TestPrivateMethod(unittest.TestCase):
             obj._a
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()

{private_attribute_cpp-1.4.5 → private_attribute_cpp-1.4.7}/tests/test_private_wrap.py

@@ -11,9 +11,13 @@ class MyWrap:
         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)
+    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"]
@@ -37,9 +41,9 @@ class MyClass(private_attribute.PrivateAttrBase):
 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)
+        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):
@@ -48,4 +52,4 @@ class TestPrivateWrap(unittest.TestCase):
             a._secret3
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()