private-attribute-cpp 1.4.10__tar.gz → 1.4.11__tar.gz

{private_attribute_cpp-1.4.10/private_attribute_cpp.egg-info → private_attribute_cpp-1.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.10
+Version: 1.4.11
 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
@@ -247,6 +247,7 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - All of the object that is the instance of the class "PrivateAttrBase" or its subclass are default to be unable to be pickled.
 - Finally the attributes' names in `__private_attrs__` will be change to a tuple with two hash.
 - Finally the `_PrivateWrap` object will be recoveried to the original object.
+- Don't use a decorator which will return the `_PrivateWrap` in `PrivateWrapProxy` which will raise `TypeError`.
 - 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_cpp-1.4.10 → private_attribute_cpp-1.4.11}/README.md

@@ -228,6 +228,7 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - All of the object that is the instance of the class "PrivateAttrBase" or its subclass are default to be unable to be pickled.
 - Finally the attributes' names in `__private_attrs__` will be change to a tuple with two hash.
 - Finally the `_PrivateWrap` object will be recoveried to the original object.
+- Don't use a decorator which will return the `_PrivateWrap` in `PrivateWrapProxy` which will raise `TypeError`.
 - 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_cpp-1.4.10 → private_attribute_cpp-1.4.11}/private_attribute.cpp

@@ -271,10 +271,7 @@ default_random_string(uintptr_t obj_id, const std::string& attr_name) noexcept
                 result = it->second;
                 return result;
             }
-            while (true) {
-                if (::AllData::all_exist_name.find(result) == ::AllData::all_exist_name.end()) {
-                    break;
-                }
+            while (::AllData::all_exist_name.find(result) != ::AllData::all_exist_name.end()) {
                 result = original_result + "_" + std::to_string(i);
                 i++;
             }
@@ -372,10 +369,7 @@ custom_random_string(uintptr_t obj_id, const std::string& attr_name, PyObject* f
                     result = it->second;
                     return result;
                 }
-                while (true) {
-                    if (::AllData::all_exist_name.find(result) == ::AllData::all_exist_name.end()) {
-                        break;
-                    }
+                while (::AllData::all_exist_name.find(result) != ::AllData::all_exist_name.end()) {
                     result = original_result + "_" + std::to_string(i);
                     i++;
                 }
@@ -883,17 +877,11 @@ static PrivateWrapObject* PrivateWrap_New(PyObject *decorator, PyObject *func, P
 static void PrivateWrap_dealloc(PrivateWrapObject *self) noexcept;
 static PyObject* PrivateWrap_call(PrivateWrapObject *self, PyObject *args, PyObject *kw) noexcept;
 
-static PyObject *
-PrivateWrap_result(PyObject *obj, void* /*closure*/) noexcept
-{
-    if (!obj) {
-        Py_RETURN_NONE;
-    }
-
-    PyObject *res = ((PrivateWrapObject*)obj)->result;
-    Py_INCREF(res);
-    return res;
-}
+static PyMemberDef PrivateWrap_members[] = {
+    {"result", T_OBJECT, offsetof(PrivateWrapObject, result), READONLY, "The result object"},
+    {"__wrapped__", T_OBJECT, offsetof(PrivateWrapObject, result), READONLY, "The result object"},
+    {NULL}
+};
 
 static PyObject *
 PrivateWrap_funcs(PyObject *obj, void* /*closure*/) noexcept
@@ -995,9 +983,7 @@ static const char* PrivateWrap_result_doc = "the final result of decorating";
 static const char* PrivateWrap_funcs_doc = "the original functions";
 
 static PyGetSetDef PrivateWrap_getset[] = {
-    {"result", (getter)PrivateWrap_result, NULL, PrivateWrap_result_doc, NULL},
     {"funcs", (getter)PrivateWrap_funcs, NULL, PrivateWrap_funcs_doc, NULL},
-    {"__wrapped__", (getter)PrivateWrap_result, NULL, NULL, NULL},
     {"__doc__", (getter)PrivateWrap_doc, NULL, NULL, NULL},
     {"__module__", (getter)PrivateWrap_module, NULL, NULL, NULL},
     {"__name__", (getter)PrivateWarp_name, NULL, NULL, NULL},
@@ -1050,21 +1036,25 @@ static PyTypeObject PrivateWrapType = {
     0,                                 // tp_iter
     0,                                 // tp_iternext
     0,                                 // tp_methods
-    0,                                 // tp_members
+    PrivateWrap_members,               // tp_members
     PrivateWrap_getset,                // tp_getset
 };
 
 static PrivateWrapObject*
 PrivateWrap_New(PyObject *decorator, PyObject *func, PyObject *list) noexcept
 {
-    PrivateWrapObject *self =
-        PyObject_New(PrivateWrapObject, &PrivateWrapType);
     PyObject *wrapped = PyObject_CallFunctionObjArgs(decorator, func, NULL);
     if (!wrapped) {
-        Py_DECREF(self);
+        return NULL;
+    }
+    if (PyObject_TypeCheck(wrapped, &PrivateWrapType)) {
+        PyErr_SetString(PyExc_TypeError, "decorator returned a '_PrivateWrap' object which is not allowed");
+        Py_DECREF(wrapped);
         return NULL;
     }
 
+    PrivateWrapObject *self =
+        PyObject_New(PrivateWrapObject, &PrivateWrapType);
     self->func_list = list;
     Py_INCREF(list);
 

{private_attribute_cpp-1.4.10 → private_attribute_cpp-1.4.11}/private_attribute.pyi

@@ -76,7 +76,7 @@ class PrivateWrapProxy:
 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):

{private_attribute_cpp-1.4.10 → private_attribute_cpp-1.4.11/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.10
+Version: 1.4.11
 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
@@ -247,6 +247,7 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - All of the object that is the instance of the class "PrivateAttrBase" or its subclass are default to be unable to be pickled.
 - Finally the attributes' names in `__private_attrs__` will be change to a tuple with two hash.
 - Finally the `_PrivateWrap` object will be recoveried to the original object.
+- Don't use a decorator which will return the `_PrivateWrap` in `PrivateWrapProxy` which will raise `TypeError`.
 - 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_cpp-1.4.10 → private_attribute_cpp-1.4.11}/setup.py

@@ -18,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='1.4.10',
+    version='1.4.11',
     author="HuangHaoHua",
     author_email="13140752715@example.com",
     description='A Python package that provides a way to define private attributes in C++ implementation.',