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

{private_attribute_cpp-1.4.9/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.9
+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.9 → 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.9 → 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);
 
@@ -2891,8 +2881,7 @@ PrivateTempObject_kwds(PyObject* self, void* /*closure*/) noexcept
 {
     PyObject* kwds = ((PrivateTempObject*)self)->tmp->base_kwds;
     if (!kwds) {
-        PyErr_SetString(PyExc_RuntimeError, "object not init or have been used");
-        return nullptr;
+        return PyDict_New();
     }
     Py_INCREF(kwds);
     return kwds;
@@ -3141,14 +3130,14 @@ PrivateModule_dir(PyObject* self, PyObject* /*args*/) noexcept
         Py_DECREF(parent_dir);
         return NULL;
     }
-    PyList_Append(attr_list, PyUnicode_FromString("PrivateWrapProxy"));
-    PyList_Append(attr_list, PyUnicode_FromString("PrivateAttrType"));
-    PyList_Append(attr_list, PyUnicode_FromString("PrivateAttrBase"));
-    PyList_Append(attr_list, PyUnicode_FromString("prepare"));
-    PyList_Append(attr_list, PyUnicode_FromString("postprocess"));
-    PyList_Append(attr_list, PyUnicode_FromString("register_metaclass"));
-    PyList_Append(attr_list, PyUnicode_FromString("ensure_type"));
-    PyList_Append(attr_list, PyUnicode_FromString("ensure_metaclass"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("PrivateWrapProxy"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("PrivateAttrType"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("PrivateAttrBase"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("prepare"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("postprocess"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("register_metaclass"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("ensure_type"));
+    PyList_Append(attr_list, PyUnicode_InternFromString("ensure_metaclass"));
     PyObject* result = PySequence_Concat(parent_dir, attr_list);
     Py_DECREF(parent_dir);
     Py_DECREF(attr_list);
@@ -3168,13 +3157,6 @@ PrivateModule_setattro(PyObject* cls, PyObject* name, PyObject* value) noexcept
     return PyObject_GenericSetAttr(cls, name, value);
 }
 
-static PyGetSetDef PrivateModule_getsetters[] = {
-    {"PrivateWrapProxy", (getter)PrivateModule_get_PrivateWrapProxy, NULL, NULL, NULL},
-    {"PrivateAttrType", (getter)PrivateModule_get_PrivateAttrType, NULL, NULL, NULL},
-    {"PrivateAttrBase", (getter)PrivateModule_get_PrivateAttrBase, NULL, NULL, NULL},
-    {NULL}
-};
-
 static const char* prepare_and_postprocess_doc = R"(function for custom metaclass to create private attributes class.
 
 def prepare(name: str, bases: tuple, attrs: dict, **kwds) -> tempobject:
@@ -3214,7 +3196,6 @@ def ensure_metaclass(metaclass: type) -> None:
 )";
 
 static PyMethodDef PrivateModule_methods[] = {
-    {"__dir__", (PyCFunction)PrivateModule_dir, METH_NOARGS, NULL},
     {"prepare", (PyCFunction)prepare_for_PrivateAttr, METH_VARARGS | METH_KEYWORDS | METH_STATIC, prepare_and_postprocess_doc},
     {"postprocess", (PyCFunction)postprocess_for_PrivateAttr, METH_VARARGS | METH_STATIC, prepare_and_postprocess_doc},
     {"register_metaclass", (PyCFunction)register_metaclass, METH_O | METH_STATIC, prepare_and_postprocess_doc},
@@ -3223,6 +3204,53 @@ static PyMethodDef PrivateModule_methods[] = {
     {NULL}  // Sentinel
 };
 
+static PyObject*
+PrivateModule_get_prepare(PyObject* /*self*/, void* /*closure*/) noexcept
+{
+    return PyCFunction_NewEx(&PrivateModule_methods[0], NULL, NULL);
+}
+
+static PyObject*
+PrivateModule_get_postprocess(PyObject* /*self*/, void* /*closure*/) noexcept
+{
+    return PyCFunction_NewEx(&PrivateModule_methods[1], NULL, NULL);
+}
+
+static PyObject*
+PrivateModule_get_register_metaclass(PyObject* /*self*/, void* /*closure*/) noexcept
+{
+    return PyCFunction_NewEx(&PrivateModule_methods[2], NULL, NULL);
+}
+
+static PyObject*
+PrivateModule_get_ensure_type(PyObject* /*self*/, void* /*closure*/) noexcept
+{
+    return PyCFunction_NewEx(&PrivateModule_methods[3], NULL, NULL);
+}
+
+static PyObject*
+PrivateModule_get_ensure_metaclass(PyObject* /*self*/, void* /*closure*/) noexcept
+{
+    return PyCFunction_NewEx(&PrivateModule_methods[4], NULL, NULL);
+}
+
+static PyGetSetDef PrivateModule_getsetters[] = {
+    {"PrivateWrapProxy", (getter)PrivateModule_get_PrivateWrapProxy, NULL, NULL, NULL},
+    {"PrivateAttrType", (getter)PrivateModule_get_PrivateAttrType, NULL, NULL, NULL},
+    {"PrivateAttrBase", (getter)PrivateModule_get_PrivateAttrBase, NULL, NULL, NULL},
+    {"prepare", (getter)PrivateModule_get_prepare, NULL, NULL, NULL},
+    {"postprocess", (getter)PrivateModule_get_postprocess, NULL, NULL, NULL},
+    {"register_metaclass", (getter)PrivateModule_get_register_metaclass, NULL, NULL, NULL},
+    {"ensure_type", (getter)PrivateModule_get_ensure_type, NULL, NULL, NULL},
+    {"ensure_metaclass", (getter)PrivateModule_get_ensure_metaclass, NULL, NULL, NULL},
+    {NULL}
+};
+
+static PyMethodDef PrivateModule_methods_def[] = {
+    {"__dir__", (PyCFunction)PrivateModule_dir, METH_NOARGS, NULL},
+    {NULL}  // Sentinel
+};
+
 static PyTypeObject PrivateModuleType = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "private_attribute_module", //tp_name
@@ -3251,7 +3279,7 @@ static PyTypeObject PrivateModuleType = {
     0, //tp_weaklistoffset
     0, //tp_iter
     0, //tp_iternext
-    PrivateModule_methods, //tp_methods
+    PrivateModule_methods_def, //tp_methods
     0, //tp_members
     PrivateModule_getsetters, //tp_getset
     &PyModule_Type, //tp_base
@@ -3323,14 +3351,14 @@ PyInit_private_attribute(void) noexcept
      * 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"));
+    PyList_Append(all, PyUnicode_InternFromString("PrivateWrapProxy"));
+    PyList_Append(all, PyUnicode_InternFromString("PrivateAttrType"));
+    PyList_Append(all, PyUnicode_InternFromString("PrivateAttrBase"));
+    PyList_Append(all, PyUnicode_InternFromString("prepare"));
+    PyList_Append(all, PyUnicode_InternFromString("postprocess"));
+    PyList_Append(all, PyUnicode_InternFromString("register_metaclass"));
+    PyList_Append(all, PyUnicode_InternFromString("ensure_type"));
+    PyList_Append(all, PyUnicode_InternFromString("ensure_metaclass"));
     Py_SET_TYPE(m, &PrivateModuleType);
     return m;
 }

{private_attribute_cpp-1.4.9 → 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.9 → 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.9
+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.9 → 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.9',
+    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.',