private-attribute-cpp 2.2.1__tar.gz → 2.2.3__tar.gz

private_attribute_cpp-2.2.3/CMakeLists.txt

@@ -0,0 +1,89 @@
+cmake_minimum_required(VERSION 3.15...3.31)
+
+project(private_attribute_cpp LANGUAGES CXX)
+
+# Locate the running interpreter and its development headers/module support.
+find_package(
+  Python
+  COMPONENTS Interpreter Development.Module
+  REQUIRED)
+
+# Build the `private_attribute` extension module with a proper SOABI suffix
+# (private_attribute.cpython-3XX[-t]-<plat>.so), importable from site-packages.
+# Detect whether the running Python was built with --enable-shared.
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -c
+          "import sysconfig; print(sysconfig.get_config_var('Py_ENABLE_SHARED') or 0)"
+  OUTPUT_VARIABLE PYTHON_ENABLE_SHARED
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  RESULT_VARIABLE PYTHON_CONFIG_RESULT
+)
+
+if(NOT PYTHON_CONFIG_RESULT EQUAL 0)
+  message(FATAL_ERROR "Failed to query Python build configuration")
+endif()
+
+if(WIN32)
+  # Windows: keep Python::Module to obtain the required import library.
+  Python_add_library(
+    private_attribute MODULE WITH_SOABI
+    private_attribute.cpp
+  )
+elseif(PYTHON_ENABLE_SHARED STREQUAL "1")
+  # Keep the standard CMake Python extension-module behavior.
+  Python_add_library(
+    private_attribute MODULE WITH_SOABI
+    private_attribute.cpp
+  )
+else()
+  # Match the usual Unix setuptools.Extension behavior:
+  # do not link the static libpython into the extension module.
+  add_library(
+    private_attribute MODULE
+    private_attribute.cpp
+  )
+
+  if(APPLE)
+    target_link_options(
+      private_attribute PRIVATE
+      "-undefined" "dynamic_lookup"
+    )
+  endif()
+
+  target_include_directories(
+    private_attribute PRIVATE
+    ${Python_INCLUDE_DIRS}
+  )
+
+  set_target_properties(
+    private_attribute PROPERTIES
+    PREFIX ""
+    SUFFIX ".${Python_SOABI}${CMAKE_SHARED_MODULE_SUFFIX}"
+  )
+
+  message(STATUS
+    "Python was built without --enable-shared; "
+    "building the extension without linking libpython"
+  )
+endif()
+
+# picosha2.h is a header-only dependency living next to the .cpp.
+target_include_directories(private_attribute PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
+
+# C++17, matching the original setup.py flags.
+if(MSVC)
+  target_compile_options(private_attribute PRIVATE /std:c++17 /GR-)
+else()
+  target_compile_options(private_attribute PRIVATE -std=c++17 -fno-exceptions -fno-rtti)
+  # Strip debug info unless the caller explicitly opts in to keeping it.
+  # (This is the conditional that a static pyproject.toml cannot express,
+  #  hence it lives here in CMake instead of setup.py.)
+  if(NOT "$ENV{PRIVATE_ATTR_KEEP_DEBUG}" STREQUAL "1")
+    target_compile_options(private_attribute PRIVATE -g0)
+  endif()
+endif()
+
+# Install both the compiled module and its PEP 561 type stub at the
+# site-packages root, side by side.
+install(TARGETS private_attribute LIBRARY DESTINATION .)
+install(FILES private_attribute.pyi DESTINATION .)

{private_attribute_cpp-2.2.1 → private_attribute_cpp-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: private_attribute_cpp
-Version: 2.2.1
+Version: 2.2.3
 Summary: A Python package that provides a way to define private attributes in C++ implementation.
 Author-Email: HuangHaoHua <13140752715@example.com>
 License-Expression: MIT
@@ -184,10 +184,10 @@ import private_attribute
 
 class PrivateAbcMeta(ABCMeta):
     def __new__(cls, name, bases, attrs, **kwargs):
-        temp = private_attribute.prepare(name, bases, attrs, **kwargs)
-        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-        private_attribute.postprocess(typ, temp)
-        return typ
+        with private_attribute.prepare(name, bases, attrs, **kwargs) as tmp: # In 2.2.3 it support using "with"
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp) # or tmp.postprocess(typ)
+            return typ
 
 private_attribute.register_metaclass(PrivateAbcMeta)
 ```
@@ -248,6 +248,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - 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.
 - `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
 - Don't set `__static_attributes__` in private attribute class, or it will be removed.
+- After 2.2.1, when `prepare` was called, it will lock the creation of new private attribute type. There will be only one private attribute type in building (type.\_\_new\_\_) at the same time. Call `postprocess` to unlock it. If build failed, the lock will be released automatically.
+- After 2.2.3, it is recommend to use "with" on `private_attribute.prepare` and `private_attribute.postprocess` to ensure the lock is released.
 
 ## License
 

{private_attribute_cpp-2.2.1 → private_attribute_cpp-2.2.3}/README.md

@@ -174,10 +174,10 @@ import private_attribute
 
 class PrivateAbcMeta(ABCMeta):
     def __new__(cls, name, bases, attrs, **kwargs):
-        temp = private_attribute.prepare(name, bases, attrs, **kwargs)
-        typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
-        private_attribute.postprocess(typ, temp)
-        return typ
+        with private_attribute.prepare(name, bases, attrs, **kwargs) as tmp: # In 2.2.3 it support using "with"
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp) # or tmp.postprocess(typ)
+            return typ
 
 private_attribute.register_metaclass(PrivateAbcMeta)
 ```
@@ -238,6 +238,8 @@ TypeError: Can't instantiate abstract class MyClass without an implementation fo
 - 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.
 - `private_attribute.register_metaclass` must be called with the metaclass which supports weakref.
 - Don't set `__static_attributes__` in private attribute class, or it will be removed.
+- After 2.2.1, when `prepare` was called, it will lock the creation of new private attribute type. There will be only one private attribute type in building (type.\_\_new\_\_) at the same time. Call `postprocess` to unlock it. If build failed, the lock will be released automatically.
+- After 2.2.3, it is recommend to use "with" on `private_attribute.prepare` and `private_attribute.postprocess` to ensure the lock is released.
 
 ## License
 

{private_attribute_cpp-2.2.1 → private_attribute_cpp-2.2.3}/private_attribute.cpp

@@ -4060,8 +4060,27 @@ PrivateTempObject_postprocess(PyObject* self, PyObject* type) noexcept
     Py_RETURN_NONE;
 }
 
+static PyObject*
+PrivateTempObject_enter(PyObject* self, PyObject* /*args*/) noexcept
+{
+    Py_INCREF(self);
+    return self;
+}
+
+
+static PyObject*
+PrivateTempObject_exit(PyObject* self, PyObject* /*args*/) noexcept
+{
+    PrivateTempObject* obj = (PrivateTempObject*)self;
+    if (!obj->tmp->cleared) {
+        obj->tmp->clear();
+    }
+    Py_RETURN_NONE;
+}
 static PyMethodDef PrivateTempObject_methods[] = {
     {"postprocess", (PyCFunction)PrivateTempObject_postprocess, METH_O, "postprocess the temp object"},
+    {"__enter__", (PyCFunction)PrivateTempObject_enter, METH_NOARGS, NULL},
+    {"__exit__", (PyCFunction)PrivateTempObject_exit, METH_VARARGS, NULL},
     {NULL}
 };
 
@@ -4147,7 +4166,11 @@ postprocess_for_PrivateAttr(PyObject* /*self*/, PyObject* args) noexcept
 {
     PyObject* type;
     PyObject* tmp;
-    if (!PyArg_ParseTuple(args, "OO", &type, &tmp)) {
+    if (!PyArg_ParseTuple(args, "OO:private_attribute.postprocess", &type, &tmp)) {
+        return NULL;
+    }
+    if (!PyObject_IsInstance(tmp, (PyObject*)&PrivateTempType)) {
+        PyErr_SetString(PyExc_TypeError, "tmp must be a PrivateTempObject");
         return NULL;
     }
     return PrivateTempObject_postprocess(tmp, type);
@@ -4506,10 +4529,10 @@ 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) # or temp.postprocess(typ)
-        return typ
+        with private_attribute.prepare(*args, **kwargs) as temp:
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+            return typ
 
 private_attribute.register_metaclass(PrivateAbcMeta)
 ```

{private_attribute_cpp-2.2.1 → private_attribute_cpp-2.2.3}/private_attribute.pyi

@@ -119,6 +119,9 @@ class _PrivateTemp:
     def kwds(self) -> dict[str, Any]: ...
     def postprocess(self, typ: type, /) -> None: ... # add in 2.1.17
 
+    def __enter__(self) -> "_PrivateTemp": ...
+    def __exit__(self, exc_type: type, exc_val: Exception, exc_tb: Any) -> None: ...
+
 def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _PrivateTemp:
     """
     function for custom metaclass to create private attributes class.
@@ -140,10 +143,10 @@ def prepare(name: str, bases: tuple, attrs: _PrivateAttrDict, /, **kwds) -> _Pri
 
     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) # or temp.postprocess(typ)
-            return typ
+            with private_attribute.prepare(*args, **kwargs) as temp:
+                typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+                private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+                return typ
 
     private_attribute.register_metaclass(PrivateAbcMeta)
     ```
@@ -178,10 +181,10 @@ def postprocess(typ: type, temp: _PrivateTemp, /) -> None:
 
     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) # or temp.postprocess(typ)
-            return typ
+            with private_attribute.prepare(*args, **kwargs) as temp:
+                typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+                private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+                return typ
 
     private_attribute.register_metaclass(PrivateAbcMeta)
     ```
@@ -208,10 +211,10 @@ def register_metaclass(typ: type, /) -> None:
 
     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) # or temp.postprocess(typ)
-            return typ
+            with private_attribute.prepare(*args, **kwargs) as temp:
+                typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+                private_attribute.postprocess(typ, temp) # or temp.postprocess(typ)
+                return typ
 
     private_attribute.register_metaclass(PrivateAbcMeta)
     ```

{private_attribute_cpp-2.2.1 → private_attribute_cpp-2.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "private_attribute_cpp"
-version = "2.2.1"
+version = "2.2.3"
 description = "A Python package that provides a way to define private attributes in C++ implementation."
 readme = "README.md"
 requires-python = ">=3.10"

{private_attribute_cpp-2.2.1 → private_attribute_cpp-2.2.3}/tests/test_private_abc.py

@@ -5,10 +5,10 @@ import unittest
 
 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
+        with private_attribute.prepare(*args, **kwargs) as temp:
+            typ = super().__new__(cls, temp.name, temp.bases, temp.attrs, **temp.kwds)
+            private_attribute.postprocess(typ, temp)
+            return typ
 
 
 private_attribute.register_metaclass(PrivateAbcMeta)
@@ -34,7 +34,7 @@ class ConcreteClass(MyClass):
         self._secret1 = secret1
         self._secret2 = secret2
 
-    def public_method(self):
+    def public_method(self): # type: ignore
         return self._secret1, self._secret2
 
 
@@ -47,7 +47,7 @@ class TestPrivateAbc(unittest.TestCase):
         with self.assertRaises(AttributeError):
             c._secret2
         with self.assertRaises(TypeError):
-            MyClass()
+            MyClass() # type: ignore
         with self.assertRaises(AttributeError):
             MyClass._secret1
         self.assertEqual(MyClass.get_secret1(), 10)

private_attribute_cpp-2.2.1/CMakeLists.txt

@@ -1,34 +0,0 @@
-cmake_minimum_required(VERSION 3.15...3.31)
-
-project(private_attribute_cpp LANGUAGES CXX)
-
-# Locate the running interpreter and its development headers/module support.
-find_package(
-  Python
-  COMPONENTS Interpreter Development.Module
-  REQUIRED)
-
-# Build the `private_attribute` extension module with a proper SOABI suffix
-# (private_attribute.cpython-3XX[-t]-<plat>.so), importable from site-packages.
-Python_add_library(private_attribute MODULE WITH_SOABI private_attribute.cpp)
-
-# picosha2.h is a header-only dependency living next to the .cpp.
-target_include_directories(private_attribute PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
-
-# C++17, matching the original setup.py flags.
-if(MSVC)
-  target_compile_options(private_attribute PRIVATE /std:c++17 /GR-)
-else()
-  target_compile_options(private_attribute PRIVATE -std=c++17 -fno-exceptions -fno-rtti)
-  # Strip debug info unless the caller explicitly opts in to keeping it.
-  # (This is the conditional that a static pyproject.toml cannot express,
-  #  hence it lives here in CMake instead of setup.py.)
-  if(NOT "$ENV{PRIVATE_ATTR_KEEP_DEBUG}" STREQUAL "1")
-    target_compile_options(private_attribute PRIVATE -g0)
-  endif()
-endif()
-
-# Install both the compiled module and its PEP 561 type stub at the
-# site-packages root, side by side.
-install(TARGETS private_attribute LIBRARY DESTINATION .)
-install(FILES private_attribute.pyi DESTINATION .)