private-attribute-cpp 1.3.3__tar.gz → 1.3.5__tar.gz

private_attribute_cpp-1.3.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Locked-chess-official
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{private_attribute_cpp-1.3.3/private_attribute_cpp.egg-info → private_attribute_cpp-1.3.5}/PKG-INFO

@@ -1,18 +1,20 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.3.3
+Version: 1.3.5
 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
 Author-email: 13140752715@example.com
 License: MIT
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: summary
 
 # Private Attribute (c++ implementation)
@@ -247,7 +249,6 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - Finally the `_PrivateWrap` object will be recoveried to the original object.
 - One class defined in another class cannot use another class's private attribute.
 - One parent class defined an attribute which not in `__private_attrs__` or not a `PrivateAttrType` instance, the child class shouldn't contain the attribute in its `__private_attrs__`.
-- When combine with other metaclass, be ensure that the parent metaclass has no classmethod that can set subclasses' attributes. If it has, it will fail on new metaclass because the new metaclass you defined and registered will be immutable.
 - CPython may change "tp_getattro", "tp_setattro" and so on when you change the attribute "\_\_getattribute\_\_", "\_\_setattr\_\_" and so on. If you are fear about it, you can use `ensure_type` to reset those tp slots. For the other metaclasses, you can use `ensure_metaclass` to reset those tp slots. Also, don't set those methods on these classes in your code.
 
 ## License

{private_attribute_cpp-1.3.3 → private_attribute_cpp-1.3.5}/README.md

@@ -230,7 +230,6 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - Finally the `_PrivateWrap` object will be recoveried to the original object.
 - One class defined in another class cannot use another class's private attribute.
 - One parent class defined an attribute which not in `__private_attrs__` or not a `PrivateAttrType` instance, the child class shouldn't contain the attribute in its `__private_attrs__`.
-- When combine with other metaclass, be ensure that the parent metaclass has no classmethod that can set subclasses' attributes. If it has, it will fail on new metaclass because the new metaclass you defined and registered will be immutable.
 - CPython may change "tp_getattro", "tp_setattro" and so on when you change the attribute "\_\_getattribute\_\_", "\_\_setattr\_\_" and so on. If you are fear about it, you can use `ensure_type` to reset those tp slots. For the other metaclasses, you can use `ensure_metaclass` to reset those tp slots. Also, don't set those methods on these classes in your code.
 
 ## License

{private_attribute_cpp-1.3.3 → private_attribute_cpp-1.3.5}/private_attribute.cpp

@@ -816,11 +816,10 @@ type_delattr(PyObject* typ, std::string attr_name)
 // ================================================================
 // _PrivateWrap
 // ================================================================
-typedef struct PrivateWrapObject {
+typedef struct {
     PyObject_HEAD
     PyObject *result;
     PyObject *func_list;
-    PyObject *decorator;
 } PrivateWrapObject;
 
 static PrivateWrapObject* PrivateWrap_New(PyObject *decorator, PyObject *func, PyObject *list);
@@ -935,16 +934,19 @@ PrivateWrap_type_params(PyObject* obj, void* /*closure*/)
     return type_params;
 }
 
+static const char* PrivateWrap_result_doc = "the final result of decorating";
+static const char* PrivateWrap_funcs_doc = "the original functions";
+
 static PyGetSetDef PrivateWrap_getset[] = {
-    {"result", (getter)PrivateWrap_result, NULL, "final result", NULL},
-    {"funcs", (getter)PrivateWrap_funcs, NULL, "funcs", NULL},
-    {"__wrapped__", (getter)PrivateWrap_result, NULL, "final result", NULL},
-    {"__doc__", (getter)PrivateWrap_doc, NULL, "doc", NULL},
-    {"__module__", (getter)PrivateWrap_module, NULL, "module", NULL},
-    {"__name__", (getter)PrivateWarp_name, NULL, "name", NULL},
-    {"__qualname__", (getter)PrivateWrap_qualname, NULL, "qualname", NULL},
-    {"__annotate__", (getter)PrivateWrap_annotate, NULL, "annotate", NULL},
-    {"__type_params__", (getter)PrivateWrap_type_params, NULL, "type_params", NULL},
+    {"result", (getter)PrivateWrap_result, NULL, PrivateWrap_result_doc, NULL},
+    {"funcs", (getter)PrivateWrap_funcs, NULL, PrivateWrap_funcs_doc, NULL},
+    {"__wrapped__", (getter)PrivateWrap_result, NULL, NULL, NULL},
+    {"__doc__", (getter)PrivateWrap_doc, NULL, NULL, NULL},
+    {"__module__", (getter)PrivateWrap_module, NULL, NULL, NULL},
+    {"__name__", (getter)PrivateWarp_name, NULL, NULL, NULL},
+    {"__qualname__", (getter)PrivateWrap_qualname, NULL, NULL, NULL},
+    {"__annotate__", (getter)PrivateWrap_annotate, NULL, NULL, NULL},
+    {"__type_params__", (getter)PrivateWrap_type_params, NULL, NULL, NULL},
     {NULL}
 };
 
@@ -1006,9 +1008,6 @@ PrivateWrap_New(PyObject *decorator, PyObject *func, PyObject *list)
         return NULL;
     }
 
-    self->decorator = decorator;
-    Py_INCREF(decorator);
-
     self->func_list = list;
     Py_INCREF(list);
 
@@ -1022,7 +1021,6 @@ PrivateWrap_dealloc(PrivateWrapObject *self)
 {
     Py_XDECREF(self->result);
     Py_XDECREF(self->func_list);
-    Py_XDECREF(self->decorator);
     Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
@@ -1070,6 +1068,35 @@ PrivateWrapProxy_call(PrivateWrapProxyObject *self, PyObject *args, PyObject* /*
 
 static void PrivateWrapProxy_dealloc(PrivateWrapProxyObject *self);
 static PyObject* PrivateWrapProxy_New(PyTypeObject *type, PyObject *args, PyObject *kwds);
+static const char* PrivateWrapProxy_doc = R"(
+PrivateWrapProxy is a proxy for private attributes.
+Usage:
+```
+from private_attribute import PrivateWrapProxy, PrivateAttrBase
+
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ()
+    @PrivateWrapProxy(decorator)
+    def my_method(self): ...
+
+    @PrivateWrapProxy(decorator)
+    def my_method2(self): ...
+```
+It returned a '_PrivateWrap' object.
+
+If you need to decorate more function, use like this:
+```
+from private_attribute import PrivateWrapProxy, PrivateAttrBase
+
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ()
+    @PrivateWrapProxy(decorator)
+    def my_method(self): ...
+
+    @PrivateWrapProxy(my_method.some_decorator, my_method)
+    def my_method(self): ...
+```
+)";
 
 static PyTypeObject PrivateWrapProxyType = {
     PyVarObject_HEAD_INIT(NULL, 0)
@@ -1092,7 +1119,7 @@ static PyTypeObject PrivateWrapProxyType = {
     0,                                      // tp_setattro
     0,                                      // tp_as_buffer
     Py_TPFLAGS_DEFAULT,                     // tp_flags
-    "PrivateWrapProxy",                     // tp_doc
+    PrivateWrapProxy_doc,                   // tp_doc
     0,                                      // tp_traverse
     0,                                      // tp_clear
     0,                                      // tp_richcompare
@@ -1307,66 +1334,45 @@ static PyObject* PrivateAttrType_getattr(PyObject* cls, PyObject* name);
 static int PrivateAttrType_setattr(PyObject* cls, PyObject* name, PyObject* value);
 static void PrivateAttrType_del(PyObject* cls);
 
-static int
-PrivateAttrType_init(PyObject* self, PyObject* args, PyObject* kwds)
-{
-    PyTypeObject* base = Py_TYPE(self);
-    while (base->tp_init == PrivateAttrType_init) {
-        base = base->tp_base;
-    }
-    if (base->tp_init == NULL) {
-        int result = PyType_Type.tp_init(self, args, kwds);
-        if (result == 0) {
-            ensure_tp((PyTypeObject*)self);
-        }
-        return result;
-    }
-    int result = base->tp_init(self, args, kwds);
-    if (result == 0) {
-        ensure_tp((PyTypeObject*)self);
-    }
-    return result;
-}
-
 static PyTypeObject PrivateAttrType = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    "private_attribute.PrivateAttrType",    // tp_name
-    sizeof(PrivateAttrTypeObject),          // tp_basicsize
-    0,                                      // tp_itemsize
-    (destructor)PrivateAttrType_del,        // 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
-    0,                                      // tp_call
-    0,                                      // tp_str
-    (getattrofunc)PrivateAttrType_getattr,  // tp_getattro
-    (setattrofunc)PrivateAttrType_setattr,  // tp_setattro
-    0,                                      // tp_as_buffer
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,    // tp_flags
-    "metaclass for private attributes",     // tp_doc
-    0,                                      // tp_travers
-    0,                                      // tp_clear
-    0,                                      // tp_richcompare
-    0,                                      // tp_weaklistoffset
-    0,                                      // tp_iter
-    0,                                      // tp_iternext
-    0,                                      // tp_methods
-    0,                                      // tp_members
-    0,                                      // tp_getset
-    &PyType_Type,                           // tp_base
-    0,                                      // tp_dict
-    0,                                      // tp_descr_get
-    0,                                      // tp_descr_set
-    0,                                      // tp_dictoffset
-    PrivateAttrType_init,                   // tp_init
-    0,                                      // tp_alloc
-    (newfunc)PrivateAttrType_new,           // tp_new
+    "private_attribute.PrivateAttrType",        // tp_name
+    sizeof(PrivateAttrTypeObject),              // tp_basicsize
+    0,                                          // tp_itemsize
+    (destructor)PrivateAttrType_del,            // 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
+    0,                                          // tp_call
+    0,                                          // tp_str
+    (getattrofunc)PrivateAttrType_getattr,      // tp_getattro
+    (setattrofunc)PrivateAttrType_setattr,      // tp_setattro
+    0,                                          // tp_as_buffer
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,   // tp_flags
+    "metaclass for private attributes",         // tp_doc
+    0,                                          // tp_travers
+    0,                                          // tp_clear
+    0,                                          // tp_richcompare
+    0,                                          // tp_weaklistoffset
+    0,                                          // tp_iter
+    0,                                          // tp_iternext
+    0,                                          // tp_methods
+    0,                                          // tp_members
+    0,                                          // tp_getset
+    &PyType_Type,                               // tp_base
+    0,                                          // tp_dict
+    0,                                          // tp_descr_get
+    0,                                          // tp_descr_set
+    0,                                          // tp_dictoffset
+    0,                                          // tp_init
+    0,                                          // tp_alloc
+    (newfunc)PrivateAttrType_new,               // tp_new
 };
 
 static PyObject*
@@ -2027,6 +2033,7 @@ ensure_subclass_tp(PyTypeObject* type_instance)
             continue;
         }
         ensure_tp((PyTypeObject*)subclass);
+        ensure_subclass_tp((PyTypeObject*)subclass);
     }
     Py_DECREF(type_subclasses);
 }
@@ -2303,6 +2310,8 @@ PrivateAttrType_del(PyObject* cls)
     (Py_TYPE(cls))->tp_free(cls);
 }
 
+static const char* PrivateAttrBase_doc = "The class to help to create private attribute. It does not have any special behavior.";
+
 // PrivateAttrBase
 static PyObject*
 create_private_attr_base_simple(void)
@@ -2329,6 +2338,7 @@ create_private_attr_base_simple(void)
     }
     PyDict_SetItemString(dict, "__private_attrs__", private_attrs);
     PyDict_SetItemString(dict, "__slots__", private_attrs);
+    PyDict_SetItemString(dict, "__doc__", PyUnicode_FromString(PrivateAttrBase_doc));
     PyObject *args = PyTuple_Pack(3, name, bases, dict);
     PyObject* base_type;
     if (args) {
@@ -2362,7 +2372,7 @@ PrivateTempObject_name(PyObject* self, void* /*closure*/)
 {
     PyObject* name = ((PrivateTempObject*)self)->tmp->name;
     if (!name) {
-        PyErr_SetString(PyExc_RuntimeError, "object not init");
+        PyErr_SetString(PyExc_RuntimeError, "object not init or have been used");
         return nullptr;
     }
     Py_INCREF(name);
@@ -2374,7 +2384,7 @@ PrivateTempObject_base(PyObject* self, void* /*closure*/)
 {
     PyObject* base = ((PrivateTempObject*)self)->tmp->bases;
     if (!base) {
-        PyErr_SetString(PyExc_RuntimeError, "object not init");
+        PyErr_SetString(PyExc_RuntimeError, "object not init or have been used");
         return nullptr;
     }
     Py_INCREF(base);
@@ -2386,7 +2396,7 @@ PrivateTempObject_attrs(PyObject* self, void* /*closure*/)
 {
     PyObject* attrs = ((PrivateTempObject*)self)->tmp->attrs_copy;
     if (!attrs) {
-        PyErr_SetString(PyExc_RuntimeError, "object not init");
+        PyErr_SetString(PyExc_RuntimeError, "object not init or have been used");
         return nullptr;
     }
     Py_INCREF(attrs);
@@ -2398,7 +2408,7 @@ PrivateTempObject_kwds(PyObject* self, void* /*closure*/)
 {
     PyObject* kwds = ((PrivateTempObject*)self)->tmp->base_kwds;
     if (!kwds) {
-        PyErr_SetString(PyExc_RuntimeError, "object not init");
+        PyErr_SetString(PyExc_RuntimeError, "object not init or have been used");
         return nullptr;
     }
     Py_INCREF(kwds);
@@ -2406,10 +2416,10 @@ PrivateTempObject_kwds(PyObject* self, void* /*closure*/)
 }
 
 static PyGetSetDef PrivateTempObject_getsets[] = {
-    {"name", (getter)PrivateTempObject_name, NULL, NULL, NULL},
-    {"bases", (getter)PrivateTempObject_base, NULL, NULL, NULL},
-    {"attrs", (getter)PrivateTempObject_attrs, NULL, NULL, NULL},
-    {"kwds", (getter)PrivateTempObject_kwds, NULL, NULL, NULL},
+    {"name", (getter)PrivateTempObject_name, NULL, "The name for submetaclass.__new__ argument 1", NULL},
+    {"bases", (getter)PrivateTempObject_base, NULL, "The base classes for submetaclass.__new__ argument 2", NULL},
+    {"attrs", (getter)PrivateTempObject_attrs, NULL, "The attributes for submetaclass.__new__ argument 3", NULL},
+    {"kwds", (getter)PrivateTempObject_kwds, NULL, "The keyword arguments for submetaclass.__new__", NULL},
     {NULL}
 };
 
@@ -2457,15 +2467,19 @@ static PyTypeObject PrivateTempType = {
 static PyObject*
 prepare_for_PrivateAttr(PyObject* /*self*/, PyObject* args, PyObject* kwargs)
 {
-    PrivateTempObject* tmp = PyObject_New(PrivateTempObject, &PrivateTempType);
-    if (!tmp) {
+    PrivateAttrCreationData* tmp_data = new PrivateAttrCreationData();
+    if (!PrivateAttrType_preprocess(args, kwargs, *tmp_data)) {
+        tmp_data->clear();
+        delete tmp_data;
         return NULL;
     }
-    tmp->tmp = new PrivateAttrCreationData();
-    if (!PrivateAttrType_preprocess(args, kwargs, *(tmp->tmp))) {
-        Py_DECREF(tmp);
+    PrivateTempObject* tmp = PyObject_New(PrivateTempObject, &PrivateTempType);
+    if (!tmp) {
+        tmp_data->clear();
+        delete tmp_data;
         return NULL;
     }
+    tmp->tmp = tmp_data;
     return (PyObject*)tmp;
 }
 
@@ -2526,8 +2540,6 @@ register_metaclass(PyObject* /*self*/, PyObject* metaclass)
     ((PyTypeObject*)metaclass)->tp_getattro = PrivateAttrType_getattr;
     ((PyTypeObject*)metaclass)->tp_setattro = PrivateAttrType_setattr;
     ((PyTypeObject*)metaclass)->tp_finalize = register_finalize;
-    ((PyTypeObject*)metaclass)->tp_init = PrivateAttrType_init;
-    ((PyTypeObject*)metaclass)->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
     Py_RETURN_NONE;
 }
 
@@ -2554,7 +2566,6 @@ ensure_metaclass_tp(PyObject* /*self*/, PyObject* metaclass)
         ((PyTypeObject*)metaclass)->tp_getattro = PrivateAttrType_getattr;
         ((PyTypeObject*)metaclass)->tp_setattro = PrivateAttrType_setattr;
         ((PyTypeObject*)metaclass)->tp_finalize = register_finalize;
-        ((PyTypeObject*)metaclass)->tp_init = PrivateAttrType_init;
     }
     Py_RETURN_NONE;
 }
@@ -2638,13 +2649,51 @@ static PyGetSetDef PrivateModule_getsetters[] = {
     {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:
+    the function to prepare for creating private attributes class. It will return a temporary object which has the same information as the arguments.
+
+def postprocess(type: type, tmp: tempobject) -> None:
+    the function to postprocess for creating private attributes class. The custom metaclass can call this
+
+def register_metaclass(metaclass: type) -> None:
+    the function to register custom metaclass. The custom metaclass must call this function to register itself before creating any private attributes class,
+    otherwise the private attributes class created by this custom metaclass will not work.
+
+All usage of this module should be like:
+```
+from abc import ABCMeta
+import private_attribute
+
+class PrivateAbcMeta(ABCMeta):
+    def __new__(cls, *args, **kwargs):
+        temp = private_attribute.prepare(*args, **kwargs)
+        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+        private_attribute.postprocess(typ, temp)
+        return typ
+
+private_attribute.register_metaclass(PrivateAbcMeta)
+```
+)";
+
+static const char* ensure_type_doc = R"(function for custom metaclass to ensure the type is a private attributes class.
+def ensure_type(type: type) -> None:
+    the function to ensure the type is a private attributes class `tp_getattro`, `tp_setattro` and `tp_finalizer`.
+)";
+
+static const char* ensure_metaclass_doc = R"(function for custom metaclass to ensure the metaclass is working.
+def ensure_metaclass(metaclass: type) -> None:
+    the function to ensure the metaclass `tp_getattro`, `tp_setattro` and `tp_finalizer`.
+)";
+
 static PyMethodDef PrivateModule_methods[] = {
     {"__dir__", (PyCFunction)PrivateModule_dir, METH_NOARGS, NULL},
-    {"prepare", (PyCFunction)prepare_for_PrivateAttr, METH_VARARGS | METH_KEYWORDS, NULL},
-    {"postprocess", (PyCFunction)postprocess_for_PrivateAttr, METH_VARARGS, NULL},
-    {"register_metaclass", (PyCFunction)register_metaclass, METH_O, NULL},
-    {"ensure_type", (PyCFunction)ensure_type_tp, METH_O, NULL},
-    {"ensure_metaclass", (PyCFunction)ensure_metaclass_tp, METH_O, NULL},
+    {"prepare", (PyCFunction)prepare_for_PrivateAttr, METH_VARARGS | METH_KEYWORDS, prepare_and_postprocess_doc},
+    {"postprocess", (PyCFunction)postprocess_for_PrivateAttr, METH_VARARGS, prepare_and_postprocess_doc},
+    {"register_metaclass", (PyCFunction)register_metaclass, METH_O, prepare_and_postprocess_doc},
+    {"ensure_type", (PyCFunction)ensure_type_tp, METH_O, ensure_type_doc},
+    {"ensure_metaclass", (PyCFunction)ensure_metaclass_tp, METH_O, ensure_metaclass_doc},
     {NULL}  // Sentinel
 };
 
@@ -2682,10 +2731,29 @@ static PyTypeObject PrivateModuleType = {
     &PyModule_Type, //tp_base
 };
 
+static const char* module_doc = R"(
+A module that provides a metaclass for creating classes with private attributes.
+Private attributes are defined in the `__private_attrs__` sequence and are only
+You can use the `PrivateAttrBase` metaclass to create classes with private attributes.
+The attributes which are private are not on the instance's `__dict__` and cannot be accessed outside
+but in the methods defined in class it is reachable.
+Usage example:
+```python
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ('_private_attr1',)
+    def __init__(self):
+        self._private_attr1 = 1
+
+    @property
+    def public_attr1(self):
+        return self._private_attr1
+```
+)";
+
 static PyModuleDef def = {
     PyModuleDef_HEAD_INIT,
     "private_attribute",
-    NULL,
+    module_doc,
     0,
     NULL,
     NULL,

private_attribute_cpp-1.3.5/private_attribute.pyi

@@ -0,0 +1,200 @@
+"""A module that provides a metaclass for creating classes with private attributes.
+Private attributes are defined in the `__private_attrs__` sequence and are only
+You can use the `PrivateAttrBase` metaclass to create classes with private attributes.
+The attributes which are private are not on the instance's `__dict__` and cannot be accessed outside
+but in the methods defined in class it is reachable.
+Usage example:
+```python
+class MyClass(PrivateAttrBase):
+    __private_attrs__ = ('_private_attr1',)
+    def __init__(self):
+        self._private_attr1 = 1
+
+    @property
+    def public_attr1(self):
+        return self._private_attr1
+```
+"""
+from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic
+from types import FunctionType
+
+# define the dict that must have a key "__private_attrs__" and value must be the sequence of strings
+class PrivateAttrDict(TypedDict):
+    __private_attrs__: Sequence[str]
+
+T = TypeVar('T')
+
+class _PrivateWrap(Generic[T]):
+    @property
+    def result(self) -> T:
+        "the final result of decorating"
+        ...
+
+    @property
+    def funcs(self) -> tuple[FunctionType]:
+        "the original functions"
+        ...
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.result, name)
+
+TVar = TypeVar('TVar')
+
+class PrivateWrapProxy:
+    """
+    PrivateWrapProxy is a proxy for private attributes.
+    Usage:
+    ```
+    from private_attribute import PrivateWrapProxy, PrivateAttrBase
+
+    class MyClass(PrivateAttrBase):
+        __private_attrs__ = ()
+        @PrivateWrapProxy(decorator)
+        def my_method(self): ...
+
+        @PrivateWrapProxy(decorator)
+        def my_method2(self): ...
+    ```
+    It returned a '_PrivateWrap' object.
+
+    If you need to decorate more function, use like this:
+    ```
+    from private_attribute import PrivateWrapProxy, PrivateAttrBase
+
+    class MyClass(PrivateAttrBase):
+        __private_attrs__ = ()
+        @PrivateWrapProxy(decorator)
+        def my_method(self): ...
+
+        @PrivateWrapProxy(my_method.some_decorator, my_method)
+        def my_method(self): ...
+    ```
+    """
+    def __init__(self, decorator: Callable[[TVar], T], orig: _PrivateWrap[Any]|None = None, /) -> None: ...
+    def __call__(self, func: TVar, /) -> _PrivateWrap[T]: ...
+
+class PrivateAttrType(type):
+    "metaclass for private attributes"
+    def __new__(cls, name: str, bases: tuple,
+                attrs: PrivateAttrDict, /,
+                private_func: Callable[[int, str], str]|None = None) -> PrivateAttrType: ...
+
+class PrivateAttrBase(metaclass=PrivateAttrType):
+    "The class to help to create private attribute. It does not have any special behavior."
+    __slots__ = ()
+    __private_attrs__ = ()
+
+
+class _PrivateTemp:
+    @property
+    def name(self) -> str: ...
+    @property
+    def bases(self) -> tuple[type]: ...
+    @property
+    def attrs(self) -> dict[str, Any]: ...
+    @property
+    def kwds(self) -> dict[str, Any]: ...
+
+def prepare(name: str, bases: tuple, attrs: PrivateAttrDict, /, **kwds) -> _PrivateTemp:
+    """
+    function for custom metaclass to create private attributes class.
+
+    def prepare(name: str, bases: tuple, attrs: dict, **kwds) -> tempobject:
+        the function to prepare for creating private attributes class. It will return a temporary object which has the same information as the arguments.
+
+    def postprocess(type: type, tmp: tempobject) -> None:
+        the function to postprocess for creating private attributes class. The custom metaclass can call this
+
+    def register_metaclass(metaclass: type) -> None:
+        the function to register custom metaclass. The custom metaclass must call this function to register itself before creating any private attributes class,
+        otherwise the private attributes class created by this custom metaclass will not work.
+
+    All usage of this module should be like:
+    ```
+    from abc import ABCMeta
+    import private_attribute
+
+    class PrivateAbcMeta(ABCMeta):
+        def __new__(cls, *args, **kwargs):
+            temp = private_attribute.prepare(*args, **kwargs)
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
+
+    private_attribute.register_metaclass(PrivateAbcMeta)
+    ```
+    """
+    ...
+
+def postprocess(typ: type, temp: _PrivateTemp, /) -> None:
+    """
+    function for custom metaclass to create private attributes class.
+
+    def prepare(name: str, bases: tuple, attrs: dict, **kwds) -> tempobject:
+        the function to prepare for creating private attributes class. It will return a temporary object which has the same information as the arguments.
+
+    def postprocess(type: type, tmp: tempobject) -> None:
+        the function to postprocess for creating private attributes class. The custom metaclass can call this
+
+    def register_metaclass(metaclass: type) -> None:
+        the function to register custom metaclass. The custom metaclass must call this function to register itself before creating any private attributes class,
+        otherwise the private attributes class created by this custom metaclass will not work.
+
+    All usage of this module should be like:
+    ```
+    from abc import ABCMeta
+    import private_attribute
+
+    class PrivateAbcMeta(ABCMeta):
+        def __new__(cls, *args, **kwargs):
+            temp = private_attribute.prepare(*args, **kwargs)
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
+
+    private_attribute.register_metaclass(PrivateAbcMeta)
+    ```
+    """
+    ...
+def register_metaclass(typ: type, /) -> None:
+    """
+    function for custom metaclass to create private attributes class.
+
+    def prepare(name: str, bases: tuple, attrs: dict, **kwds) -> tempobject:
+        the function to prepare for creating private attributes class. It will return a temporary object which has the same information as the arguments.
+
+    def postprocess(type: type, tmp: tempobject) -> None:
+        the function to postprocess for creating private attributes class. The custom metaclass can call this
+
+    def register_metaclass(metaclass: type) -> None:
+        the function to register custom metaclass. The custom metaclass must call this function to register itself before creating any private attributes class,
+        otherwise the private attributes class created by this custom metaclass will not work.
+
+    All usage of this module should be like:
+    ```
+    from abc import ABCMeta
+    import private_attribute
+
+    class PrivateAbcMeta(ABCMeta):
+        def __new__(cls, *args, **kwargs):
+            temp = private_attribute.prepare(*args, **kwargs)
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
+
+    private_attribute.register_metaclass(PrivateAbcMeta)
+    ```
+    """
+    ...
+def ensure_type(typ: type, /) -> None:
+    """function for custom metaclass to ensure the type is a private attributes class.
+    def ensure_type(type: type) -> None:
+        the function to ensure the type is a private attributes class `tp_getattro`, `tp_setattro` and `tp_finalizer`.
+    """
+    ...
+def ensure_metaclass(typ: type, /) -> None:
+    """function for custom metaclass to ensure the metaclass is working.
+    def ensure_metaclass(metaclass: type) -> None:
+        the function to ensure the metaclass `tp_getattro`, `tp_setattro` and `tp_finalizer`.
+    """
+    ...

{private_attribute_cpp-1.3.3 → private_attribute_cpp-1.3.5/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,18 +1,20 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.3.3
+Version: 1.3.5
 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
 Author-email: 13140752715@example.com
 License: MIT
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: summary
 
 # Private Attribute (c++ implementation)
@@ -247,7 +249,6 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - Finally the `_PrivateWrap` object will be recoveried to the original object.
 - One class defined in another class cannot use another class's private attribute.
 - One parent class defined an attribute which not in `__private_attrs__` or not a `PrivateAttrType` instance, the child class shouldn't contain the attribute in its `__private_attrs__`.
-- When combine with other metaclass, be ensure that the parent metaclass has no classmethod that can set subclasses' attributes. If it has, it will fail on new metaclass because the new metaclass you defined and registered will be immutable.
 - CPython may change "tp_getattro", "tp_setattro" and so on when you change the attribute "\_\_getattribute\_\_", "\_\_setattr\_\_" and so on. If you are fear about it, you can use `ensure_type` to reset those tp slots. For the other metaclasses, you can use `ensure_metaclass` to reset those tp slots. Also, don't set those methods on these classes in your code.
 
 ## License

{private_attribute_cpp-1.3.3 → private_attribute_cpp-1.3.5}/private_attribute_cpp.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 MANIFEST.in
 README.md
 picosha2.h

{private_attribute_cpp-1.3.3 → private_attribute_cpp-1.3.5}/setup.py

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

private_attribute_cpp-1.3.3/private_attribute.pyi

@@ -1,50 +0,0 @@
-from typing import Any, TypeVar, Callable, TypedDict, Sequence, Generic
-from types import FunctionType
-
-# define the dict that must have a key "__private_attrs__" and value must be the sequence of strings
-class PrivateAttrDict(TypedDict):
-    __private_attrs__: Sequence[str]
-
-T = TypeVar('T')
-
-class _PrivateWrap(Generic[T]):
-    @property
-    def result(self) -> T: ...
-
-    @property
-    def funcs(self) -> tuple[FunctionType]: ...
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self.result, name)
-
-TVar = TypeVar('TVar')
-
-class PrivateWrapProxy:
-    def __init__(self, decorator: Callable[[TVar], T], orig: _PrivateWrap[Any]|None = None, /) -> None: ...
-    def __call__(self, func: TVar, /) -> _PrivateWrap[T]: ...
-
-class PrivateAttrType(type):
-    def __new__(cls, name: str, bases: tuple,
-                attrs: PrivateAttrDict, /,
-                private_func: Callable[[int, str], str]|None = None) -> PrivateAttrType: ...
-
-class PrivateAttrBase(metaclass=PrivateAttrType):
-    __slots__ = ()
-    __private_attrs__ = ()
-
-
-class _PrivateTemp:
-    @property
-    def name(self) -> str: ...
-    @property
-    def bases(self) -> tuple[type]: ...
-    @property
-    def attrs(self) -> dict[str, Any]: ...
-    @property
-    def kwds(self) -> dict[str, Any]: ...
-
-def prepare(name: str, bases: tuple, attrs: PrivateAttrDict, /, **kwds) -> _PrivateTemp: ...
-def postprocess(typ: type, temp: _PrivateTemp, /) -> None: ...
-def register_metaclass(typ: type, /) -> None: ...
-def ensure_type(typ: type, /) -> None: ...
-def ensure_metaclass(typ: type, /) -> None: ...