private-attribute-cpp 1.4.2__tar.gz → 1.4.4__tar.gz

{private_attribute_cpp-1.4.2/private_attribute_cpp.egg-info → private_attribute_cpp-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.2
+Version: 1.4.4
 Summary: A Python package that provides a way to define private attributes in C++ implementation.
 Home-page: https://github.com/Locked-chess-official/private_attribute_cpp
 Author: HuangHaoHua

{private_attribute_cpp-1.4.2 → private_attribute_cpp-1.4.4}/private_attribute.cpp

@@ -138,8 +138,6 @@ namespace {
         static std::unordered_map<uintptr_t, destructor> all_type_finalize;
 
         static std::shared_mutex all_register_new_metaclass_mutex;
-        static std::vector<PyTypeObject*> all_register_new_metaclass;
-        static std::unordered_set<uintptr_t> all_register_new_metaclass_id;
         static std::unordered_map<uintptr_t, PyObject*> all_register_type_weak_ref;
     };
 };
@@ -233,7 +231,7 @@ generate_private_attr_name(uintptr_t obj_id, const std::string& attr_name)
     "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ";
 
     std::uniform_int_distribution<long long> dist(0, printable_chars.size() - 1);
-    
+
     auto generate_random_ascii = [&](int length) {
         std::string result;
         for(int i = 0; i < length; i++) {
@@ -1754,6 +1752,18 @@ 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;
@@ -1987,6 +1997,9 @@ PrivateAttrType_preprocess(PyObject* args, PyObject* kwds, PrivateAttrCreationDa
     if (!PyArg_ParseTuple(args, "OOO", &data.name, &data.bases, &data.attrs)) {
         return false;
     }
+    Py_INCREF(data.name);
+    Py_INCREF(data.bases);
+    Py_INCREF(data.attrs);
 
     if (!PyUnicode_Check(data.name)) {
         PyErr_SetString(PyExc_TypeError, "name must be a string");
@@ -2315,6 +2328,10 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data)
     if (!new_type) {
         return false;
     }
+    if (!PyType_Check(new_type)) {
+        PyErr_SetString(PyExc_TypeError, "created object is not a type");
+        return false;
+    }
 
     PyTypeObject* type_instance = (PyTypeObject*)new_type;
     uintptr_t type_id = (uintptr_t)(type_instance);
@@ -2423,7 +2440,13 @@ PrivateAttrType_postprocess(PyObject* new_type, PrivateAttrCreationData& data)
             analyse_all_code(original_value, ::AllData::type_allowed_code_map[type_id], set);
         }
     }
-    
+
+    // Python >= 3.13, delete the attr "__static_attributes__"
+#if PY_VERSION_HEX >= 0x030D0000
+    PyDict_DelItemString(type_instance->tp_dict, "__static_attributes__");
+    PyErr_Clear();
+#endif
+
     return true;
 }
 
@@ -3189,7 +3212,7 @@ static PyMethodDef PrivateModule_methods[] = {
 static PyTypeObject PrivateModuleType = {
     PyVarObject_HEAD_INIT(NULL, 0)
     "private_attribute_module", //tp_name
-    PyModule_Type.tp_basicsize + 8, //tp_basicsize   size of module object + 8 bytes for flag to avoid change attribute '__class__'
+    PyModule_Type.tp_basicsize + 8, //tp_basicsize   size of module object + 8 bytes for basicsize to avoid changing attribute '__class__'
     0, //tp_itemsize
     0, //tp_dealloc
     0, //tp_print
@@ -3262,14 +3285,38 @@ PyInit_private_attribute(void)
         PyType_Ready(&PrivateTempType) < 0) {
         return NULL;
     }
-
+    PyObject* all = PyList_New(0);
+    if (!all) {
+        return NULL;
+    }
     PyObject* m = PyModule_Create(&def);
     if (!m) {
+        Py_DECREF(all);
         return NULL;
     }
 #ifdef Py_GIL_DISABLED
     PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
 #endif
+
+    PyModule_AddObject(m, "__all__", all);
+    /* all contains:
+     * PrivateWrapProxy
+     * PrivateAttrType
+     * PrivateAttrBase
+     * prepare
+     * postprocess
+     * register_metaclass
+     * ensure_type
+     * ensure_metaclass
+     */
+    PyList_Append(all, PyUnicode_FromString("PrivateWrapProxy"));
+    PyList_Append(all, PyUnicode_FromString("PrivateAttrType"));
+    PyList_Append(all, PyUnicode_FromString("PrivateAttrBase"));
+    PyList_Append(all, PyUnicode_FromString("prepare"));
+    PyList_Append(all, PyUnicode_FromString("postprocess"));
+    PyList_Append(all, PyUnicode_FromString("register_metaclass"));
+    PyList_Append(all, PyUnicode_FromString("ensure_type"));
+    PyList_Append(all, PyUnicode_FromString("ensure_metaclass"));
     Py_SET_TYPE(m, &PrivateModuleType);
     return m;
 }

{private_attribute_cpp-1.4.2 → private_attribute_cpp-1.4.4}/private_attribute.pyi

@@ -19,14 +19,14 @@ 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):
+class _PrivateAttrDict(TypedDict):
     __private_attrs__: Sequence[str]
 
-T = TypeVar('T')
+_T = TypeVar('T')
 
-class _PrivateWrap(Generic[T]):
+class _PrivateWrap(Generic[_T]):
     @property
-    def result(self) -> T:
+    def result(self) -> _T:
         "the final result of decorating"
         ...
 
@@ -38,7 +38,7 @@ class _PrivateWrap(Generic[T]):
     def __getattr__(self, name: str) -> Any:
         return getattr(self.result, name)
 
-TVar = TypeVar('TVar')
+_TVar = TypeVar('TVar')
 
 class PrivateWrapProxy:
     """
@@ -70,13 +70,13 @@ class PrivateWrapProxy:
         def my_method(self): ...
     ```
     """
-    def __init__(self, decorator: Callable[[TVar], T], orig: _PrivateWrap[Any]|None = None, /) -> None: ...
-    def __call__(self, func: TVar, /) -> _PrivateWrap[T]: ...
+    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, /,
+                attrs: _PrivateAttrDict, /,
                 private_func: Callable[[int, str], str]|None = None) -> PrivateAttrType: ...
 
 class PrivateAttrBase(metaclass=PrivateAttrType):
@@ -95,7 +95,7 @@ class _PrivateTemp:
     @property
     def kwds(self) -> dict[str, Any]: ...
 
-def prepare(name: str, bases: tuple, attrs: PrivateAttrDict, /, **kwds) -> _PrivateTemp:
+def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _PrivateTemp:
     """
     function for custom metaclass to create private attributes class.
 

{private_attribute_cpp-1.4.2 → private_attribute_cpp-1.4.4/private_attribute_cpp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 1.4.2
+Version: 1.4.4
 Summary: A Python package that provides a way to define private attributes in C++ implementation.
 Home-page: https://github.com/Locked-chess-official/private_attribute_cpp
 Author: HuangHaoHua

{private_attribute_cpp-1.4.2 → private_attribute_cpp-1.4.4}/setup.py

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