private-attribute-cpp 1.3.4__tar.gz → 1.3.6__tar.gz

{private_attribute_cpp-1.3.4/private_attribute_cpp.egg-info → private_attribute_cpp-1.3.6}/PKG-INFO

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

@@ -61,7 +61,8 @@ public:
     }
 };
 
-class TwoStringTuple {
+class TwoStringTuple
+{
 private:
     std::string first;
     std::string second;
@@ -127,7 +128,8 @@ namespace {
     };
 };
 
-struct FinalObject {
+struct FinalObject
+{
     PyObject* result = NULL;
     int status = 0;
     FinalObject(PyObject* result)
@@ -816,11 +818,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);
@@ -1009,9 +1010,6 @@ PrivateWrap_New(PyObject *decorator, PyObject *func, PyObject *list)
         return NULL;
     }
 
-    self->decorator = decorator;
-    Py_INCREF(decorator);
-
     self->func_list = list;
     Py_INCREF(list);
 
@@ -1025,7 +1023,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);
 }
 
@@ -1674,7 +1671,8 @@ real_class_name(std::string name, std::string class_name)
     return name;
 }
 
-struct PrivateAttrCreationData {
+struct PrivateAttrCreationData
+{
     std::string class_name;
     PyObject* attrs_copy = nullptr;
     PyObject* new_hash_private_attrs = nullptr;
@@ -2214,8 +2212,14 @@ PrivateAttrType_setattr(PyObject* cls, PyObject* name, PyObject* value)
         PyErr_SetString(PyExc_TypeError, "cls must be a type");
         return -1;
     }
+    // check Py_TPFLAGS_IMMUTABLETYPE
     uintptr_t typ_id = (uintptr_t)(cls);
     std::string name_str = PyUnicode_AsUTF8(name);
+    if (((PyTypeObject*)cls)->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) {
+        std::string error_message = "cannot set '" + name_str + "' attribute of immutable type '" + ((PyTypeObject*)cls)->tp_name + "'";
+        PyErr_SetString(PyExc_TypeError, error_message.c_str());
+        return -1;
+    }
     PyCodeObject* now_code = get_now_code();
     if (type_private_attr(typ_id, name_str)) {
         if (!now_code || (!is_class_code(typ_id, now_code) && !is_subclass_code(typ_id, now_code))) {
@@ -2315,8 +2319,7 @@ 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, but it can be used as a base class for PrivateAttrType to avoid some conflicts with other metaclasses.";
+static const char* PrivateAttrBase_doc = "The class to help to create private attribute. It does not have any special behavior.";
 
 // PrivateAttrBase
 static PyObject*
@@ -2378,7 +2381,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);
@@ -2390,7 +2393,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);
@@ -2402,7 +2405,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);
@@ -2414,7 +2417,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);
@@ -2473,20 +2476,25 @@ 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;
 }
 
 static PyObject*
-postprocess_for_PrivateAttr(PyObject* /*self*/, PyObject* args) {
+postprocess_for_PrivateAttr(PyObject* /*self*/, PyObject* args)
+{
     PyObject* type;
     PyObject* tmp;
     if (!PyArg_ParseTuple(args, "OO", &type, &tmp)) {
@@ -2542,7 +2550,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_flags |= Py_TPFLAGS_IMMUTABLETYPE;
     Py_RETURN_NONE;
 }
 
@@ -2655,13 +2662,14 @@ static PyGetSetDef PrivateModule_getsetters[] = {
 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. The custom metaclass can call this function in its __prepare__ method to get the information for creating private attributes class.
+    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.
+    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:
 ```
@@ -2675,18 +2683,16 @@ class PrivateAbcMeta(ABCMeta):
         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 registered.
+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`.
 )";
@@ -2740,7 +2746,7 @@ 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 classmethods it is reachable.
+but in the methods defined in class it is reachable.
 Usage example:
 ```python
 class MyClass(PrivateAttrBase):
@@ -2773,7 +2779,7 @@ PyInit_private_attribute(void)
         PyType_Ready(&PrivateWrapProxyType) < 0 ||
         PyType_Ready(&PrivateAttrType) < 0 ||
         PyType_Ready(&PrivateModuleType) < 0 ||
-        PyType_Ready(&PrivateTempType)) {
+        PyType_Ready(&PrivateTempType) < 0) {
         return NULL;
     }
 

private_attribute_cpp-1.3.6/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.4 → private_attribute_cpp-1.3.6/private_attribute_cpp.egg-info}/PKG-INFO

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

@@ -19,7 +19,7 @@ readme = open('README.md').read()
 
 setup(
     name='private_attribute_cpp',
-    version='1.3.4',
+    version='1.3.6',
     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.4/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: ...