private-attribute-cpp 2.0.1__tar.gz → 2.0.3__tar.gz

{private_attribute_cpp-2.0.1/private_attribute_cpp.egg-info → private_attribute_cpp-2.0.3}/PKG-INFO

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

@@ -33,6 +33,12 @@ PyDict_ContainsString(PyObject *op, const char *key) noexcept
     return res;
 }
 #endif
+
+// python >= 3.15 has PyAnyDict_Check. Under 3.15 defined it as PyDict_Check
+#if PY_VERSION_HEX < 0x030F0000
+#define PyAnyDict_Check(op) PyDict_Check(op)
+#endif
+
 static const auto module_running_time = std::chrono::system_clock::now();
 
 static std::string
@@ -277,178 +283,67 @@ default_random_string(uintptr_t obj_id, const std::string& attr_name) noexcept
     return result;
 }
 
-class RestorePythonException : public std::exception
-{
-public:
-    RestorePythonException(PyObject* type, PyObject* value, PyObject* traceback) noexcept
-        : type(type), value(value), traceback(traceback) {
-    }
-
-    ~RestorePythonException() noexcept {
-        Py_XDECREF(type);
-        Py_XDECREF(value);
-        Py_XDECREF(traceback);
-    }
-
-    RestorePythonException(const RestorePythonException&) = delete;
-    RestorePythonException& operator=(RestorePythonException&& other) noexcept {
-        if (this != &other) {
-            type = other.type;
-            value = other.value;
-            traceback = other.traceback;
-            other.type = nullptr;
-            other.value = nullptr;
-            other.traceback = nullptr;
-        }
-        return *this;
-    }
-
-    // Move constructor
-    RestorePythonException(RestorePythonException&& other) noexcept
-        : type(other.type), value(other.value), traceback(other.traceback) {
-        other.type = nullptr;
-        other.value = nullptr;
-        other.traceback = nullptr;
-    }
-
-    void restore() noexcept {
-        PyErr_Restore(type, value, traceback);
-        type = value = traceback = nullptr;
-    }
-
-    const char* what() const noexcept override {
-        if (!msg_.empty())
-            return msg_.c_str();
-
-        if (!type || !value) {
-            msg_ = "cannot format this exception (missing type/value)";
-            return msg_.c_str();
-        }
-
-        PyObject* tb_mod = PyImport_ImportModule("traceback");
-        if (!tb_mod) {
-            msg_ = "cannot format this exception (import traceback failed)";
-            return msg_.c_str();
-        }
-
-        PyObject* format_exc = PyObject_GetAttrString(tb_mod, "format_exception");
-        Py_DECREF(tb_mod);
-        if (!format_exc) {
-            msg_ = "cannot format this exception (get format_exception failed)";
-            return msg_.c_str();
-        }
-
-        PyObject* result = PyObject_CallFunctionObjArgs(
-            format_exc, type, value, traceback ? traceback : Py_None, nullptr);
-        Py_DECREF(format_exc);
-
-        if (!result) {
-            msg_ = "cannot format this exception (format_exception failed)";
-            return msg_.c_str();
-        }
-
-        PyObject* empty = PyUnicode_FromString("");
-        if (!empty) {
-            Py_DECREF(result);
-            msg_ = "cannot format this exception (create empty string failed)";
-            return msg_.c_str();
-        }
-
-        PyObject* joined = PyUnicode_Join(empty, result);
-        Py_DECREF(empty);
-        Py_DECREF(result);
-
-        if (!joined) {
-            msg_ = "cannot format this exception (join failed)";
-            return msg_.c_str();
-        }
-
-        const char* utf8 = PyUnicode_AsUTF8(joined);
-        if (utf8)
-            msg_ = utf8;
-        else
-            msg_ = "cannot format this exception (AsUTF8 failed)";
-
-        Py_DECREF(joined);
-        return msg_.c_str();
-    }
-
-private:
-    PyObject* type = nullptr;
-    PyObject* value = nullptr;
-    PyObject* traceback = nullptr;
-    mutable std::string msg_;
+struct RestorePythonExceptionResult {
+    std::string value;
+    bool ok = true;
 };
 
-// In MSVC, disable warning C5272
-// The custom_random_string will throw RestorePythonException, which cannot be copied and will be caught anyway.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 5272)
-#endif
-
-static std::string
-custom_random_string(uintptr_t obj_id, const std::string& attr_name, PyObject* func)
+static RestorePythonExceptionResult
+custom_random_string(uintptr_t obj_id, const std::string& attr_name, PyObject* func) noexcept
 {
+    RestorePythonExceptionResult result;
     AllPyobjectAttrCacheKey key(obj_id, attr_name);
-    std::string result;
     {
         std::shared_lock<std::shared_mutex> lock(::AllData::cache_mutex);
         auto it = ::AllData::cache.find(key);
         if (it != ::AllData::cache.end()) {
-            result = it->second;
+            result.value = it->second;
             return result;
         } else {
             lock.unlock();
-            PyObject* args = PyTuple_New(2);
-            PyTuple_SetItem(args, 0, PyLong_FromSize_t(static_cast<size_t>(obj_id)));
-            PyTuple_SetItem(args, 1, PyUnicode_FromString(attr_name.c_str()));
-
-            PyObject* python_result = PyObject_CallObject((PyObject*)func, args);
-
-            Py_DECREF(args);
+            PyObject* python_result = PyObject_CallFunction(
+                func,
+                "ns",
+                static_cast<Py_ssize_t>(obj_id),
+                attr_name.c_str()
+            );
             if (python_result) {
                 if (!PyUnicode_Check(python_result)) {
                     Py_DECREF(python_result);
                     PyErr_SetString(PyExc_TypeError, "private_func function must return a string");
-                    PyObject *type, *value, *traceback;
-                    PyErr_Fetch(&type, &value, &traceback);
-                    throw RestorePythonException(type, value, traceback);
+                    result.ok = false;
+                    result.value = "private_func function must return a string";
+                    return result;
                 }
-                result = PyUnicode_AsUTF8(python_result);
+                result.value = PyUnicode_AsUTF8(python_result);
                 Py_DECREF(python_result);
-                std::string original_result = result;
+                std::string original_result = result.value;
                 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()) {
-                    result = it->second;
+                    result.value = it->second;
                     return result;
                 }
-                while (::AllData::all_exist_name.find(result) != ::AllData::all_exist_name.end()) {
-                    result = original_result + "_" + std::to_string(i);
+                while (::AllData::all_exist_name.find(result.value) != ::AllData::all_exist_name.end()) {
+                    result.value = original_result + "_" + std::to_string(i);
                     i++;
                 }
                 if (::AllData::obj_attr_keys.find(obj_id) == ::AllData::obj_attr_keys.end()) {
                     ::AllData::obj_attr_keys[obj_id] = {};
                 }
                 ::AllData::obj_attr_keys[obj_id].push_back(key);
-                ::AllData::cache[key] = result;
-                ::AllData::all_exist_name.insert(result);
+                ::AllData::cache[key] = result.value;
+                ::AllData::all_exist_name.insert(result.value);
             } else {
-                PyObject *type, *value, *traceback;
-                PyErr_Fetch(&type, &value, &traceback);
-                throw RestorePythonException(type, value, traceback);
+                result.ok = false;
+                result.value = "python exception while calling private function";
             }
         }
     }
     return result;
 }
 
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 static void
 clear_obj(uintptr_t obj_id) noexcept
 {
@@ -500,12 +395,11 @@ id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
         obj_need_call = ::AllData::type_need_call[final_id];
     }
     if (obj_need_call) {
-        try {
-            obj_private_name = custom_random_string(obj_id, attr_name, obj_need_call);
-        } catch (RestorePythonException& e) {
-            e.restore();
+        auto private_name_result = custom_random_string(obj_id, attr_name, obj_need_call);
+        if (!private_name_result.ok) {
             return NULL;
         }
+        obj_private_name = private_name_result.value;
     } else {
         obj_private_name = default_random_string(obj_id, attr_name);
     }
@@ -582,9 +476,7 @@ id_getattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
     if (type_name == NULL) {
         return NULL;
     }
-    std::string string_type_name = type_name;
-    std::string exception_information = "'" + string_type_name + "' objects has no attribute '" + attr_name + "'";
-    PyErr_SetString(PyExc_AttributeError, exception_information.c_str());
+    PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", type_name, attr_name.c_str());
     return NULL;
 }
 
@@ -616,9 +508,7 @@ type_getattr(PyObject* typ, const std::string& attr_name) noexcept
     if (type_name == NULL) {
         return NULL;
     }
-    std::string string_type_name = type_name;
-    std::string message = "type object '" + string_type_name + "' has no attribute '" + attr_name + "'";
-    PyErr_SetString(PyExc_AttributeError, message.c_str());
+    PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", type_name, attr_name.c_str());
     return NULL;
 }
 
@@ -641,12 +531,11 @@ id_setattr(const std::string& attr_name, PyObject* obj, PyObject* typ, PyObject*
         obj_need_call = ::AllData::type_need_call[final_id];
     }
     if (obj_need_call) {
-        try {
-            obj_private_name = custom_random_string(obj_id, attr_name, obj_need_call);
-        } catch (RestorePythonException& e) {
-            e.restore();
+        auto private_name_result = custom_random_string(obj_id, attr_name, obj_need_call);
+        if (!private_name_result.ok) {
             return -1;
         }
+        obj_private_name = private_name_result.value;
     } else {
         obj_private_name = default_random_string(obj_id, attr_name);
     }
@@ -710,12 +599,11 @@ type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexc
         type_need_call = NULL;
     }
     if (type_need_call) {
-        try {
-            final_key = custom_random_string(typ_id, attr_name, type_need_call);
-        } catch (RestorePythonException& e) {
-            e.restore();
+        auto private_name_result = custom_random_string(typ_id, attr_name, type_need_call);
+        if (!private_name_result.ok) {
             return -1;
         }
+        final_key = private_name_result.value;
     } else {
         final_key = default_random_string(typ_id, attr_name);
     }
@@ -785,12 +673,11 @@ id_delattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
         obj_need_call = ::AllData::type_need_call[final_id];
     }
     if (obj_need_call) {
-        try {
-            obj_private_name = custom_random_string(obj_id, attr_name, obj_need_call);
-        } catch (RestorePythonException& e) {
-            e.restore();
+        auto private_name_result = custom_random_string(obj_id, attr_name, obj_need_call);
+        if (!private_name_result.ok) {
             return -1;
         }
+        obj_private_name = private_name_result.value;
     } else {
         obj_private_name = default_random_string(obj_id, attr_name);
     }
@@ -832,10 +719,7 @@ id_delattr(const std::string& attr_name, PyObject* obj, PyObject* typ) noexcept
             if (type_name == NULL) {
                 return -1;
             }
-            std::string string_type_name = type_name;
-            std::string exception_information = "'" + string_type_name + "' objects has no attribute '" + attr_name + "'";
-            PyErr_SetString(PyExc_AttributeError, exception_information.c_str());
-            return -1;
+            PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", type_name, attr_name.c_str());
         }
         PyObject* delete_obj = ::AllData::all_object_attr[final_id][obj_id][obj_private_name];
         ::AllData::all_object_attr[final_id][obj_id].erase(obj_private_name);
@@ -857,12 +741,11 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
         type_need_call = NULL;
     }
     if (type_need_call) {
-        try {
-            final_key = custom_random_string(typ_id, attr_name, type_need_call);
-        } catch (RestorePythonException& e) {
-            e.restore();
+        auto private_name_result = custom_random_string(typ_id, attr_name, type_need_call);
+        if (!private_name_result.ok) {
             return -1;
         }
+        final_key = private_name_result.value;
     } else {
         final_key = default_random_string(typ_id, attr_name);
     }
@@ -884,9 +767,7 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
             if (type_name == NULL) {
                 return -1;
             }
-            std::string string_type_name = type_name;
-            std::string message = "type object '" + string_type_name + "' has no attribute '" + attr_name + "'";
-            PyErr_SetString(PyExc_AttributeError, message.c_str());
+            PyErr_Format(PyExc_AttributeError, "type object '%s' has no attribute '%s'", type_name, attr_name.c_str());
             return -1;
         }
         PyObject* delete_obj = ::AllData::type_attr_dict[typ_id][final_key];
@@ -912,9 +793,7 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
             if (type_name == NULL) {
                 return -1;
             }
-            std::string string_type_name = type_name;
-            std::string message = "type object '" + string_type_name + "' has no attribute '" + attr_name + "'";
-            PyErr_SetString(PyExc_AttributeError, message.c_str());
+            PyErr_Format(PyExc_AttributeError, "type object '%s' has no attribute '%s'", type_name, attr_name.c_str());
             return -1;
         }
         PyObject* delete_obj = ::AllData::all_type_subclass_attr[final_id][typ_id][final_key];
@@ -1577,12 +1456,11 @@ type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept
             }
             std::string key;
             if (type_need_call != NULL) {
-                try {
-                    key = custom_random_string(type_id, name, type_need_call);
-                } catch (RestorePythonException& e) {
-                    e.restore();
+                auto private_name_result = custom_random_string(type_id, name, type_need_call);
+                if (!private_name_result.ok) {
                     return -2; // -2 means exception
                 }
+                key = private_name_result.value;
             } else {
                 key = default_random_string(type_id, name);
             }
@@ -1616,12 +1494,11 @@ type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept
                                 if (::AllData::type_need_call.find(now_visited_id) != ::AllData::type_need_call.end()) {
                                     PyObject* func = ::AllData::type_need_call[now_visited_id];
                                     if (func != NULL) {
-                                        try {
-                                            key = custom_random_string(now_visited_id, name, func);
-                                        } catch (RestorePythonException& e) {
-                                            e.restore();
+                                        auto private_name_result = custom_random_string(now_visited_id, name, func);
+                                        if (!private_name_result.ok) {
                                             return -2; // -2 means exception
                                         }
+                                        key = private_name_result.value;
                                     } else {
                                         key = default_random_string(now_visited_id, name);
                                     }
@@ -1647,12 +1524,11 @@ type_get_final_attr(uintptr_t type_id, const std::string& name) noexcept
                     if (::AllData::type_need_call.find(parent_id) != ::AllData::type_need_call.end()) {
                         PyObject* func = ::AllData::type_need_call[parent_id];
                         if (func != NULL) {
-                            try {
-                                key = custom_random_string(parent_id, name, ::AllData::type_need_call[parent_id]);
-                            } catch (RestorePythonException& e) {
-                                e.restore();
+                            auto private_name_result = custom_random_string(parent_id, name, func);
+                            if (!private_name_result.ok) {
                                 return -2; // -2 means exception
                             }
+                            key = private_name_result.value;
                         } else {
                             key = default_random_string(parent_id, name);
                         }
@@ -1975,7 +1851,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         return false;
     }
 
-    if (!PyDict_Check(data.attrs)) {
+    if (!PyAnyDict_Check(data.attrs)) {
         PyErr_SetString(PyExc_TypeError, "attrs must be a dict");
         return false;
     }
@@ -2050,26 +1926,46 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
 
     if (has_slots) {
         PyObject* all_slots = PyDict_GetItemString(data.attrs_copy, "__slots__");
-        PyObject* slot_seq = PySequence_Fast(all_slots, "__slots__ must be a sequence");
-        if (!slot_seq) {
-            return false;
-        }
-
-        Py_ssize_t slot_len = PySequence_Fast_GET_SIZE(slot_seq);
-
-        for (Py_ssize_t j = 0; j < slot_len; j++) {
-            PyObject* slot = PySequence_Fast_GET_ITEM(slot_seq, j);
-            if (PyUnicode_Check(slot)) {
-                const char* slot_cstr = PyUnicode_AsUTF8(slot);
-                if (data.private_attrs_vector_string.find((std::string)slot_cstr) != data.private_attrs_vector_string.end()){
-                    std::string error_msg = "'__slots__' and '__private_attrs__' cannot have the same attribute name: '" + std::string(slot_cstr) + "'";
-                    PyErr_SetString(PyExc_TypeError, error_msg.c_str());
-                    Py_DECREF(slot_seq);
+        if (!all_slots) {return false;}
+        if (PyUnicode_Check(all_slots)) {
+            const char* slot_cstr = PyUnicode_AsUTF8(all_slots);
+            if (data.private_attrs_vector_string.find((std::string)slot_cstr) != data.private_attrs_vector_string.end()){
+                std::string error_msg = "'__slots__' and '__private_attrs__' cannot have the same attribute name: '" + std::string(slot_cstr) + "'";
+                PyErr_SetString(PyExc_TypeError, error_msg.c_str());
+                return false;
+            }
+        } else {
+            PyObject* slot_seq;
+            if (PyAnyDict_Check(all_slots)) {
+                // use the key of the dict as the slot name
+                PyObject* keys = PyDict_Keys(all_slots);
+                if (!keys) {
                     return false;
                 }
+                slot_seq = keys;
+            } else {
+                slot_seq = PySequence_Fast(all_slots, "__slots__ must be a sequence");
+            }
+            if (!slot_seq) {
+                return false;
+            }
+
+            Py_ssize_t slot_len = PySequence_Fast_GET_SIZE(slot_seq);
+
+            for (Py_ssize_t j = 0; j < slot_len; j++) {
+                PyObject* slot = PySequence_Fast_GET_ITEM(slot_seq, j);
+                if (PyUnicode_Check(slot)) {
+                    const char* slot_cstr = PyUnicode_AsUTF8(slot);
+                    if (data.private_attrs_vector_string.find((std::string)slot_cstr) != data.private_attrs_vector_string.end()){
+                        std::string error_msg = "'__slots__' and '__private_attrs__' cannot have the same attribute name: '" + std::string(slot_cstr) + "'";
+                        PyErr_SetString(PyExc_TypeError, error_msg.c_str());
+                        Py_DECREF(slot_seq);
+                        return false;
+                    }
+                }
             }
+            Py_DECREF(slot_seq);
         }
-        Py_DECREF(slot_seq);
     }
 
     Py_ssize_t bases_len = PyTuple_GET_SIZE(data.bases);
@@ -2312,12 +2208,11 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
     for (auto& [key, value]: data.need_remove_itself) {
         std::string final_key;
         if (data.private_func) {
-            try {
-                final_key = custom_random_string(type_id, key, data.private_func);
-            } catch (RestorePythonException& e) {
-                e.restore();
+            auto private_name_result = custom_random_string(type_id, key, data.private_func);
+            if (!private_name_result.ok) {
                 return false;
             }
+            final_key = private_name_result.value;
         } else {
             final_key = default_random_string(type_id, key);
         }
@@ -2341,12 +2236,11 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
         for (auto& [key, value]: map) {
             std::string final_key;
             if (data.private_func) {
-                try {
-                    final_key = custom_random_string(type_id, key, data.private_func);
-                } catch (RestorePythonException& e) {
-                    e.restore();
+                auto private_name_result = custom_random_string(type_id, key, data.private_func);
+                if (!private_name_result.ok) {
                     return false;
                 }
+                final_key = private_name_result.value;
             } else {
                 final_key = default_random_string(type_id, key);
             }
@@ -3136,7 +3030,7 @@ PrivateModule_setattro(PyObject* self, PyObject* name, PyObject* value) noexcept
         const size_t num_attrs = sizeof(unsetable_attrs) / sizeof(unsetable_attrs[0]);
         for (size_t i = 0; i < num_attrs; ++i) {
             if (strcmp(name_cstr, unsetable_attrs[i]) == 0) {
-                PyErr_Format(PyExc_AttributeError, "attribute '%s' of 'private_attribute_module' objects is not writable", name_cstr);
+                PyErr_Format(PyExc_AttributeError, "attribute '%s' of 'private_attribute.private_attribute_module' objects is not writable", name_cstr);
                 return -1;
             }
         }

{private_attribute_cpp-2.0.1 → private_attribute_cpp-2.0.3/private_attribute_cpp.egg-info}/PKG-INFO

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

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