Merge branch 'master' into sh_merge_master

Author: rwgk

.pre-commit-config.yaml

@@ -25,28 +25,28 @@ repos:
 
 # Clang format the codebase automatically
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: "v17.0.6"
+  rev: "v18.1.2"
   hooks:
   - id: clang-format
     types_or: [c++, c, cuda]
 
 # Ruff, the Python auto-correcting linter/formatter written in Rust
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.2.0
+  rev: v0.3.5
   hooks:
   - id: ruff
     args: ["--fix", "--show-fixes"]
   - id: ruff-format
 
 # Check static types with mypy
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: "v1.8.0"
+  rev: "v1.9.0"
   hooks:
   - id: mypy
     args: []
     exclude: ^(tests|docs)/
     additional_dependencies:
-    - markdown-it-py<3 # Drop this together with dropping Python 3.7 support.
+    - markdown-it-py
     - nox
     - rich
     - types-setuptools
@@ -88,14 +88,14 @@ repos:
 
 # Changes tabs to spaces
 - repo: https://github.com/Lucas-C/pre-commit-hooks
-  rev: "v1.5.4"
+  rev: "v1.5.5"
   hooks:
   - id: remove-tabs
     exclude: (^docs/.*|\.patch)?$
 
 # Avoid directional quotes
 - repo: https://github.com/sirosen/texthooks
-  rev: "0.6.4"
+  rev: "0.6.6"
   hooks:
   - id: fix-ligatures
   - id: fix-smartquotes
@@ -129,7 +129,7 @@ repos:
 
 # Check for common shell mistakes
 - repo: https://github.com/shellcheck-py/shellcheck-py
-  rev: "v0.9.0.6"
+  rev: "v0.10.0.1"
   hooks:
   - id: shellcheck
 
@@ -144,13 +144,13 @@ repos:
 
 # PyLint has native support - not always usable, but works for us
 - repo: https://github.com/PyCQA/pylint
-  rev: "v3.0.3"
+  rev: "v3.1.0"
   hooks:
   - id: pylint
     files: ^pybind11
 
 - repo: https://github.com/python-jsonschema/check-jsonschema
-  rev: 0.28.0
+  rev: 0.28.1
   hooks:
   - id: check-readthedocs
   - id: check-github-workflows

include/pybind11/buffer_info.h

@@ -102,22 +102,22 @@ struct buffer_info {
     template <typename T>
     buffer_info(const T *ptr, ssize_t size, bool readonly = true)
         : buffer_info(
-            const_cast<T *>(ptr), sizeof(T), format_descriptor<T>::format(), size, readonly) {}
+              const_cast<T *>(ptr), sizeof(T), format_descriptor<T>::format(), size, readonly) {}
 
     explicit buffer_info(Py_buffer *view, bool ownview = true)
         : buffer_info(
-            view->buf,
-            view->itemsize,
-            view->format,
-            view->ndim,
-            {view->shape, view->shape + view->ndim},
-            /* Though buffer::request() requests PyBUF_STRIDES, ctypes objects
-             * ignore this flag and return a view with NULL strides.
-             * When strides are NULL, build them manually.  */
-            view->strides
-                ? std::vector<ssize_t>(view->strides, view->strides + view->ndim)
-                : detail::c_strides({view->shape, view->shape + view->ndim}, view->itemsize),
-            (view->readonly != 0)) {
+              view->buf,
+              view->itemsize,
+              view->format,
+              view->ndim,
+              {view->shape, view->shape + view->ndim},
+              /* Though buffer::request() requests PyBUF_STRIDES, ctypes objects
+               * ignore this flag and return a view with NULL strides.
+               * When strides are NULL, build them manually.  */
+              view->strides
+                  ? std::vector<ssize_t>(view->strides, view->strides + view->ndim)
+                  : detail::c_strides({view->shape, view->shape + view->ndim}, view->itemsize),
+              (view->readonly != 0)) {
         // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
         this->m_view = view;
         // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
@@ -176,7 +176,7 @@ struct buffer_info {
                 detail::any_container<ssize_t> &&strides_in,
                 bool readonly)
         : buffer_info(
-            ptr, itemsize, format, ndim, std::move(shape_in), std::move(strides_in), readonly) {}
+              ptr, itemsize, format, ndim, std::move(shape_in), std::move(strides_in), readonly) {}
 
     Py_buffer *m_view = nullptr;
     bool ownview = false;

include/pybind11/detail/common.h

@@ -949,8 +949,7 @@ using is_template_base_of
     = decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T> *) nullptr));
 #else
 struct is_template_base_of
-    : decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T> *) nullptr)) {
-};
+    : decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T> *) nullptr)){};
 #endif
 
 /// Check if T is an instantiation of the template `Class`. For example:
@@ -1132,14 +1131,14 @@ struct overload_cast_impl {
     }
 
     template <typename Return, typename Class>
-    constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept
-        -> decltype(pmf) {
+    constexpr auto operator()(Return (Class::*pmf)(Args...),
+                              std::false_type = {}) const noexcept -> decltype(pmf) {
         return pmf;
     }
 
     template <typename Return, typename Class>
-    constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
-        -> decltype(pmf) {
+    constexpr auto operator()(Return (Class::*pmf)(Args...) const,
+                              std::true_type) const noexcept -> decltype(pmf) {
         return pmf;
     }
 };

include/pybind11/detail/descr.h

@@ -256,10 +256,10 @@ constexpr auto concat(const descr<N, Ts...> &d, const Args &...args) {
 }
 #else
 template <size_t N, typename... Ts, typename... Args>
-constexpr auto concat(const descr<N, Ts...> &d, const Args &...args)
-    -> decltype(std::declval<descr<N + 2, Ts...>>() + concat(args...)) {
-    // Ensure that src_loc of existing descr is used.
-    return d + const_name(", ", src_loc{nullptr, 0}) + concat(args...);
+constexpr auto concat(const descr<N, Ts...> &d,
+                      const Args &...args) -> decltype(std::declval<descr<N + 2, Ts...>>()
+                                                       + concat(args...)) {
+    return d + const_name(", ") + concat(args...);
 }
 #endif
 

include/pybind11/detail/internals.h

@@ -329,13 +329,13 @@ struct type_info {
 
 #define PYBIND11_INTERNALS_ID                                                                     \
     "__pybind11_internals_v" PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION)                        \
-        PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI         \
-            PYBIND11_BUILD_TYPE PYBIND11_INTERNALS_SH_DEF "__"
+        PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB                            \
+            PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__"
 
 #define PYBIND11_MODULE_LOCAL_ID                                                                  \
     "__pybind11_module_local_v" PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION)                     \
-        PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI         \
-            PYBIND11_BUILD_TYPE PYBIND11_INTERNALS_SH_DEF "__"
+        PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB                            \
+            PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__"
 
 /// Each module locally stores a pointer to the `internals` data. The data
 /// itself is shared among modules with the same `PYBIND11_INTERNALS_ID`.

include/pybind11/detail/type_caster_base.h

@@ -1188,14 +1188,14 @@ class type_caster_base : public type_caster_generic {
        does not have a private operator new implementation. A comma operator is used in the
        decltype argument to apply SFINAE to the public copy/move constructors.*/
     template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
-    static auto make_copy_constructor(const T *)
-        -> decltype(new T(std::declval<const T>()), Constructor{}) {
+    static auto make_copy_constructor(const T *) -> decltype(new T(std::declval<const T>()),
+                                                             Constructor{}) {
         return [](const void *arg) -> void * { return new T(*reinterpret_cast<const T *>(arg)); };
     }
 
     template <typename T, typename = enable_if_t<is_move_constructible<T>::value>>
-    static auto make_move_constructor(const T *)
-        -> decltype(new T(std::declval<T &&>()), Constructor{}) {
+    static auto make_move_constructor(const T *) -> decltype(new T(std::declval<T &&>()),
+                                                             Constructor{}) {
         return [](const void *arg) -> void * {
             return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
         };

include/pybind11/stl_bind.h

@@ -158,8 +158,7 @@ void vector_modifiers(
         return v.release();
     }));
 
-    cl.def(
-        "clear", [](Vector &v) { v.clear(); }, "Clear the contents");
+    cl.def("clear", [](Vector &v) { v.clear(); }, "Clear the contents");
 
     cl.def(
         "extend",

pybind11/setup_helpers.py

@@ -353,7 +353,7 @@ def no_recompile(obg: str, src: str) -> bool:  # noqa: ARG001
         distutils.ccompiler.CCompiler,
         List[str],
         Optional[str],
-        Optional[Union[Tuple[str], Tuple[str, Optional[str]]]],
+        Optional[List[Union[Tuple[str], Tuple[str, Optional[str]]]]],
         Optional[List[str]],
         bool,
         Optional[List[str]],
@@ -429,7 +429,7 @@ def compile_function(
             compiler: distutils.ccompiler.CCompiler,
             sources: List[str],
             output_dir: Optional[str] = None,
-            macros: Optional[Union[Tuple[str], Tuple[str, Optional[str]]]] = None,
+            macros: Optional[List[Union[Tuple[str], Tuple[str, Optional[str]]]]] = None,
             include_dirs: Optional[List[str]] = None,
             debug: bool = False,
             extra_preargs: Optional[List[str]] = None,

pyproject.toml

@@ -19,7 +19,7 @@ ignore = [
 
 [tool.mypy]
 files = ["pybind11"]
-python_version = "3.7"
+python_version = "3.8"
 strict = true
 show_error_codes = true
 enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]

tests/test_builtin_casters.cpp

@@ -102,7 +102,7 @@ TEST_SUBMODULE(builtin_casters, m) {
     } // 𝐀, utf16
     else {
         wstr.push_back((wchar_t) mathbfA32);
-    }                     // 𝐀, utf32
+    } // 𝐀, utf32
     wstr.push_back(0x7a); // z
 
     m.def("good_utf8_string", []() {
@@ -111,10 +111,9 @@ TEST_SUBMODULE(builtin_casters, m) {
     m.def("good_utf16_string", [=]() {
         return std::u16string({b16, ib16, cake16_1, cake16_2, mathbfA16_1, mathbfA16_2, z16});
     }); // b‽🎂𝐀z
-    m.def("good_utf32_string", [=]() {
-        return std::u32string({a32, mathbfA32, cake32, ib32, z32});
-    });                                                 // a𝐀🎂‽z
-    m.def("good_wchar_string", [=]() { return wstr; }); // a‽𝐀z
+    m.def("good_utf32_string",
+          [=]() { return std::u32string({a32, mathbfA32, cake32, ib32, z32}); }); // a𝐀🎂‽z
+    m.def("good_wchar_string", [=]() { return wstr; });                           // a‽𝐀z
     m.def("bad_utf8_string", []() {
         return std::string("abc\xd0"
                            "def");
@@ -124,9 +123,8 @@ TEST_SUBMODULE(builtin_casters, m) {
     // UnicodeDecodeError
     m.def("bad_utf32_string", [=]() { return std::u32string({a32, char32_t(0xd800), z32}); });
     if (sizeof(wchar_t) == 2) {
-        m.def("bad_wchar_string", [=]() {
-            return std::wstring({wchar_t(0x61), wchar_t(0xd800)});
-        });
+        m.def("bad_wchar_string",
+              [=]() { return std::wstring({wchar_t(0x61), wchar_t(0xd800)}); });
     }
     m.def("u8_Z", []() -> char { return 'Z'; });
     m.def("u8_eacute", []() -> char { return '\xe9'; });
@@ -243,8 +241,7 @@ TEST_SUBMODULE(builtin_casters, m) {
 
     // test_int_convert
     m.def("int_passthrough", [](int arg) { return arg; });
-    m.def(
-        "int_passthrough_noconvert", [](int arg) { return arg; }, py::arg{}.noconvert());
+    m.def("int_passthrough_noconvert", [](int arg) { return arg; }, py::arg{}.noconvert());
 
     // test_tuple
     m.def(
@@ -309,17 +306,15 @@ TEST_SUBMODULE(builtin_casters, m) {
 
     // test_bool_caster
     m.def("bool_passthrough", [](bool arg) { return arg; });
-    m.def(
-        "bool_passthrough_noconvert", [](bool arg) { return arg; }, py::arg{}.noconvert());
+    m.def("bool_passthrough_noconvert", [](bool arg) { return arg; }, py::arg{}.noconvert());
 
     // TODO: This should be disabled and fixed in future Intel compilers
 #if !defined(__INTEL_COMPILER)
     // Test "bool_passthrough_noconvert" again, but using () instead of {} to construct py::arg
     // When compiled with the Intel compiler, this results in segmentation faults when importing
     // the module. Tested with icc (ICC) 2021.1 Beta 20200827, this should be tested again when
     // a newer version of icc is available.
-    m.def(
-        "bool_passthrough_noconvert2", [](bool arg) { return arg; }, py::arg().noconvert());
+    m.def("bool_passthrough_noconvert2", [](bool arg) { return arg; }, py::arg().noconvert());
 #endif
 
     // test_reference_wrapper

tests/test_call_policies.cpp

@@ -63,10 +63,8 @@ TEST_SUBMODULE(call_policies, m) {
         .def("returnNullChildKeepAliveParent", &Parent::returnNullChild, py::keep_alive<0, 1>())
         .def_static("staticFunction", &Parent::staticFunction, py::keep_alive<1, 0>());
 
-    m.def(
-        "free_function", [](Parent *, Child *) {}, py::keep_alive<1, 2>());
-    m.def(
-        "invalid_arg_index", [] {}, py::keep_alive<0, 1>());
+    m.def("free_function", [](Parent *, Child *) {}, py::keep_alive<1, 2>());
+    m.def("invalid_arg_index", [] {}, py::keep_alive<0, 1>());
 
 #if !defined(PYPY_VERSION)
     // test_alive_gc

tests/test_class.cpp

@@ -475,8 +475,7 @@ TEST_SUBMODULE(class_, m) {
     py::class_<Nested>(base, "Nested")
         .def(py::init<>())
         .def("fn", [](Nested &, int, NestBase &, Nested &) {})
-        .def(
-            "fa", [](Nested &, int, NestBase &, Nested &) {}, "a"_a, "b"_a, "c"_a);
+        .def("fa", [](Nested &, int, NestBase &, Nested &) {}, "a"_a, "b"_a, "c"_a);
     base.def("g", [](NestBase &, Nested &) {});
     base.def("h", []() { return NestBase(); });
 

tests/test_copy_move.cpp

@@ -289,8 +289,7 @@ TEST_SUBMODULE(copy_move_policies, m) {
         "get_moveissue1",
         [](int i) { return std::unique_ptr<MoveIssue1>(new MoveIssue1(i)); },
         py::return_value_policy::move);
-    m.def(
-        "get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
+    m.def("get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
 
     // Make sure that cast from pytype rvalue to other pytype works
     m.def("get_pytype_rvalue_castissue", [](double i) { return py::float_(i).cast<py::int_>(); });

tests/test_custom_type_casters.cpp

@@ -185,14 +185,10 @@ TEST_SUBMODULE(custom_type_casters, m) {
         py::arg_v(nullptr, ArgInspector1()).noconvert(true),
         py::arg() = ArgAlwaysConverts());
 
-    m.def(
-        "floats_preferred", [](double f) { return 0.5 * f; }, "f"_a);
-    m.def(
-        "floats_only", [](double f) { return 0.5 * f; }, "f"_a.noconvert());
-    m.def(
-        "ints_preferred", [](int i) { return i / 2; }, "i"_a);
-    m.def(
-        "ints_only", [](int i) { return i / 2; }, "i"_a.noconvert());
+    m.def("floats_preferred", [](double f) { return 0.5 * f; }, "f"_a);
+    m.def("floats_only", [](double f) { return 0.5 * f; }, "f"_a.noconvert());
+    m.def("ints_preferred", [](int i) { return i / 2; }, "i"_a);
+    m.def("ints_only", [](int i) { return i / 2; }, "i"_a.noconvert());
 
     // test_custom_caster_destruction
     // Test that `take_ownership` works on types with a custom type caster when given a pointer