private-attribute-cpp 2.1.17__tar.gz → 2.1.19__tar.gz

{private_attribute_cpp-2.1.17/private_attribute_cpp.egg-info → private_attribute_cpp-2.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.1.17
+Version: 2.1.19
 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.17 → private_attribute_cpp-2.1.19}/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_FromLong(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*
@@ -1120,41 +1384,67 @@ PrivateWrap_descrset(PyObject* obj, PyObject* name, PyObject* value) noexcept
     }
 }
 
+static int
+PrivateWrap_traverse(PyObject* obj, visitproc visit, void* arg) noexcept
+{
+    PrivateWrapObject* self = (PrivateWrapObject*)obj;
+    if (self->result) {
+        Py_VISIT(self->result);
+    }
+    if (self->func_list) {
+        Py_VISIT(self->func_list);
+    }
+    return 0;
+}
+
+static int
+PrivateWrap_clear(PyObject* obj) noexcept
+{
+    PrivateWrapObject* self = (PrivateWrapObject*)obj;
+    if (self->result) {
+        Py_CLEAR(self->result);
+    }
+    if (self->func_list) {
+        Py_CLEAR(self->func_list);
+    }
+    return 0;
+}
+
 static PyTypeObject PrivateWrapType = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    "_PrivateWrap",                    // tp_name
-    sizeof(PrivateWrapObject),         // tp_basicsize
-    0,                                 // tp_itemsize
-    (destructor)PrivateWrap_dealloc,   // tp_dealloc
-    0,                                 // tp_print
-    0,                                 // tp_getattr
-    0,                                 // tp_setattr
-    0,                                 // tp_reserved
-    0,                                 // tp_repr
-    0,                                 // tp_as_number
-    0,                                 // tp_as_sequence
-    0,                                 // tp_as_mapping
-    0,                                 // tp_hash
-    (ternaryfunc)PrivateWrap_call,     // tp_call
-    0,                                 // tp_str
-    PrivateWrap_getattro,              // tp_getattro
-    0,                                 // tp_setattro
-    0,                                 // tp_as_buffer
-    Py_TPFLAGS_DEFAULT,                // tp_flags
-    "private_attribute._PrivateWrap",  // tp_doc
-    0,                                 // tp_traverse
-    0,                                 // tp_clear
-    0,                                 // tp_richcompare
-    0,                                 // tp_weaklistoffset
-    0,                                 // tp_iter
-    0,                                 // tp_iternext
-    0,                                 // tp_methods
-    PrivateWrap_members,               // tp_members
-    PrivateWrap_getset,                // tp_getset
-    0,                                 // tp_base
-    0,                                 // tp_dict
-    PrivateWrap_descrget,              // tp_descr_get
-    PrivateWrap_descrset,              // tp_descr_set
+    "private_attribute._PrivateWrap",          // tp_name
+    sizeof(PrivateWrapObject),                 // tp_basicsize
+    0,                                         // tp_itemsize
+    (destructor)PrivateWrap_dealloc,           // tp_dealloc
+    0,                                         // tp_print
+    0,                                         // tp_getattr
+    0,                                         // tp_setattr
+    0,                                         // tp_reserved
+    0,                                         // tp_repr
+    0,                                         // tp_as_number
+    0,                                         // tp_as_sequence
+    0,                                         // tp_as_mapping
+    0,                                         // tp_hash
+    (ternaryfunc)PrivateWrap_call,             // tp_call
+    0,                                         // tp_str
+    PrivateWrap_getattro,                      // tp_getattro
+    0,                                         // tp_setattro
+    0,                                         // tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,   // tp_flags
+    "private_attribute._PrivateWrap",          // tp_doc
+    PrivateWrap_traverse,                      // tp_traverse
+    PrivateWrap_clear,                         // tp_clear
+    0,                                         // tp_richcompare
+    0,                                         // tp_weaklistoffset
+    0,                                         // tp_iter
+    0,                                         // tp_iternext
+    0,                                         // tp_methods
+    PrivateWrap_members,                       // tp_members
+    PrivateWrap_getset,                        // tp_getset
+    0,                                         // tp_base
+    0,                                         // tp_dict
+    PrivateWrap_descrget,                      // tp_descr_get
+    PrivateWrap_descrset,                      // tp_descr_set
 };
 
 static PrivateWrapObject*
@@ -1171,7 +1461,7 @@ PrivateWrap_New(PyObject *decorator, PyObject *func, PyObject *list) noexcept
     }
 
     PrivateWrapObject *self =
-        PyObject_New(PrivateWrapObject, &PrivateWrapType);
+        PyObject_GC_New(PrivateWrapObject, &PrivateWrapType);
     self->func_list = list;
     Py_INCREF(list);
 
@@ -1207,7 +1497,7 @@ static PyObject*
 PrivateWrapProxy_call(PrivateWrapProxyObject *self, PyObject *args, PyObject* /* kwgs */) noexcept
 {
     PyObject *func;
-    if (!PyArg_ParseTuple(args, "O", &func)) return NULL;
+    if (!PyArg_ParseTuple(args, "O:private_attribute.PrivateWrapProxy.__call__", &func)) return NULL;
     if(PyObject_TypeCheck(func, &PrivateWrapType)) {
         return (PyObject*)PrivateWrap_New(
             self->decorator,
@@ -1262,6 +1552,22 @@ class MyClass(PrivateAttrBase):
 ```
 )";
 
+static int
+PrivateWrapProxy_traverse(PrivateWrapProxyObject *self, visitproc visit, void *arg) noexcept
+{
+    Py_VISIT(self->decorator);
+    Py_VISIT(self->func_list);
+    return 0;
+}
+
+static int
+PrivateWrapProxy_clear(PrivateWrapProxyObject *self) noexcept
+{
+    Py_CLEAR(self->decorator);
+    Py_CLEAR(self->func_list);
+    return 0;
+}
+
 static PyTypeObject PrivateWrapProxyType = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "private_attribute.PrivateWrapProxy",   // tp_name
@@ -1282,10 +1588,10 @@ static PyTypeObject PrivateWrapProxyType = {
     0,                                      // tp_getattro
     0,                                      // tp_setattro
     0,                                      // tp_as_buffer
-    Py_TPFLAGS_DEFAULT,                     // tp_flags
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,// tp_flags
     PrivateWrapProxy_doc,                   // tp_doc
-    0,                                      // tp_traverse
-    0,                                      // tp_clear
+    (traverseproc)PrivateWrapProxy_traverse,// tp_traverse
+    (inquiry)PrivateWrapProxy_clear,        // tp_clear
     0,                                      // tp_richcompare
     0,                                      // tp_weaklistoffset
     0,                                      // tp_iter
@@ -1310,7 +1616,7 @@ PrivateWrapProxy_New(PyTypeObject *type, PyObject *args, PyObject* /*kwds*/) noe
     PyObject *decorator;
     PyObject *orig = NULL;
 
-    if (!PyArg_ParseTuple(args, "O|O", &decorator, &orig))
+    if (!PyArg_ParseTuple(args, "O|O:private_attribute.PrivateWrapProxy", &decorator, &orig))
         return NULL;
 
     self = (PrivateWrapProxyObject*)type->tp_alloc(type, 0);
@@ -2522,7 +2828,7 @@ need_analyse_type(PyObject* type) noexcept
 }
 
 static bool
-PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationData& data) noexcept
+PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationData& data, const std::string& func_name = "") noexcept
 {
     static const char* invalid_name[] = {"__private_attrs__", "__slots__", "__getattribute__", "__getattr__", "__init__",
         "__setattr__", "__delattr__", "__name__", "__module__", "__doc__", "__getstate__", "__setstate__",
@@ -2534,7 +2840,11 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
     }
 
     // only parse name, bases, attrs
-    if (!PyArg_ParseTuple(args, "OOO", &data.name, &data.bases, &data.attrs)) {
+    std::string parse = "OOO";
+    if (func_name.length() > 0) {
+        parse += ":" + func_name;
+    }
+    if (!PyArg_ParseTuple(args, parse.c_str(), &data.name, &data.bases, &data.attrs)) {
         return false;
     }
     Py_INCREF(data.name);
@@ -3069,7 +3379,7 @@ PrivateAttrType_new(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
     PrivateAttrCreationData data;
     PyObject* new_type = nullptr;
 
-    if (!PrivateAttrType_preprocess(args, kwds, data)) {
+    if (!PrivateAttrType_preprocess(args, kwds, data, "private_attribute.PrivateAttrType")) {
         return nullptr;
     }
 
@@ -3705,6 +4015,31 @@ static PyMethodDef PrivateTempObject_methods[] = {
     {NULL}
 };
 
+static int
+PrivateTempObject_traverse(PyObject* self, visitproc visit, void* arg) noexcept
+{
+    PrivateTempObject* tmp = (PrivateTempObject*)self;
+    if (tmp->tmp) {
+        PrivateAttrCreationData* data = tmp->tmp;
+        if (!data->cleared) {
+            Py_VISIT(data->attrs_copy);
+            Py_VISIT(data->base_kwds);
+            Py_VISIT(data->attrs);
+        }
+    }
+    return 0;
+}
+
+static int
+PrivateTempObject_clear(PyObject* self) noexcept
+{
+    PrivateTempObject* tmp = (PrivateTempObject*)self;
+    if (tmp->tmp && !tmp->tmp->cleared) {
+        tmp->tmp->clear();
+    }
+    return 0;
+}
+
 static PyTypeObject PrivateTempType = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "private_attribute._PrivateTemp",    // tp_name
@@ -3725,10 +4060,10 @@ static PyTypeObject PrivateTempType = {
     0, //tp_getattro
     0, //tp_setattro
     0, //tp_as_buffer
-    Py_TPFLAGS_DEFAULT, //tp_flags
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, //tp_flags
     0, //tp_doc
-    0, //tp_traverse
-    0, //tp_clear
+    PrivateTempObject_traverse, //tp_traverse
+    PrivateTempObject_clear, //tp_clear
     0, //tp_richcompare
     0, //tp_weaklistoffset
     0, //tp_iter
@@ -3742,12 +4077,12 @@ static PyObject*
 prepare_for_PrivateAttr(PyObject* /*self*/, PyObject* args, PyObject* kwargs) noexcept
 {
     PrivateAttrCreationData* tmp_data = new PrivateAttrCreationData();
-    if (!PrivateAttrType_preprocess(args, kwargs, *tmp_data)) {
+    if (!PrivateAttrType_preprocess(args, kwargs, *tmp_data, "private_attribute.prepare")) {
         tmp_data->clear();
         delete tmp_data;
         return NULL;
     }
-    PrivateTempObject* tmp = PyObject_New(PrivateTempObject, &PrivateTempType);
+    PrivateTempObject* tmp = PyObject_GC_New(PrivateTempObject, &PrivateTempType);
     if (!tmp) {
         tmp_data->clear();
         delete tmp_data;
@@ -4425,6 +4760,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.17 → private_attribute_cpp-2.1.19}/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.17 → private_attribute_cpp-2.1.19/private_attribute_cpp.egg-info}/PKG-INFO

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

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