private-attribute-cpp 2.0.2__tar.gz → 2.0.4__tar.gz

{private_attribute_cpp-2.0.2/private_attribute_cpp.egg-info → private_attribute_cpp-2.0.4}/PKG-INFO

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

@@ -115,6 +115,56 @@ namespace std {
     };
 }
 
+struct PyObjectStorage
+{
+    PyObject* obj = NULL;
+
+    PyObjectStorage() noexcept = default;
+    PyObjectStorage(PyObject* obj) noexcept : obj(obj) {
+        Py_XINCREF(obj);
+    }
+    PyObjectStorage(const PyObjectStorage& other) noexcept : obj(other.obj) {
+        Py_XINCREF(obj);
+    }
+    PyObjectStorage(PyObjectStorage&& other) noexcept : obj(other.obj) {
+        other.obj = NULL;
+    }
+    PyObjectStorage& operator=(const PyObjectStorage& other) noexcept {
+        if (this == &other) {
+            return *this;
+        }
+        PyObject* new_obj = other.obj;
+        Py_XINCREF(new_obj);
+        Py_XDECREF(obj);
+        obj = new_obj;
+        return *this;
+    }
+    PyObjectStorage& operator=(PyObjectStorage&& other) noexcept {
+        if (this != &other) {
+            Py_XDECREF(obj);
+            obj = other.obj;
+            other.obj = NULL;
+        }
+        return *this;
+    }
+    PyObjectStorage& operator=(PyObject* new_obj) noexcept {
+        Py_XINCREF(new_obj);
+        Py_XDECREF(obj);
+        obj = new_obj;
+        return *this;
+    }
+    ~PyObjectStorage() noexcept {
+        Py_XDECREF(obj);
+    }
+
+    operator PyObject*() const noexcept {
+        return obj;
+    }
+    PyObject* get() const noexcept {
+        return obj;
+    }
+};
+
 namespace {
     namespace AllData {
         static std::unordered_map<AllPyobjectAttrCacheKey, std::string> cache;
@@ -122,7 +172,7 @@ namespace {
         static std::unordered_map<uintptr_t, std::vector<AllPyobjectAttrCacheKey>> obj_attr_keys;
         static std::shared_mutex cache_mutex;
         namespace {
-            static std::unordered_map<uintptr_t, std::unordered_map<std::string, PyObject*>> type_attr_dict;
+            static std::unordered_map<uintptr_t, std::unordered_map<std::string, PyObjectStorage>> type_attr_dict;
         };
         static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t, PyCodeObject*>> type_allowed_code_map;
         static std::unordered_map<uintptr_t, std::shared_ptr<std::shared_mutex>> all_type_mutex;
@@ -130,7 +180,7 @@ namespace {
         static std::unordered_map<uintptr_t, std::unordered_set<TwoStringTuple>> all_type_attr_set;
         namespace {
             static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t,
-            std::unordered_map<std::string, PyObject*>>> all_object_attr, all_type_subclass_attr;
+            std::unordered_map<std::string, PyObjectStorage>>> all_object_attr, all_type_subclass_attr;
         };
         static std::unordered_map<uintptr_t, std::unordered_map<uintptr_t, std::shared_ptr<std::shared_mutex>>>
         all_object_mutex, all_type_subclass_mutex;
@@ -149,16 +199,12 @@ namespace {
 
 struct FinalObject
 {
-    PyObject* result = NULL;
+    PyObjectStorage result;
     int status = 0;
-    FinalObject(PyObject* result) noexcept
-        : result(result) {
-            Py_XINCREF(result);
-        }
-    FinalObject(int status) noexcept: status(status) {}
-    ~FinalObject() noexcept {
-        Py_XDECREF(result);
-    }
+    FinalObject() noexcept = default;
+    FinalObject(PyObject* result) noexcept : result(result) {}
+    FinalObject(PyObjectStorage result) noexcept : result(std::move(result)) {}
+    FinalObject(int status) noexcept : status(status) {}
 };
 
 static TwoStringTuple get_string_hash_tuple2(const std::string& name) noexcept;
@@ -476,9 +522,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;
 }
 
@@ -510,9 +554,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;
 }
 
@@ -574,12 +616,8 @@ id_setattr(const std::string& attr_name, PyObject* obj, PyObject* typ, PyObject*
     }
 
     // second: set attribute on obj
-    Py_INCREF(value);
     {
         std::unique_lock<std::shared_mutex> lock(*::AllData::all_object_mutex[final_id][obj_id]);
-        if (::AllData::all_object_attr[final_id][obj_id].find(obj_private_name) != ::AllData::all_object_attr[final_id][obj_id].end()) {
-            Py_XDECREF(::AllData::all_object_attr[final_id][obj_id][obj_private_name]);
-        }
         ::AllData::all_object_attr[final_id][obj_id][obj_private_name] = value;
     }
     return 0;
@@ -625,11 +663,7 @@ type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexc
         }
         {
             std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_mutex[typ_id]);
-            if (::AllData::type_attr_dict[typ_id].find(final_key) != ::AllData::type_attr_dict[typ_id].end()) {
-                Py_XDECREF(::AllData::type_attr_dict[typ_id][final_key]);
-            }
             ::AllData::type_attr_dict[typ_id][final_key] = value;
-            Py_INCREF(value);
         }
         return 0;
     } else {
@@ -648,11 +682,7 @@ type_setattr(PyObject* typ, const std::string& attr_name, PyObject* value) noexc
         }
         {
             std::unique_lock<std::shared_mutex> lock(*::AllData::all_type_subclass_mutex[final_id][typ_id]);
-            if (::AllData::all_type_subclass_attr[final_id][typ_id].find(final_key) != ::AllData::all_type_subclass_attr[final_id][typ_id].end()) {
-                Py_XDECREF(::AllData::all_type_subclass_attr[final_id][typ_id][final_key]);
-            }
             ::AllData::all_type_subclass_attr[final_id][typ_id][final_key] = value;
-            Py_INCREF(value);
             return 0;
         }
     }
@@ -723,14 +753,9 @@ 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);
-        Py_XDECREF(delete_obj);
     }
     return 0;
 }
@@ -774,14 +799,10 @@ 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];
         ::AllData::type_attr_dict[typ_id].erase(final_key);
-        Py_XDECREF(delete_obj);
     } else {
         if (::AllData::all_type_subclass_attr.find(final_id) == ::AllData::all_type_subclass_attr.end()) {
             ::AllData::all_type_subclass_attr[final_id] = {};
@@ -802,14 +823,10 @@ 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];
         ::AllData::all_type_subclass_attr[final_id][typ_id].erase(final_key);
-        Py_XDECREF(delete_obj);
     }
     return 0;
 }
@@ -1323,10 +1340,6 @@ PrivateAttr_tp_finalize(PyObject* self) noexcept
         if (::AllData::all_object_attr.find(typ_id) != ::AllData::all_object_attr.end()){
             auto& all_object_attr = ::AllData::all_object_attr[typ_id];
             if (all_object_attr.find(id_self) != all_object_attr.end()){
-                auto& all_object_attr_self = all_object_attr[id_self];
-                for (auto& attr : all_object_attr_self){
-                    Py_XDECREF(attr.second);
-                }
                 all_object_attr.erase(id_self);
             }
         }
@@ -1341,10 +1354,6 @@ PrivateAttr_tp_finalize(PyObject* self) noexcept
             if (::AllData::all_object_attr.find(parent_id) != ::AllData::all_object_attr.end()){
                 auto& all_object_attr = ::AllData::all_object_attr[parent_id];
                 if (all_object_attr.find(id_self) != all_object_attr.end()){
-                    auto& all_object_attr_self = all_object_attr[id_self];
-                    for (auto& attr : all_object_attr_self){
-                        Py_XDECREF(attr.second);
-                    }
                     all_object_attr.erase(id_self);
                 }
             }
@@ -1621,6 +1630,21 @@ get_now_code() noexcept
     return code;
 }
 
+static PyObject*
+try_get_attr_string(PyObject* obj, const char* name) noexcept
+{
+    if (obj == NULL || name == NULL) {
+        return NULL;
+    }
+    if (PyObject_HasAttrString(obj, name) <= 0) {
+        if (PyErr_Occurred()) {
+            PyErr_Clear();
+        }
+        return NULL;
+    }
+    return PyObject_GetAttrString(obj, name);
+}
+
 static void
 analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyCodeObject*>& map, std::unordered_set<uintptr_t>& _seen) noexcept
 {
@@ -1632,88 +1656,83 @@ analyse_all_code(PyObject* obj, std::unordered_map<uintptr_t, PyCodeObject*>& ma
     if (PyObject_TypeCheck(obj, &PyCode_Type)) {
         Py_INCREF(obj);
         map[(uintptr_t)obj] = (PyCodeObject*)obj;
-        PyObject* co_contain = PyObject_GetAttrString(obj, "co_consts");
+        PyObject* co_contain = try_get_attr_string(obj, "co_consts");
         if (co_contain && PySequence_Check(co_contain)) {
             Py_ssize_t len = PySequence_Length(co_contain);
-            for (Py_ssize_t i = 0; i < len; i++) {
-                PyObject* item = PySequence_GetItem(co_contain, i);
-                if (item) {
-                    analyse_all_code(item, map, _seen);
-                } else {
-                    PyErr_Clear();
+            if (len >= 0) {
+                for (Py_ssize_t i = 0; i < len; i++) {
+                    PyObject* item = PySequence_GetItem(co_contain, i);
+                    if (item) {
+                        analyse_all_code(item, map, _seen);
+                        Py_DECREF(item);
+                    }
                 }
             }
         }
+        Py_XDECREF(co_contain);
         return;
     }
     if (PyObject_TypeCheck(obj, &PrivateWrapType)) {
         PyObject* func_list = ((PrivateWrapObject*)obj)->func_list;
         if (func_list && PySequence_Check(func_list)) {
             Py_ssize_t len = PySequence_Length(func_list);
-            for (Py_ssize_t i = 0; i < len; i++) {
-                PyObject* func = PySequence_GetItem(func_list, i);
-                if (func) {
-                    analyse_all_code(func, map, _seen);
-                } else {
-                    PyErr_Clear();
+            if (len >= 0) {
+                for (Py_ssize_t i = 0; i < len; i++) {
+                    PyObject* func = PySequence_GetItem(func_list, i);
+                    if (func) {
+                        analyse_all_code(func, map, _seen);
+                        Py_DECREF(func);
+                    }
                 }
             }
         }
         return;
     }
     if (PyObject_TypeCheck(obj, &PyProperty_Type)) {
-        PyObject* fget = PyObject_GetAttrString(obj, "fget");
+        PyObject* fget = try_get_attr_string(obj, "fget");
         if (fget) {
             analyse_all_code(fget, map, _seen);
-        } else {
-            PyErr_Clear();
+            Py_DECREF(fget);
         }
-        PyObject* fset = PyObject_GetAttrString(obj, "fset");
+        PyObject* fset = try_get_attr_string(obj, "fset");
         if (fset) {
             analyse_all_code(fset, map, _seen);
+            Py_DECREF(fset);
         }
-        else {
-            PyErr_Clear();
-        }
-        PyObject* fdel = PyObject_GetAttrString(obj, "fdel");
+        PyObject* fdel = try_get_attr_string(obj, "fdel");
         if (fdel) {
             analyse_all_code(fdel, map, _seen);
-        } else {
-            PyErr_Clear();
+            Py_DECREF(fdel);
         }
         return;
     }
     if (PyObject_TypeCheck(obj, &PyClassMethod_Type) || PyObject_TypeCheck(obj, &PyStaticMethod_Type)) {
-        PyObject* func = PyObject_GetAttrString(obj, "__func__");
+        PyObject* func = try_get_attr_string(obj, "__func__");
         if (func) {
             analyse_all_code(func, map, _seen);
-        } else {
-            PyErr_Clear();
+            Py_DECREF(func);
         }
         return;
     }
-    PyObject* wrap = PyObject_GetAttrString(obj, "__wrapped__");
+    PyObject* wrap = try_get_attr_string(obj, "__wrapped__");
     if (wrap) {
         if (wrap == obj) {
-            PyObject* code = PyObject_GetAttrString(obj, "__code__");
+            PyObject* code = try_get_attr_string(obj, "__code__");
             if (code) {
                 analyse_all_code(code, map, _seen);
-            } else {
-                PyErr_Clear();
+                Py_DECREF(code);
             }
+            Py_DECREF(wrap);
             return;
         }
         analyse_all_code(wrap, map, _seen);
+        Py_DECREF(wrap);
         return;
     }
-    else {
-        PyErr_Clear();
-    }
-    PyObject* code = PyObject_GetAttrString(obj, "__code__");
+    PyObject* code = try_get_attr_string(obj, "__code__");
     if (code) {
         analyse_all_code(code, map, _seen);
-    } else {
-        PyErr_Clear();
+        Py_DECREF(code);
     }
 }
 
@@ -1735,8 +1754,8 @@ struct PrivateAttrCreationData
     std::unordered_set<TwoStringTuple> private_attrs_set;
     std::unordered_set<std::string> private_attrs_vector_string;
     std::vector<uintptr_t> all_need_analyse_base;
-    std::unordered_map<std::string, PyObject*> need_remove_itself;
-    std::unordered_map<uintptr_t, std::unordered_map<std::string, PyObject*>> need_remove_subclass;
+    std::unordered_map<std::string, PyObjectStorage> need_remove_itself;
+    std::unordered_map<uintptr_t, std::unordered_map<std::string, PyObjectStorage>> need_remove_subclass;
     PyObject* private_func = nullptr;
     PyObject* base_kwds = nullptr;
     PyObject* name = nullptr;
@@ -1777,16 +1796,7 @@ struct PrivateAttrCreationData
             base_kwds = nullptr;
         }
 
-        for (auto& pair : need_remove_itself) {
-            Py_XDECREF(pair.second);
-        }
         need_remove_itself.clear();
-
-        for (auto& outer_pair : need_remove_subclass) {
-            for (auto& inner_pair : outer_pair.second) {
-                Py_XDECREF(inner_pair.second);
-            }
-        }
         need_remove_subclass.clear();
         cleared = true;
     }
@@ -1937,26 +1947,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);
@@ -2207,7 +2237,6 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
         } else {
             final_key = default_random_string(type_id, key);
         }
-        Py_INCREF(value);
         ::AllData::type_attr_dict[type_id][final_key] = value;
     }
 
@@ -2235,7 +2264,6 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data) n
             } else {
                 final_key = default_random_string(type_id, key);
             }
-            Py_INCREF(value);
             ::AllData::all_type_subclass_attr[i][type_id][final_key] = value;
         }
     }
@@ -2513,10 +2541,6 @@ PrivateAttrType_finalize(PyObject* cls) noexcept
         ::AllData::type_need_call.erase(typ_id);
     }
     if (::AllData::type_attr_dict.find(typ_id) != ::AllData::type_attr_dict.end()) {
-        auto& private_attrs = ::AllData::type_attr_dict[typ_id];
-        for (auto& attr : private_attrs) {
-            Py_XDECREF(attr.second);
-        }
         ::AllData::type_attr_dict.erase(typ_id);
     }
     if (::AllData::all_type_subclass_attr.find(typ_id) != ::AllData::all_type_subclass_attr.end()) {
@@ -2533,10 +2557,6 @@ PrivateAttrType_finalize(PyObject* cls) noexcept
     for (auto& parent_id : parent_ids) {
         if (::AllData::all_type_subclass_attr.find(parent_id) != ::AllData::all_type_subclass_attr.end()) {
             if (::AllData::all_type_subclass_attr[parent_id].find(typ_id) != ::AllData::all_type_subclass_attr[parent_id].end()) {
-                auto& private_attrs = ::AllData::all_type_subclass_attr[parent_id][typ_id];
-                for (auto& attr : private_attrs) {
-                    Py_XDECREF(attr.second);
-                }
                 ::AllData::all_type_subclass_attr[parent_id].erase(typ_id);
             }
         }

{private_attribute_cpp-2.0.2 → private_attribute_cpp-2.0.4/private_attribute_cpp.egg-info}/PKG-INFO

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

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