private-attribute-cpp 2.1.18__tar.gz → 2.1.20__tar.gz

{private_attribute_cpp-2.1.18/private_attribute_cpp.egg-info → private_attribute_cpp-2.1.20}/PKG-INFO

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

@@ -931,6 +931,270 @@ type_delattr(PyObject* typ, const std::string& attr_name) noexcept
     return 0;
 }
 
+// list proxy
+// privatewrap.funcs return this type after 2.1.19
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *list;
+} listproxy;
+
+static bool
+listproxy_check(listproxy *obj) noexcept
+{
+    if (!obj->list) {
+        PyErr_SetString(PyExc_RuntimeError, "listproxy object has no list");
+        return false;
+    }
+    if (!PyList_CheckExact(obj->list)) {
+        PyErr_Format(PyExc_TypeError, "listproxy object can only proxy list, not '%s'", Py_TYPE(obj->list)->tp_name);
+        return false;
+    }
+    return true;
+}
+
+static PyObject*
+listproxy_copy(PyObject* self, PyObject* /*args*/) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+    return PySequence_List(obj->list);
+}
+
+static PyObject*
+listproxy_count(PyObject* self, PyObject* value) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+    Py_ssize_t m =  PySequence_Count(obj->list, value);
+    if (m < 0) {
+        return NULL;
+    }
+    PyObject* result = PyLong_FromSsize_t(m);
+    return result;
+}
+
+static PyObject*
+listproxy_index(PyObject* self, PyObject* args) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+    PyObject* method = PyObject_GetAttrString(obj->list, "index");
+    if (!method) {
+        return NULL;
+    }
+    PyObject* result = PyObject_Call(method, args, NULL);
+    Py_DECREF(method);
+    return result;
+}
+
+static Py_ssize_t
+listproxy_length(PyObject* self) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return -1;
+    }
+    return PyList_Size(obj->list);
+}
+
+static PyObject*
+listproxy_iter(PyObject* self) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+    return PyObject_GetIter(obj->list);
+}
+
+static PyObject*
+listproxy_item(PyObject* self, Py_ssize_t i) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+    Py_ssize_t size = PyList_Size(obj->list);
+    if (i < 0) {
+        i += size;
+    }
+    if (i < 0 || i >= size) {
+        PyErr_SetString(PyExc_IndexError, "listproxy index out of range");
+        return NULL;
+    }
+    PyObject* item = PyList_GetItem(obj->list, i);
+    if (!item) {
+        return NULL;
+    }
+    Py_INCREF(item);
+    return item;
+}
+
+static PyObject*
+listproxy_subscript(PyObject* self, PyObject* key) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+    return PyObject_GetItem(obj->list, key);
+}
+
+static int
+listproxy_contains(PyObject* self, PyObject* value) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return -1;
+    }
+    return PySequence_Contains(obj->list, value);
+}
+
+static PyObject*
+listproxy_repr(PyObject* self) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+    PyObject* inner = PyObject_Repr(obj->list);
+    if (!inner) {
+        return NULL;
+    }
+    PyObject* result = PyUnicode_FromFormat("listproxy(%U)", inner);
+    Py_DECREF(inner);
+    return result;
+}
+
+static PyObject*
+listproxy_richcompare(PyObject* self, PyObject* other, int op) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    if (!listproxy_check(obj)) {
+        return NULL;
+    }
+
+    // If the counterpart is a genuine Python list, compare the underlying
+    // list directly. Otherwise copy the counterpart into a real list first
+    // (so that listproxy == listproxy and listproxy == tuple behave like a
+    // list-to-list comparison), then compare.
+    PyObject* self_list = obj->list;
+    bool decref_self_list = false;
+    if (!PyList_CheckExact(other)) {
+        self_list = PySequence_List(obj->list);
+        if (!self_list) {
+            PyErr_Clear();
+            Py_RETURN_NOTIMPLEMENTED;
+        }
+        decref_self_list = true;
+    }
+
+    PyObject* result = PyObject_RichCompare(self_list, other, op);
+    if (decref_self_list) {
+        Py_DECREF(self_list);
+    }
+    return result;
+}
+
+static void
+listproxy_dealloc(listproxy* self) noexcept
+{
+    Py_XDECREF(self->list);
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PySequenceMethods listproxy_as_sequence = {
+    listproxy_length,       // sq_length
+    0,                      // sq_concat
+    0,                      // sq_repeat
+    listproxy_item,         // sq_item
+    0,                      // was_sq_slice
+    0,                      // sq_ass_item
+    0,                      // was_sq_ass_slice
+    listproxy_contains,     // sq_contains
+    0,                      // sq_inplace_concat
+    0,                      // sq_inplace_repeat
+};
+
+static PyMappingMethods listproxy_as_mapping = {
+    listproxy_length,       // mp_length
+    listproxy_subscript,    // mp_subscript
+    0,                      // mp_ass_subscript
+};
+
+static PyMethodDef listproxy_methods[] = {
+    {"copy", listproxy_copy, METH_NOARGS, "Return a copy of the proxied list."},
+    {"count", listproxy_count, METH_O, "Return number of occurrences of value."},
+    {"index", listproxy_index, METH_VARARGS, "Return first index of value."},
+    {NULL, NULL, 0, NULL}
+};
+
+static int
+listproxy_traverse(PyObject* self, visitproc visit, void* arg) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    Py_VISIT(obj->list);
+    return 0;
+}
+
+static int
+listproxy_clear(PyObject* self) noexcept
+{
+    listproxy* obj = (listproxy*)self;
+    Py_CLEAR(obj->list);
+    return 0;
+}
+
+static PyTypeObject listproxyType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "private_attribute.listproxy",           // tp_name
+    sizeof(listproxy),                       // tp_basicsize
+    0,                                       // tp_itemsize
+    (destructor)listproxy_dealloc,           // tp_dealloc
+    0,                                       // tp_print
+    0,                                       // tp_getattr
+    0,                                       // tp_setattr
+    0,                                       // tp_reserved
+    listproxy_repr,                          // tp_repr
+    0,                                       // tp_as_number
+    &listproxy_as_sequence,                  // tp_as_sequence
+    &listproxy_as_mapping,                   // tp_as_mapping
+    0,                                       // tp_hash
+    0,                                       // tp_call
+    0,                                       // tp_str
+    0,                                       // tp_getattro
+    0,                                       // tp_setattro
+    0,                                       // tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, // tp_flags
+    "A read-only proxy of a list.",          // tp_doc
+    listproxy_traverse,                      // tp_traverse
+    listproxy_clear,                         // tp_clear
+    listproxy_richcompare,                   // tp_richcompare
+    0,                                       // tp_weaklistoffset
+    listproxy_iter,                          // tp_iter
+    0,                                       // tp_iternext
+    listproxy_methods,                       // tp_methods
+};
+
+static PyObject*
+listproxy_new(PyObject* list) noexcept
+{
+    listproxy* obj = PyObject_GC_New(listproxy, &listproxyType);
+    if (!obj) {
+        return NULL;
+    }
+    obj->list = list;
+    Py_INCREF(list);
+    return (PyObject*)obj;
+}
+
 // ================================================================
 // _PrivateWrap
 // ================================================================
@@ -957,7 +1221,7 @@ PrivateWrap_funcs(PyObject *obj, void* /*closure*/) noexcept
         Py_RETURN_NONE;
     }
 
-    return PySequence_Tuple(((PrivateWrapObject*)obj)->func_list);
+    return listproxy_new(((PrivateWrapObject*)obj)->func_list);
 }
 
 static PyObject*
@@ -1148,7 +1412,7 @@ PrivateWrap_clear(PyObject* obj) noexcept
 
 static PyTypeObject PrivateWrapType = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    "_PrivateWrap",                            // tp_name
+    "private_attribute._PrivateWrap",          // tp_name
     sizeof(PrivateWrapObject),                 // tp_basicsize
     0,                                         // tp_itemsize
     (destructor)PrivateWrap_dealloc,           // tp_dealloc
@@ -2100,17 +2364,12 @@ PrivateAttrType_tp_clear(PyObject* self) noexcept
 static void
 PrivateAttr_object_init_private_dict(uintptr_t obj_id, uintptr_t type_id) noexcept
 {
-    if (::AllData::all_object_mutex.find(type_id) == ::AllData::all_object_mutex.end()) {
-        ::AllData::all_object_mutex[type_id].clear();
-    }
-    if (::AllData::all_object_attr.find(type_id) == ::AllData::all_object_attr.end()) {
-        ::AllData::all_object_attr[type_id] = {};
-    }
-    if (::AllData::all_object_mutex[type_id].find(obj_id) == ::AllData::all_object_mutex[type_id].end()) {
-        ::AllData::all_object_mutex[type_id][obj_id] = std::make_unique<std::shared_mutex>();
-    }
-    if (::AllData::all_object_attr[type_id].find(obj_id) == ::AllData::all_object_attr[type_id].end()) {
-        ::AllData::all_object_attr[type_id][obj_id] = {};
+    object_create_mutex(type_id, obj_id);
+    {
+        std::unique_lock<std::shared_mutex> lock(*::AllData::all_object_mutex[type_id][obj_id]);
+        if (::AllData::all_object_attr[type_id].find(obj_id) == ::AllData::all_object_attr[type_id].end()) {
+            ::AllData::all_object_attr[type_id][obj_id] = {};
+        }
     }
     if (::AllData::all_type_parent_id.find(type_id) != ::AllData::all_type_parent_id.end()) {
         for (auto parent_id : ::AllData::all_type_parent_id[type_id]) {
@@ -2177,7 +2436,7 @@ get_string_hash_tuple(const std::string& name) noexcept
     std::string name1hash, name2hash;
     picosha2::hash256_hex_string(name1, name1hash);
     picosha2::hash256_hex_string(name2, name2hash);
-    return PyTuple_Pack(2, PyUnicode_FromString(name1hash.c_str()), PyUnicode_FromString(name2hash.c_str()));
+    return Py_BuildValue("(ss)", name1hash.c_str(), name2hash.c_str());
 }
 
 static TwoStringTuple
@@ -2466,6 +2725,14 @@ real_class_name(const std::string& name, const std::string& class_name) noexcept
     return name;
 }
 
+#define PRIVATEATTR_CREATION_DATA_CLEAR(name) do \
+    { \
+        if (name) { \
+            Py_DECREF(name); \
+            name = nullptr; \
+        } \
+    } while (0)
+
 struct PrivateAttrCreationData
 {
     std::string class_name;
@@ -2489,34 +2756,13 @@ struct PrivateAttrCreationData
         if (cleared) {
             return;
         }
-        if (name) {
-            Py_DECREF(name);
-            name = nullptr;
-        }
-        if (bases) {
-            Py_DECREF(bases);
-            bases = nullptr;
-        }
-        if (attrs) {
-            Py_DECREF(attrs);
-            attrs = nullptr;
-        }
-        if (attrs_copy) {
-            Py_DECREF(attrs_copy);
-            attrs_copy = nullptr;
-        }
-        if (new_hash_private_attrs) {
-            Py_DECREF(new_hash_private_attrs);
-            new_hash_private_attrs = nullptr;
-        }
-        if (private_func) {
-            Py_DECREF(private_func);
-            private_func = nullptr;
-        }
-        if (base_kwds) {
-            Py_DECREF(base_kwds);
-            base_kwds = nullptr;
-        }
+        PRIVATEATTR_CREATION_DATA_CLEAR(name);
+        PRIVATEATTR_CREATION_DATA_CLEAR(bases);
+        PRIVATEATTR_CREATION_DATA_CLEAR(attrs);
+        PRIVATEATTR_CREATION_DATA_CLEAR(attrs_copy);
+        PRIVATEATTR_CREATION_DATA_CLEAR(new_hash_private_attrs);
+        PRIVATEATTR_CREATION_DATA_CLEAR(private_func);
+        PRIVATEATTR_CREATION_DATA_CLEAR(base_kwds);
 
         need_remove_itself.clear();
         need_remove_subclass.clear();
@@ -2747,7 +2993,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
 
     // forbidden to have "__static_attributes__" in attrs, because it exposes the private attributes name.
     if (PyDict_ContainsString(data.attrs_copy, "__static_attributes__")) {
-        PyDict_DelItemString(data.attrs_copy, "__static_attributes__");
+        if (PyDict_DelItemString(data.attrs_copy, "__static_attributes__") < 0) return false;
     }
 
     {
@@ -2772,7 +3018,7 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
                 // (PrivateAttrCreationData::clear). No manual INCREF here,
                 // otherwise the value leaks (+1) when the class is destroyed.
                 data.need_remove_itself[attr_name] = need_value;
-                PyDict_DelItem(data.attrs_copy, key);
+                if (PyDict_DelItem(data.attrs_copy, key)) return false;
                 continue;
             }
             uintptr_t need_remove_subclass_id = need_remove_to_subclass(attr_name);
@@ -2785,10 +3031,12 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
                 }
                 // PyObjectStorage assignment INCREFs (RAII); no manual INCREF.
                 data.need_remove_subclass[need_remove_subclass_id][attr_name] = need_value;
-                PyDict_DelItem(data.attrs_copy, key);
+                if (PyDict_DelItem(data.attrs_copy, key)) return false;
                 continue;
             }
-            if (value != need_value) PyDict_SetItem(data.attrs_copy, key, need_value);
+            if (value != need_value) {
+                if (PyDict_SetItem(data.attrs_copy, key, need_value) < 0) return false;
+            }
         }
         Py_DECREF(forward_analyse);
     }
@@ -2804,7 +3052,9 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
         if (!data.base_kwds) {
             return false;
         }
-        if (has_private_func) PyDict_DelItemString(data.base_kwds, "private_func");
+        if (has_private_func) {
+            if (PyDict_DelItemString(data.base_kwds, "private_func") < 0) return false;
+        }
     }
 
     return true;
@@ -3610,54 +3860,78 @@ static const char* PrivateAttrBase_doc = "The class to help to create private at
 static PyObject*
 create_private_attr_base_simple(void) noexcept
 {
-    PyObject* name = PyUnicode_InternFromString("PrivateAttrBase");
-    if (!name) return NULL;
-    PyObject* bases = PyTuple_New(0);
-    if (!bases) {
-        Py_DECREF(name);
-        return NULL;
-    }
-    PyObject* dict = PyDict_New();
-    if (!dict) {
-        Py_DECREF(name);
-        Py_DECREF(bases);
-        return NULL;
-    }
-    PyObject *private_attrs = PyTuple_New(0);
-    if (!private_attrs) {
-        Py_DECREF(name);
-        Py_DECREF(bases);
-        Py_DECREF(dict);
-        return NULL;
-    }
-    PyDict_SetItemString(dict, "__private_attrs__", private_attrs);
-    PyDict_SetItemString(dict, "__slots__", private_attrs);
-    PyDict_SetItemString(dict, "__doc__", PyUnicode_InternFromString(PrivateAttrBase_doc));
-    PyDict_SetItemString(dict, "__module__", PyUnicode_InternFromString("private_attribute"));
-    PyObject *args = PyTuple_Pack(3, name, bases, dict);
-    PyObject* base_type;
-    if (args) {
+    PyObject* name = NULL;
+    PyObject* bases = NULL;
+    PyObject* dict = NULL;
+    PyObject* private_attrs = NULL;
+    PyObject* doc = NULL;
+    PyObject* module_name = NULL;
+    PyObject* args = NULL;
+    PyObject* base_type = NULL;
+
+    name = PyUnicode_InternFromString("PrivateAttrBase");
+    if (!name) goto fail;
+
+    bases = PyTuple_New(0);
+    if (!bases) goto fail;
+
+    dict = PyDict_New();
+    if (!dict) goto fail;
+
+    private_attrs = PyTuple_New(0);
+    if (!private_attrs) goto fail;
+
+    doc = PyUnicode_InternFromString(PrivateAttrBase_doc);
+    if (!doc) goto fail;
+
+    module_name = PyUnicode_InternFromString("private_attribute");
+    if (!module_name) goto fail;
+
+    if (PyDict_SetItemString(dict, "__private_attrs__", private_attrs) < 0) goto fail;
+    if (PyDict_SetItemString(dict, "__slots__", private_attrs) < 0) goto fail;
+    if (PyDict_SetItemString(dict, "__doc__", doc) < 0) goto fail;
+    if (PyDict_SetItemString(dict, "__module__", module_name) < 0) goto fail;
+
+    Py_DECREF(doc);
+    doc = NULL;
+    Py_DECREF(module_name);
+    module_name = NULL;
+
+    args = PyTuple_Pack(3, name, bases, dict);
+    if (!args) goto fail;
+
+    {
         // RAII: the first heap type created through tp_new (PrivateAttrBase)
         // carries CPython's pristine subtype_traverse/subtype_clear in its
         // tp_traverse/tp_clear; PrivateAttrType_new captures those pointers
         // while this guard is active.
         PrivateAttrCaptureGuard capture_guard;
         base_type = PrivateAttrType_new((PyTypeObject*)&PrivateAttrType, args, NULL);
-        Py_DECREF(args);
-    } else {
-        Py_DECREF(name);
-        Py_DECREF(bases);
-        Py_DECREF(dict);
-        return NULL;
     }
+    Py_DECREF(args);
+    args = NULL;
+
     Py_DECREF(name);
+    name = NULL;
     Py_DECREF(bases);
+    bases = NULL;
     Py_DECREF(dict);
-    if (!base_type) {
-        return NULL;
-    }
+    dict = NULL;
+
+    if (!base_type) goto fail;
+
     ((PyTypeObject*)base_type)->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
     return base_type;
+
+fail:
+    Py_XDECREF(name);
+    Py_XDECREF(bases);
+    Py_XDECREF(dict);
+    Py_XDECREF(private_attrs);
+    Py_XDECREF(doc);
+    Py_XDECREF(module_name);
+    Py_XDECREF(args);
+    return NULL;
 }
 
 typedef struct {
@@ -4496,6 +4770,7 @@ PyInit_private_attribute(void) noexcept
     }
     if (init_all_slots() <0 ||
         atexit_register_clean_func() < 0 ||
+        PyType_Ready(&listproxyType) < 0 ||
         PyType_Ready(&PrivateWrapType) < 0 ||
         PyType_Ready(&PrivateWrapProxyType) < 0 ||
         PyType_Ready(&PrivateAttrType) < 0 ||

{private_attribute_cpp-2.1.18 → private_attribute_cpp-2.1.20}/private_attribute.pyi

@@ -15,8 +15,9 @@ class MyClass(PrivateAttrBase):
         return self._private_attr1
 ```
 """
-from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic, Optional, cast
+from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic, Optional, cast, Iterator
 from types import FunctionType
+import sys
 
 # define the dict that must have a key "__private_attrs__" and value must be the sequence of strings
 class _PrivateAttrDict(TypedDict):
@@ -24,6 +25,16 @@ class _PrivateAttrDict(TypedDict):
 
 _T = TypeVar('_T')
 
+class listproxy(Generic[_T]):
+    "a read-only proxy of a list"
+    def copy(self) -> list[_T]: ...
+    def count(self, value: Any, /) -> int: ...
+    def index(self, value: Any, start: int = 0, stop: int = sys.maxsize, /) -> int: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __getitem__(self, key: int | slice) -> Any: ...
+    def __contains__(self, value: object) -> bool: ...
+
 class _PrivateWrap(Generic[_T]):
     @property
     def result(self) -> _T:
@@ -31,7 +42,7 @@ class _PrivateWrap(Generic[_T]):
         ...
 
     @property
-    def funcs(self) -> tuple[FunctionType]:
+    def funcs(self) -> listproxy[FunctionType]:
         "the original functions"
         ...
 

{private_attribute_cpp-2.1.18 → private_attribute_cpp-2.1.20/private_attribute_cpp.egg-info}/PKG-INFO

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

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