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

private_attribute_cpp-1.4.10/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include picosha2.h

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

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

@@ -229,7 +229,7 @@ generate_private_attr_name(uintptr_t obj_id, const std::string& attr_name) noexc
 
     std::mt19937 rng(seed);
 
-    static const std::string printable_chars = 
+    static const std::string printable_chars =
     "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
 
     std::uniform_int_distribution<long long> dist(0, printable_chars.size() - 1);
@@ -296,7 +296,7 @@ public:
         : type(type), value(value), traceback(traceback) {
     }
 
-    ~RestorePythonException() {
+    ~RestorePythonException() noexcept {
         Py_XDECREF(type);
         Py_XDECREF(value);
         Py_XDECREF(traceback);
@@ -498,7 +498,7 @@ id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
         if (::AllData::all_object_attr[final_id][obj_id].find(obj_private_name) != ::AllData::all_object_attr[final_id][obj_id].end()) {
             PyObject* python_obj = ::AllData::all_object_attr[final_id][obj_id][obj_private_name];
             if (!python_obj) {
-                PyErr_SetString(PyExc_SystemError, "attribute is NULL");
+                PyErr_Format(PyExc_SystemError, "%s (%d): attribute is NULL", __FILE__, __LINE__);
                 return NULL;
             }
             // if obj is a type, call result.__get__(None, obj)
@@ -948,7 +948,7 @@ PrivateWarp_name(PyObject* obj, void* /*closure*/) noexcept
 }
 
 static PyObject*
-PrivateWrap_qualname(PyObject* obj, void* /*closure*/)
+PrivateWrap_qualname(PyObject* obj, void* /*closure*/) noexcept
 {
     if (!obj) {
         return PyUnicode_FromString("_PrivateWrap");
@@ -1097,7 +1097,7 @@ typedef struct {
 } PrivateWrapProxyObject;
 
 static PyObject*
-PrivateWrapProxy_call(PrivateWrapProxyObject *self, PyObject *args, PyObject* /*kwgs */) noexcept
+PrivateWrapProxy_call(PrivateWrapProxyObject *self, PyObject *args, PyObject* /* kwgs */) noexcept
 {
     PyObject *func;
     if (!PyArg_ParseTuple(args, "O", &func)) return NULL;
@@ -1709,6 +1709,15 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyCodeObject*>& ma
     }
     PyObject* wrap = PyObject_GetAttrString(obj, "__wrapped__");
     if (wrap) {
+        if (wrap == obj) {
+            PyObject* code = PyObject_GetAttrString(obj, "__code__");
+            if (code) {
+                analyse_all_code(code, map, _seen);
+            } else {
+                PyErr_Clear();
+            }
+            return;
+        }
         analyse_all_code(wrap, map, _seen);
         return;
     }
@@ -1724,7 +1733,7 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyCodeObject*>& ma
 }
 
 static std::string
-real_class_name(const std::string& name, const std::string& class_name)
+real_class_name(const std::string& name, const std::string& class_name) noexcept
 {
     // 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) != "__") {
@@ -1796,7 +1805,7 @@ struct PrivateAttrCreationData
         need_remove_subclass.clear();
         cleared = true;
     }
-    
+
     ~PrivateAttrCreationData() noexcept {
         clear();
     }
@@ -1963,7 +1972,7 @@ python_original_tp_finalize(PyObject* self) noexcept
     get_del((PyTypeObject*)self->ob_type, &del);
     if (del) {
         PyObject *exc_type = NULL, *exc_value = NULL, *exc_tb = NULL;
-        PyErr_Fetch(&exc_type, &exc_value, &exc_tb); 
+        PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
         PyObject *result = PyObject_CallFunctionObjArgs(del, self, NULL);
         if (result == NULL)  {
             // python < 3.13 use PyErr_WriteUnraisable, python >= 3.13 use PyErr_FormatUnraisable
@@ -1991,7 +2000,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         "__get__", "__set__", "__delete__", "__new__", "__set_name__", "__class__", NULL};
 
     if (!args) {
-        PyErr_SetString(PyExc_SystemError, "arg is NULL");
+        PyErr_Format(PyExc_SystemError, "%s (%d): args is NULL", __FILE__, __LINE__);
         return false;
     }
 
@@ -2205,8 +2214,8 @@ PrivateAttrType_create(PyTypeObject* type, PrivateAttrCreationData& data) noexce
 
     if (!PyObject_IsInstance(new_type, (PyObject*)type)) {
         Py_DECREF(new_type);
-        PyErr_SetString(PyExc_TypeError, 
-                       ("base type creation did not return an instance of '" + 
+        PyErr_SetString(PyExc_TypeError,
+                       ("base type creation did not return an instance of '" +
                         std::string(type->tp_name) + "'").c_str());
         return nullptr;
     }
@@ -2344,7 +2353,7 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
     uintptr_t type_id = (uintptr_t)(type_instance);
     if (PyDict_ContainsString(type_instance->tp_dict, "__static_attributes__")) {
         PyErr_Format(PyExc_SystemError,
-            "%s: %d: '__static_attributes__' will expose private attribute names and cannot be used in private attribute types", __FILE__, __LINE__);
+            "%s (%d): '__static_attributes__' will expose private attribute names and cannot be used in private attribute types", __FILE__, __LINE__);
         return false;
     }
 
@@ -2882,8 +2891,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;
@@ -3132,14 +3140,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);
@@ -3159,13 +3167,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:
@@ -3205,7 +3206,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},
@@ -3214,6 +3214,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
@@ -3242,7 +3289,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
@@ -3314,14 +3361,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.8 → private_attribute_cpp-1.4.10/private_attribute_cpp.egg-info}/PKG-INFO

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

@@ -18,7 +18,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='1.4.8',
+    version='1.4.10',
     author="HuangHaoHua",
     author_email="13140752715@example.com",
     description='A Python package that provides a way to define private attributes in C++ implementation.',
@@ -34,4 +34,4 @@ setup(
     packages=[""],
 
     url="https://github.com/Locked-chess-official/private_attribute_cpp"
-)
+)

private_attribute_cpp-1.4.8/MANIFEST.in

@@ -1,2 +0,0 @@
-include README.md
-include picosha2.h