Merge dd3c5d2536 into 1f8b4a7f1a

Bumps the actions group with 1 update: [pypa/cibuildwheel](https://github.com/pypa/cibuildwheel).


Updates `pypa/cibuildwheel` from 2.20 to 2.21
- [Release notes](https://github.com/pypa/cibuildwheel/releases)
- [Changelog](https://github.com/pypa/cibuildwheel/blob/main/docs/changelog.md)
- [Commits](https://github.com/pypa/cibuildwheel/compare/v2.20...v2.21)

---
updated-dependencies:
- dependency-name: pypa/cibuildwheel
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.distro/.fmf/version

@@ -0,0 +1 @@
+1

.distro/plans/main.fmf.dist-git

@@ -0,0 +1,4 @@
+discover:
+  how: fmf
+  dist-git-source: true
+  dist-git-extract: scikit_build_core-*/

.distro/plans/rpminspect.fmf

@@ -0,0 +1,7 @@
+plan:
+  import:
+    url: https://github.com/packit/tmt-plans
+    ref: main
+    name: /plans/rpminspect
+environment:
+  RPMINSPECT_EXCLUDE: metadata,upstream

.distro/plans/rpmlint.fmf

@@ -0,0 +1,10 @@
+prepare:
+  - how: shell
+    script: cp ./*.rpmlintrc $TMT_PLAN_DATA/
+discover:
+  how: fmf
+  filter: "tag: rpmlint"
+  url: https://github.com/packit/tmt-plans
+  ref: main
+execute:
+  how: tmt

.distro/pybind11.spec

@@ -0,0 +1,94 @@
+Name:           pybind11
+Version:        0.0.0
+Release:        %autorelease
+Summary:        Seamless operability between C++11 and Python
+
+# TODO: https://github.com/pybind/pybind11/issues/5093
+License:        BSD
+URL:            https://github.com/pybind/pybind11
+BuildArch:      noarch
+Source0:        https://github.com/pybind/pybind11/archive/v%{version}/%{name}-%{version}.tar.gz
+
+BuildRequires:  python3-devel
+BuildRequires:  cmake
+BuildRequires:  ninja-build
+BuildRequires:  gcc
+BuildRequires:  gcc-c++
+# Project CMake dependencies
+BuildRequires:  catch-devel
+BuildRequires:  eigen3-devel
+# Test dependencies from tests/requirements.txt
+# Cannot include the file because requirements are too constrained
+BuildRequires:  python3dist(build)
+BuildRequires:  python3dist(numpy)
+BuildRequires:  python3dist(pytest)
+BuildRequires:  python3dist(pytest-timeout)
+BuildRequires:  python3dist(scipy)
+
+%global _description %{expand:
+pybind11 is a lightweight header-only library that exposes C++ types
+in Python and vice versa, mainly to create Python bindings of existing
+C++ code.
+}
+
+%description %_description
+
+%package devel
+Summary:        Development files for pybind11
+BuildRequires:  pybind11-devel
+Provides:       pybind11-static = %{version}-%{release}
+%description devel %_description
+
+Development files.
+
+%package -n python3-pybind11
+Summary:        %{summary}
+BuildRequires:  pybind11-devel
+%description -n python3-pybind11 %_description
+
+
+%prep
+%autosetup -n pybind11-%{version}
+# Remove cmake and ninja from buildrequires
+sed -i -E 's/,?\s*"cmake[^"]*"//' pyproject.toml
+sed -i -E 's/,?\s*"ninja[^"]*"//' pyproject.toml
+
+
+%generate_buildrequires
+%pyproject_buildrequires
+
+
+%build
+%cmake
+%cmake_build
+# Also running pyproject_wheel to get python metadata files
+%pyproject_wheel
+
+
+%install
+%cmake_install
+%pyproject_install
+%pyproject_save_files pybind11
+
+
+%check
+# %%ctest
+# %%pytest
+# Cannot use ctest or pytest integration yet. Replicating ci.yaml workflow
+# https://github.com/pybind/pybind11/issues/5095
+%cmake_build --target check
+
+
+%files devel
+%license LICENSE
+%doc README.rst
+%{_includedir}/pybind11/
+%{_datadir}/cmake/pybind11/
+%{_bindir}/pybind11-config
+%{_datadir}/pkgconfig/pybind11.pc
+
+%files -n python3-pybind11 -f %{pyproject_files}
+
+
+%changelog
+%autochangelog

.github/workflows/emscripten.yaml

@@ -22,7 +22,7 @@ jobs:
         submodules: true
         fetch-depth: 0
 
-    - uses: pypa/cibuildwheel@v2.20
+    - uses: pypa/cibuildwheel@v2.21
       env:
         PYODIDE_BUILD_EXPORTS: whole_archive
       with:

.github/workflows/pip.yml

@@ -91,11 +91,12 @@ jobs:
     runs-on: ubuntu-latest
     if: github.event_name == 'release' && github.event.action == 'published'
     needs: [packaging]
-    environment: pypi
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pybind11
     permissions:
       id-token: write
       attestations: write
-      contents: read
 
     steps:
     # Downloads all to directories matching the artifact names
@@ -110,8 +111,10 @@ jobs:
       uses: pypa/gh-action-pypi-publish@release/v1
       with:
         packages-dir: standard/
+        attestations: true
 
     - name: Publish global package
       uses: pypa/gh-action-pypi-publish@release/v1
       with:
         packages-dir: global/
+        attestations: true

.packit.yaml

@@ -0,0 +1,70 @@
+packages:
+  pybind11:
+    # Use `path` when upstream issue is clarified
+    # https://github.com/packit/packit/issues/2272#issuecomment-2033712303
+    specfile_path: .distro/pybind11.spec
+    downstream_package_name: pybind11
+    files_to_sync:
+      - src: .distro/pybind11.spec
+        dest: pybind11.spec
+      - .packit.yaml
+      - src: .distro/pybind11.rpmlintrc
+        dest: pybind11.rpmlintrc
+      # tmt setup
+      - src: .distro/.fmf/
+        dest: .fmf/
+      - src: .distro/plans/
+        dest: plans/
+        filters:
+          - "- main.fmf.dist-git"
+          - "- rpminspect.fmf"
+          - "- rpmlint.fmf"
+      - src: .distro/tests/
+        dest: tests/
+      - src: .distro/plans/main.fmf.dist-git
+        dest: plans/main.fmf
+
+update_release: false
+upstream_tag_template: v{version}
+
+jobs:
+  - &copr
+    job: copr_build
+    trigger: release
+    owner: "@scikit-build"
+    project: release
+    targets:
+      - fedora-all-x86_64
+      - fedora-all-aarch64
+  - &tests
+    job: tests
+    trigger: release
+    targets:
+      - fedora-all-x86_64
+      - fedora-all-aarch64
+    fmf_path: .distro
+  - <<: *copr
+    trigger: commit
+    project: nightly
+    branch: main
+  - <<: *tests
+    trigger: commit
+  - <<: *copr
+    trigger: pull_request
+    project: pybind11
+    update_release: true
+    release_suffix: "{PACKIT_RPMSPEC_RELEASE}"
+  - <<: *tests
+    trigger: pull_request
+  - job: propose_downstream
+    trigger: release
+    dist_git_branches:
+      - fedora-rawhide
+  - job: koji_build
+    trigger: commit
+    dist_git_branches:
+      - fedora-all
+  - job: bodhi_update
+    trigger: commit
+    dist_git_branches:
+      - fedora-branched

CMakeLists.txt

@@ -129,6 +129,7 @@ endif()
 set(PYBIND11_HEADERS
     include/pybind11/detail/class.h
     include/pybind11/detail/common.h
+    include/pybind11/detail/cpp_conduit.h
     include/pybind11/detail/descr.h
     include/pybind11/detail/init.h
     include/pybind11/detail/internals.h

MANIFEST.in

@@ -1,3 +1,4 @@
+prune .distro
 prune tests
 recursive-include pybind11/include/pybind11 *.h
 recursive-include pybind11 *.py

docs/changelog.rst

@@ -31,6 +31,37 @@ New Features:
 * The ``array_caster`` in pybind11/stl.h was enhanced to support value types that are not default-constructible.
   `#5305 <https://github.com/pybind/pybind11/pull/5305>`_
 
+* Added ``py::warnings`` namespace with ``py::warnings::warn`` and ``py::warnings::new_warning_type`` that provides the interface for Python warnings.
+  `#5291 <https://github.com/pybind/pybind11/pull/5291>`_
+
+Version 2.13.6 (September 13, 2024)
+-----------------------------------
+
+New Features:
+
+* A new ``self._pybind11_conduit_v1_()`` method is automatically added to all
+  ``py::class_``-wrapped types, to enable type-safe interoperability between
+  different independent Python/C++ bindings systems, including pybind11
+  versions with different ``PYBIND11_INTERNALS_VERSION``'s. Supported on
+  pybind11 2.11.2, 2.12.1, and 2.13.6+.
+  `#5296 <https://github.com/pybind/pybind11/pull/5296>`_
+
+
+Bug fixes:
+
+* Using ``__cpp_nontype_template_args`` instead of ``__cpp_nontype_template_parameter_class``.
+  `#5330 <https://github.com/pybind/pybind11/pull/5330>`_
+
+* Properly translate C++ exception to Python exception when creating Python buffer from wrapped object.
+  `#5324 <https://github.com/pybind/pybind11/pull/5324>`_
+
+
+Documentation:
+
+* Adds an answer (FAQ) for "What is a highly conclusive and simple way to find memory leaks?".
+  `#5340 <https://github.com/pybind/pybind11/pull/5340>`_
+
+
 Version 2.13.5 (August 22, 2024)
 --------------------------------
 
@@ -238,6 +269,18 @@ Other:
 * Update docs and noxfile.
   `#5071 <https://github.com/pybind/pybind11/pull/5071>`_
 
+Version 2.12.1 (September 13, 2024)
+-----------------------------------
+
+New Features:
+
+* A new ``self._pybind11_conduit_v1_()`` method is automatically added to all
+  ``py::class_``-wrapped types, to enable type-safe interoperability between
+  different independent Python/C++ bindings systems, including pybind11
+  versions with different ``PYBIND11_INTERNALS_VERSION``'s. Supported on
+  pybind11 2.11.2, 2.12.1, and 2.13.6+.
+  `#5296 <https://github.com/pybind/pybind11/pull/5296>`_
+
 
 Version 2.12.0 (March 27, 2024)
 -------------------------------
@@ -413,6 +456,18 @@ Other:
 * An ``assert()`` was added to help Coverty avoid generating a false positive.
   `#4817 <https://github.com/pybind/pybind11/pull/4817>`_
 
+Version 2.11.2 (September 13, 2024)
+-----------------------------------
+
+New Features:
+
+* A new ``self._pybind11_conduit_v1_()`` method is automatically added to all
+  ``py::class_``-wrapped types, to enable type-safe interoperability between
+  different independent Python/C++ bindings systems, including pybind11
+  versions with different ``PYBIND11_INTERNALS_VERSION``'s. Supported on
+  pybind11 2.11.2, 2.12.1, and 2.13.6+.
+  `#5296 <https://github.com/pybind/pybind11/pull/5296>`_
+
 
 Version 2.11.1 (July 17, 2023)
 ------------------------------

include/pybind11/detail/cpp_conduit.h

@@ -0,0 +1,77 @@
+// Copyright (c) 2024 The pybind Community.
+
+#pragma once
+
+#include <pybind11/pytypes.h>
+
+#include "common.h"
+#include "internals.h"
+
+#include <typeinfo>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Forward declaration needed here: Refactoring opportunity.
+extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *);
+
+inline bool type_is_managed_by_our_internals(PyTypeObject *type_obj) {
+#if defined(PYPY_VERSION)
+    auto &internals = get_internals();
+    return bool(internals.registered_types_py.find(type_obj)
+                != internals.registered_types_py.end());
+#else
+    return bool(type_obj->tp_new == pybind11_object_new);
+#endif
+}
+
+inline bool is_instance_method_of_type(PyTypeObject *type_obj, PyObject *attr_name) {
+    PyObject *descr = _PyType_Lookup(type_obj, attr_name);
+    return bool((descr != nullptr) && PyInstanceMethod_Check(descr));
+}
+
+inline object try_get_cpp_conduit_method(PyObject *obj) {
+    if (PyType_Check(obj)) {
+        return object();
+    }
+    PyTypeObject *type_obj = Py_TYPE(obj);
+    str attr_name("_pybind11_conduit_v1_");
+    bool assumed_to_be_callable = false;
+    if (type_is_managed_by_our_internals(type_obj)) {
+        if (!is_instance_method_of_type(type_obj, attr_name.ptr())) {
+            return object();
+        }
+        assumed_to_be_callable = true;
+    }
+    PyObject *method = PyObject_GetAttr(obj, attr_name.ptr());
+    if (method == nullptr) {
+        PyErr_Clear();
+        return object();
+    }
+    if (!assumed_to_be_callable && PyCallable_Check(method) == 0) {
+        Py_DECREF(method);
+        return object();
+    }
+    return reinterpret_steal<object>(method);
+}
+
+inline void *try_raw_pointer_ephemeral_from_cpp_conduit(handle src,
+                                                        const std::type_info *cpp_type_info) {
+    object method = try_get_cpp_conduit_method(src.ptr());
+    if (method) {
+        capsule cpp_type_info_capsule(const_cast<void *>(static_cast<const void *>(cpp_type_info)),
+                                      typeid(std::type_info).name());
+        object cpp_conduit = method(bytes(PYBIND11_PLATFORM_ABI_ID),
+                                    cpp_type_info_capsule,
+                                    bytes("raw_pointer_ephemeral"));
+        if (isinstance<capsule>(cpp_conduit)) {
+            return reinterpret_borrow<capsule>(cpp_conduit).get_pointer();
+        }
+    }
+    return nullptr;
+}
+
+#define PYBIND11_HAS_CPP_CONDUIT 1
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

include/pybind11/detail/exception_translation.h

@@ -50,12 +50,12 @@ inline void try_translate_exceptions() {
         - delegate translation to the next translator by throwing a new type of exception.
         */
 
-    bool handled = with_internals([&](internals &internals) {
+    bool handled = with_exception_translators(
-        auto &local_exception_translators = get_local_internals().registered_exception_translators;
+        [&](std::forward_list<ExceptionTranslator> &exception_translators,
+            std::forward_list<ExceptionTranslator> &local_exception_translators) {
             if (detail::apply_exception_translators(local_exception_translators)) {
                 return true;
             }
-        auto &exception_translators = internals.registered_exception_translators;
             if (detail::apply_exception_translators(exception_translators)) {
                 return true;
             }

include/pybind11/detail/internals.h

@@ -39,7 +39,11 @@
 #    if PY_VERSION_HEX >= 0x030C0000 || defined(_MSC_VER)
 // Version bump for Python 3.12+, before first 3.12 beta release.
 // Version bump for MSVC piggy-backed on PR #4779. See comments there.
+#        ifdef Py_GIL_DISABLED
+#            define PYBIND11_INTERNALS_VERSION 6
+#        else
 #            define PYBIND11_INTERNALS_VERSION 5
+#        endif
 #    else
 #        define PYBIND11_INTERNALS_VERSION 4
 #    endif
@@ -177,6 +181,7 @@ static_assert(sizeof(instance_map_shard) % 64 == 0,
 struct internals {
 #ifdef Py_GIL_DISABLED
     pymutex mutex;
+    pymutex exception_translator_mutex;
 #endif
     // std::type_index -> pybind11's type information
     type_map<type_info *> registered_types_cpp;
@@ -321,15 +326,17 @@ struct type_info {
 #    define PYBIND11_INTERNALS_KIND ""
 #endif
 
+#define PYBIND11_PLATFORM_ABI_ID                                                                  \
+    PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI             \
+        PYBIND11_BUILD_TYPE
+
 #define PYBIND11_INTERNALS_ID                                                                     \
     "__pybind11_internals_v" PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION)                        \
-        PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB                            \
+        PYBIND11_PLATFORM_ABI_ID "__"
-            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_PLATFORM_ABI_ID "__"
-            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`.
@@ -641,6 +648,19 @@ inline auto with_internals(const F &cb) -> decltype(cb(get_internals())) {
     return cb(internals);
 }
 
+template <typename F>
+inline auto with_exception_translators(const F &cb)
+    -> decltype(cb(get_internals().registered_exception_translators,
+                   get_local_internals().registered_exception_translators)) {
+    auto &internals = get_internals();
+#ifdef Py_GIL_DISABLED
+    std::unique_lock<pymutex> lock((internals).exception_translator_mutex);
+#endif
+    auto &local_internals = get_local_internals();
+    return cb(internals.registered_exception_translators,
+              local_internals.registered_exception_translators);
+}
+
 inline std::uint64_t mix64(std::uint64_t z) {
     // David Stafford's variant 13 of the MurmurHash3 finalizer popularized
     // by the SplitMix PRNG.

include/pybind11/detail/type_caster_base.h

@@ -12,14 +12,17 @@
 #include <pybind11/pytypes.h>
 
 #include "common.h"
+#include "cpp_conduit.h"
 #include "descr.h"
 #include "internals.h"
 #include "typeid.h"
 #include "value_and_holder.h"
 
 #include <cstdint>
+#include <cstring>
 #include <iterator>
 #include <new>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <typeindex>
@@ -611,6 +614,13 @@ public:
         }
         return false;
     }
+    bool try_cpp_conduit(handle src) {
+        value = try_raw_pointer_ephemeral_from_cpp_conduit(src, cpptype);
+        if (value != nullptr) {
+            return true;
+        }
+        return false;
+    }
     void check_holder_compat() {}
 
     PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
@@ -742,6 +752,10 @@ public:
             return true;
         }
 
+        if (convert && cpptype && this_.try_cpp_conduit(src)) {
+            return true;
+        }
+
         return false;
     }
 
@@ -769,6 +783,32 @@ public:
     void *value = nullptr;
 };
 
+inline object cpp_conduit_method(handle self,
+                                 const bytes &pybind11_platform_abi_id,
+                                 const capsule &cpp_type_info_capsule,
+                                 const bytes &pointer_kind) {
+#ifdef PYBIND11_HAS_STRING_VIEW
+    using cpp_str = std::string_view;
+#else
+    using cpp_str = std::string;
+#endif
+    if (cpp_str(pybind11_platform_abi_id) != PYBIND11_PLATFORM_ABI_ID) {
+        return none();
+    }
+    if (std::strcmp(cpp_type_info_capsule.name(), typeid(std::type_info).name()) != 0) {
+        return none();
+    }
+    if (cpp_str(pointer_kind) != "raw_pointer_ephemeral") {
+        throw std::runtime_error("Invalid pointer_kind: \"" + std::string(pointer_kind) + "\"");
+    }
+    const auto *cpp_type_info = cpp_type_info_capsule.get_pointer<const std::type_info>();
+    type_caster_generic caster(*cpp_type_info);
+    if (!caster.load(self, false)) {
+        return none();
+    }
+    return capsule(caster.value, cpp_type_info->name());
+}
+
 /**
  * Determine suitable casting operator for pointer-or-lvalue-casting type casters.  The type caster
  * needs to provide `operator T*()` and `operator T&()` operators.

include/pybind11/pybind11.h

@@ -592,7 +592,8 @@ protected:
         int index = 0;
         /* Create a nice pydoc rec including all signatures and
            docstrings of the functions in the overload chain */
-        if (chain && options::show_function_signatures()) {
+        if (chain && options::show_function_signatures()
+            && std::strcmp(rec->name, "_pybind11_conduit_v1_") != 0) {
             // First a generic signature
             signatures += rec->name;
             signatures += "(*args, **kwargs)\n";
@@ -601,7 +602,8 @@ protected:
         // Then specific overload signatures
         bool first_user_def = true;
         for (auto *it = chain_start; it != nullptr; it = it->next) {
-            if (options::show_function_signatures()) {
+            if (options::show_function_signatures()
+                && std::strcmp(rec->name, "_pybind11_conduit_v1_") != 0) {
                 if (index > 0) {
                     signatures += '\n';
                 }
@@ -1380,7 +1382,17 @@ protected:
             } else {
                 internals.registered_types_cpp[tindex] = tinfo;
             }
+
+            PYBIND11_WARNING_PUSH
+#if defined(__GNUC__) && __GNUC__ == 12
+            // When using GCC 12 these warnings are disabled as they trigger
+            // false positive warnings.  Discussed here:
+            // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115824.
+            PYBIND11_WARNING_DISABLE_GCC("-Warray-bounds")
+            PYBIND11_WARNING_DISABLE_GCC("-Wstringop-overread")
+#endif
             internals.registered_types_py[(PyTypeObject *) m_ptr] = {tinfo};
+            PYBIND11_WARNING_POP
         });
 
         if (rec.bases.size() > 1 || rec.multiple_inheritance) {
@@ -1601,6 +1613,7 @@ public:
                     = instances[std::type_index(typeid(type))];
             });
         }
+        def("_pybind11_conduit_v1_", cpp_conduit_method);
     }
 
     template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
@@ -2573,9 +2586,11 @@ void implicitly_convertible() {
 }
 
 inline void register_exception_translator(ExceptionTranslator &&translator) {
-    detail::with_internals([&](detail::internals &internals) {
+    detail::with_exception_translators(
-        internals.registered_exception_translators.push_front(
+        [&](std::forward_list<ExceptionTranslator> &exception_translators,
-            std::forward<ExceptionTranslator>(translator));
+            std::forward_list<ExceptionTranslator> &local_exception_translators) {
+            (void) local_exception_translators;
+            exception_translators.push_front(std::forward<ExceptionTranslator>(translator));
         });
 }
 
@@ -2586,10 +2601,11 @@ inline void register_exception_translator(ExceptionTranslator &&translator) {
  * the exception.
  */
 inline void register_local_exception_translator(ExceptionTranslator &&translator) {
-    detail::with_internals([&](detail::internals &internals) {
+    detail::with_exception_translators(
-        (void) internals;
+        [&](std::forward_list<ExceptionTranslator> &exception_translators,
-        detail::get_local_internals().registered_exception_translators.push_front(
+            std::forward_list<ExceptionTranslator> &local_exception_translators) {
-            std::forward<ExceptionTranslator>(translator));
+            (void) exception_translators;
+            local_exception_translators.push_front(std::forward<ExceptionTranslator>(translator));
         });
 }
 

tests/CMakeLists.txt

@@ -118,6 +118,7 @@ set(PYBIND11_TEST_FILES
     test_const_name
     test_constants_and_functions
     test_copy_move
+    test_cpp_conduit
     test_custom_type_casters
     test_custom_type_setup
     test_docstring_options
@@ -218,6 +219,8 @@ tests_extra_targets("test_exceptions.py;test_local_bindings.py;test_stl.py;test_
 # And add additional targets for other tests.
 tests_extra_targets("test_exceptions.py" "cross_module_interleaved_error_already_set")
 tests_extra_targets("test_gil_scoped.py" "cross_module_gil_utils")
+tests_extra_targets("test_cpp_conduit.py"
+                    "exo_planet_pybind11;exo_planet_c_api;home_planet_very_lonely_traveler")
 
 set(PYBIND11_EIGEN_REPO
     "https://gitlab.com/libeigen/eigen.git"

tests/custom_exceptions.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+class PythonMyException7(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(message)
+
+    def __str__(self):
+        return "[PythonMyException7]: " + self.message.a

tests/exo_planet_c_api.cpp

@@ -0,0 +1,103 @@
+// Copyright (c) 2024 The pybind Community.
+
+// THIS MUST STAY AT THE TOP!
+#include <pybind11/pybind11.h> // EXCLUSIVELY for PYBIND11_PLATFORM_ABI_ID
+// Potential future direction to maximize reusability:
+// (e.g. for use from SWIG, Cython, PyCLIF, nanobind):
+//     #include <pybind11/compat/platform_abi_id.h>
+// This would only depend on:
+//     1. A C++ compiler, WITHOUT requiring -fexceptions.
+//     2. Python.h
+
+#include "test_cpp_conduit_traveler_types.h"
+
+#include <Python.h>
+#include <typeinfo>
+
+namespace {
+
+void *get_cpp_conduit_void_ptr(PyObject *py_obj, const std::type_info *cpp_type_info) {
+    PyObject *cpp_type_info_capsule
+        = PyCapsule_New(const_cast<void *>(static_cast<const void *>(cpp_type_info)),
+                        typeid(std::type_info).name(),
+                        nullptr);
+    if (cpp_type_info_capsule == nullptr) {
+        return nullptr;
+    }
+    PyObject *cpp_conduit = PyObject_CallMethod(py_obj,
+                                                "_pybind11_conduit_v1_",
+                                                "yOy",
+                                                PYBIND11_PLATFORM_ABI_ID,
+                                                cpp_type_info_capsule,
+                                                "raw_pointer_ephemeral");
+    Py_DECREF(cpp_type_info_capsule);
+    if (cpp_conduit == nullptr) {
+        return nullptr;
+    }
+    void *void_ptr = PyCapsule_GetPointer(cpp_conduit, cpp_type_info->name());
+    Py_DECREF(cpp_conduit);
+    if (PyErr_Occurred()) {
+        return nullptr;
+    }
+    return void_ptr;
+}
+
+template <typename T>
+T *get_cpp_conduit_type_ptr(PyObject *py_obj) {
+    void *void_ptr = get_cpp_conduit_void_ptr(py_obj, &typeid(T));
+    if (void_ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<T *>(void_ptr);
+}
+
+extern "C" PyObject *wrapGetLuggage(PyObject * /*self*/, PyObject *traveler) {
+    const auto *cpp_traveler
+        = get_cpp_conduit_type_ptr<pybind11_tests::test_cpp_conduit::Traveler>(traveler);
+    if (cpp_traveler == nullptr) {
+        return nullptr;
+    }
+    return PyUnicode_FromString(cpp_traveler->luggage.c_str());
+}
+
+extern "C" PyObject *wrapGetPoints(PyObject * /*self*/, PyObject *premium_traveler) {
+    const auto *cpp_premium_traveler
+        = get_cpp_conduit_type_ptr<pybind11_tests::test_cpp_conduit::PremiumTraveler>(
+            premium_traveler);
+    if (cpp_premium_traveler == nullptr) {
+        return nullptr;
+    }
+    return PyLong_FromLong(static_cast<long>(cpp_premium_traveler->points));
+}
+
+PyMethodDef ThisMethodDef[] = {{"GetLuggage", wrapGetLuggage, METH_O, nullptr},
+                               {"GetPoints", wrapGetPoints, METH_O, nullptr},
+                               {nullptr, nullptr, 0, nullptr}};
+
+struct PyModuleDef ThisModuleDef = {
+    PyModuleDef_HEAD_INIT, // m_base
+    "exo_planet_c_api",    // m_name
+    nullptr,               // m_doc
+    -1,                    // m_size
+    ThisMethodDef,         // m_methods
+    nullptr,               // m_slots
+    nullptr,               // m_traverse
+    nullptr,               // m_clear
+    nullptr                // m_free
+};
+
+} // namespace
+
+#if defined(WIN32) || defined(_WIN32)
+#    define EXO_PLANET_C_API_EXPORT __declspec(dllexport)
+#else
+#    define EXO_PLANET_C_API_EXPORT __attribute__((visibility("default")))
+#endif
+
+extern "C" EXO_PLANET_C_API_EXPORT PyObject *PyInit_exo_planet_c_api() {
+    PyObject *m = PyModule_Create(&ThisModuleDef);
+    if (m == nullptr) {
+        return nullptr;
+    }
+    return m;
+}

tests/exo_planet_pybind11.cpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2024 The pybind Community.
+
+#if defined(PYBIND11_INTERNALS_VERSION)
+#    undef PYBIND11_INTERNALS_VERSION
+#endif
+#define PYBIND11_INTERNALS_VERSION 900000001
+
+#include "test_cpp_conduit_traveler_bindings.h"
+
+namespace pybind11_tests {
+namespace test_cpp_conduit {
+
+PYBIND11_MODULE(exo_planet_pybind11, m) {
+    wrap_traveler(m);
+    m.def("wrap_very_lonely_traveler", [m]() { wrap_very_lonely_traveler(m); });
+}
+
+} // namespace test_cpp_conduit
+} // namespace pybind11_tests

tests/extra_python_package/test_files.py

@@ -53,6 +53,7 @@ main_headers = {
 detail_headers = {
     "include/pybind11/detail/class.h",
     "include/pybind11/detail/common.h",
+    "include/pybind11/detail/cpp_conduit.h",
     "include/pybind11/detail/descr.h",
     "include/pybind11/detail/init.h",
     "include/pybind11/detail/internals.h",

tests/home_planet_very_lonely_traveler.cpp

@@ -0,0 +1,13 @@
+// Copyright (c) 2024 The pybind Community.
+
+#include "test_cpp_conduit_traveler_bindings.h"
+
+namespace pybind11_tests {
+namespace test_cpp_conduit {
+
+PYBIND11_MODULE(home_planet_very_lonely_traveler, m) {
+    m.def("wrap_very_lonely_traveler", [m]() { wrap_very_lonely_traveler(m); });
+}
+
+} // namespace test_cpp_conduit
+} // namespace pybind11_tests

tests/test_cpp_conduit.cpp

@@ -0,0 +1,22 @@
+// Copyright (c) 2024 The pybind Community.
+
+#include "pybind11_tests.h"
+#include "test_cpp_conduit_traveler_bindings.h"
+
+#include <typeinfo>
+
+namespace pybind11_tests {
+namespace test_cpp_conduit {
+
+TEST_SUBMODULE(cpp_conduit, m) {
+    m.attr("PYBIND11_PLATFORM_ABI_ID") = py::bytes(PYBIND11_PLATFORM_ABI_ID);
+    m.attr("cpp_type_info_capsule_Traveler")
+        = py::capsule(&typeid(Traveler), typeid(std::type_info).name());
+    m.attr("cpp_type_info_capsule_int") = py::capsule(&typeid(int), typeid(std::type_info).name());
+
+    wrap_traveler(m);
+    wrap_lonely_traveler(m);
+}
+
+} // namespace test_cpp_conduit
+} // namespace pybind11_tests

tests/test_cpp_conduit.py

@@ -0,0 +1,162 @@
+# Copyright (c) 2024 The pybind Community.
+
+from __future__ import annotations
+
+import exo_planet_c_api
+import exo_planet_pybind11
+import home_planet_very_lonely_traveler
+import pytest
+
+from pybind11_tests import cpp_conduit as home_planet
+
+
+def test_traveler_getattr_actually_exists():
+    t_h = home_planet.Traveler("home")
+    assert t_h.any_name == "Traveler GetAttr: any_name luggage: home"
+
+
+def test_premium_traveler_getattr_actually_exists():
+    t_h = home_planet.PremiumTraveler("home", 7)
+    assert t_h.secret_name == "PremiumTraveler GetAttr: secret_name points: 7"
+
+
+def test_call_cpp_conduit_success():
+    t_h = home_planet.Traveler("home")
+    cap = t_h._pybind11_conduit_v1_(
+        home_planet.PYBIND11_PLATFORM_ABI_ID,
+        home_planet.cpp_type_info_capsule_Traveler,
+        b"raw_pointer_ephemeral",
+    )
+    assert cap.__class__.__name__ == "PyCapsule"
+
+
+def test_call_cpp_conduit_platform_abi_id_mismatch():
+    t_h = home_planet.Traveler("home")
+    cap = t_h._pybind11_conduit_v1_(
+        home_planet.PYBIND11_PLATFORM_ABI_ID + b"MISMATCH",
+        home_planet.cpp_type_info_capsule_Traveler,
+        b"raw_pointer_ephemeral",
+    )
+    assert cap is None
+
+
+def test_call_cpp_conduit_cpp_type_info_capsule_mismatch():
+    t_h = home_planet.Traveler("home")
+    cap = t_h._pybind11_conduit_v1_(
+        home_planet.PYBIND11_PLATFORM_ABI_ID,
+        home_planet.cpp_type_info_capsule_int,
+        b"raw_pointer_ephemeral",
+    )
+    assert cap is None
+
+
+def test_call_cpp_conduit_pointer_kind_invalid():
+    t_h = home_planet.Traveler("home")
+    with pytest.raises(
+        RuntimeError, match='^Invalid pointer_kind: "raw_pointer_ephemreal"$'
+    ):
+        t_h._pybind11_conduit_v1_(
+            home_planet.PYBIND11_PLATFORM_ABI_ID,
+            home_planet.cpp_type_info_capsule_Traveler,
+            b"raw_pointer_ephemreal",
+        )
+
+
+def test_home_only_basic():
+    t_h = home_planet.Traveler("home")
+    assert t_h.luggage == "home"
+    assert home_planet.get_luggage(t_h) == "home"
+
+
+def test_home_only_premium():
+    p_h = home_planet.PremiumTraveler("home", 2)
+    assert p_h.luggage == "home"
+    assert home_planet.get_luggage(p_h) == "home"
+    assert home_planet.get_points(p_h) == 2
+
+
+def test_exo_only_basic():
+    t_e = exo_planet_pybind11.Traveler("exo")
+    assert t_e.luggage == "exo"
+    assert exo_planet_pybind11.get_luggage(t_e) == "exo"
+
+
+def test_exo_only_premium():
+    p_e = exo_planet_pybind11.PremiumTraveler("exo", 3)
+    assert p_e.luggage == "exo"
+    assert exo_planet_pybind11.get_luggage(p_e) == "exo"
+    assert exo_planet_pybind11.get_points(p_e) == 3
+
+
+def test_home_passed_to_exo_basic():
+    t_h = home_planet.Traveler("home")
+    assert exo_planet_pybind11.get_luggage(t_h) == "home"
+
+
+def test_exo_passed_to_home_basic():
+    t_e = exo_planet_pybind11.Traveler("exo")
+    assert home_planet.get_luggage(t_e) == "exo"
+
+
+def test_home_passed_to_exo_premium():
+    p_h = home_planet.PremiumTraveler("home", 2)
+    assert exo_planet_pybind11.get_luggage(p_h) == "home"
+    assert exo_planet_pybind11.get_points(p_h) == 2
+
+
+def test_exo_passed_to_home_premium():
+    p_e = exo_planet_pybind11.PremiumTraveler("exo", 3)
+    assert home_planet.get_luggage(p_e) == "exo"
+    assert home_planet.get_points(p_e) == 3
+
+
+@pytest.mark.parametrize(
+    "traveler_type", [home_planet.Traveler, exo_planet_pybind11.Traveler]
+)
+def test_exo_planet_c_api_traveler(traveler_type):
+    t = traveler_type("socks")
+    assert exo_planet_c_api.GetLuggage(t) == "socks"
+
+
+@pytest.mark.parametrize(
+    "premium_traveler_type",
+    [home_planet.PremiumTraveler, exo_planet_pybind11.PremiumTraveler],
+)
+def test_exo_planet_c_api_premium_traveler(premium_traveler_type):
+    pt = premium_traveler_type("gucci", 5)
+    assert exo_planet_c_api.GetLuggage(pt) == "gucci"
+    assert exo_planet_c_api.GetPoints(pt) == 5
+
+
+def test_home_planet_wrap_very_lonely_traveler():
+    # This does not exercise the cpp_conduit feature, but is here to
+    # demonstrate that the cpp_conduit feature does not solve all
+    # cross-extension interoperability issues.
+    # Here is the proof that the following works for extensions with
+    # matching `PYBIND11_INTERNALS_ID`s:
+    #     test_cpp_conduit.cpp:
+    #         py::class_<LonelyTraveler>
+    #     home_planet_very_lonely_traveler.cpp:
+    #         py::class_<VeryLonelyTraveler, LonelyTraveler>
+    # See test_exo_planet_pybind11_wrap_very_lonely_traveler() for the negative
+    # test.
+    assert home_planet.LonelyTraveler is not None  # Verify that the base class exists.
+    home_planet_very_lonely_traveler.wrap_very_lonely_traveler()
+    # Ensure that the derived class exists.
+    assert home_planet_very_lonely_traveler.VeryLonelyTraveler is not None
+
+
+def test_exo_planet_pybind11_wrap_very_lonely_traveler():
+    # See comment under test_home_planet_wrap_very_lonely_traveler() first.
+    # Here the `PYBIND11_INTERNALS_ID`s don't match between:
+    #     test_cpp_conduit.cpp:
+    #         py::class_<LonelyTraveler>
+    #     exo_planet_pybind11.cpp:
+    #         py::class_<VeryLonelyTraveler, LonelyTraveler>
+    assert home_planet.LonelyTraveler is not None  # Verify that the base class exists.
+    with pytest.raises(
+        RuntimeError,
+        match='^generic_type: type "VeryLonelyTraveler" referenced unknown base type '
+        '"pybind11_tests::test_cpp_conduit::LonelyTraveler"$',
+    ):
+        exo_planet_pybind11.wrap_very_lonely_traveler()

tests/test_cpp_conduit_traveler_bindings.h

@@ -0,0 +1,47 @@
+// Copyright (c) 2024 The pybind Community.
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+#include "test_cpp_conduit_traveler_types.h"
+
+#include <string>
+
+namespace pybind11_tests {
+namespace test_cpp_conduit {
+
+namespace py = pybind11;
+
+inline void wrap_traveler(py::module_ m) {
+    py::class_<Traveler>(m, "Traveler")
+        .def(py::init<std::string>())
+        .def_readwrite("luggage", &Traveler::luggage)
+        // See issue #3788:
+        .def("__getattr__", [](const Traveler &self, const std::string &key) {
+            return "Traveler GetAttr: " + key + " luggage: " + self.luggage;
+        });
+
+    m.def("get_luggage", [](const Traveler &person) { return person.luggage; });
+
+    py::class_<PremiumTraveler, Traveler>(m, "PremiumTraveler")
+        .def(py::init<std::string, int>())
+        .def_readwrite("points", &PremiumTraveler::points)
+        // See issue #3788:
+        .def("__getattr__", [](const PremiumTraveler &self, const std::string &key) {
+            return "PremiumTraveler GetAttr: " + key + " points: " + std::to_string(self.points);
+        });
+
+    m.def("get_points", [](const PremiumTraveler &person) { return person.points; });
+}
+
+inline void wrap_lonely_traveler(py::module_ m) {
+    py::class_<LonelyTraveler>(std::move(m), "LonelyTraveler");
+}
+
+inline void wrap_very_lonely_traveler(py::module_ m) {
+    py::class_<VeryLonelyTraveler, LonelyTraveler>(std::move(m), "VeryLonelyTraveler");
+}
+
+} // namespace test_cpp_conduit
+} // namespace pybind11_tests

tests/test_cpp_conduit_traveler_types.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2024 The pybind Community.
+
+#pragma once
+
+#include <string>
+
+namespace pybind11_tests {
+namespace test_cpp_conduit {
+
+struct Traveler {
+    explicit Traveler(const std::string &luggage) : luggage(luggage) {}
+    std::string luggage;
+};
+
+struct PremiumTraveler : Traveler {
+    explicit PremiumTraveler(const std::string &luggage, int points)
+        : Traveler(luggage), points(points) {}
+    int points;
+};
+
+struct LonelyTraveler {};
+struct VeryLonelyTraveler : LonelyTraveler {};
+
+} // namespace test_cpp_conduit
+} // namespace pybind11_tests

tests/test_exceptions.cpp

@@ -111,6 +111,16 @@ struct PythonAlreadySetInDestructor {
     py::str s;
 };
 
+struct CustomData {
+    explicit CustomData(const std::string &a) : a(a) {}
+    std::string a;
+};
+
+struct MyException7 {
+    explicit MyException7(const CustomData &message) : message(message) {}
+    CustomData message;
+};
+
 TEST_SUBMODULE(exceptions, m) {
     m.def("throw_std_exception",
           []() { throw std::runtime_error("This exception was intentionally thrown."); });
@@ -385,4 +395,33 @@ TEST_SUBMODULE(exceptions, m) {
 
     // m.def("pass_exception_void", [](const py::exception<void>&) {}); // Does not compile.
     m.def("return_exception_void", []() { return py::exception<void>(); });
+
+    m.def("throws7", []() {
+        auto data = CustomData("abc");
+        throw MyException7(data);
+    });
+
+    py::class_<CustomData>(m, "CustomData", py::module_local())
+        .def(py::init<const std::string &>())
+        .def_readwrite("a", &CustomData::a);
+
+    PYBIND11_CONSTINIT static py::gil_safe_call_once_and_store<py::object>
+        PythonMyException7_storage;
+    PythonMyException7_storage.call_once_and_store_result([&]() {
+        auto mod = py::module_::import("custom_exceptions");
+        py::object obj = mod.attr("PythonMyException7");
+        return obj;
+    });
+
+    py::register_local_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const MyException7 &e) {
+            auto exc_type = PythonMyException7_storage.get_stored();
+            py::object exc_inst = exc_type(e.message);
+            PyErr_SetObject(PyExc_Exception, exc_inst.ptr());
+        }
+    });
 }

tests/test_exceptions.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import sys
 
 import pytest
+from custom_exceptions import PythonMyException7
 
 import env
 import pybind11_cross_module_tests as cm
@@ -195,6 +196,10 @@ def test_custom(msg):
             raise RuntimeError("Exception error: caught child from parent") from err
     assert msg(excinfo.value) == "this is a helper-defined translated exception"
 
+    with pytest.raises(PythonMyException7) as excinfo:
+        m.throws7()
+    assert msg(excinfo.value) == "[PythonMyException7]: abc"
+
 
 def test_nested_throws(capture):
     """Tests nested (e.g. C++ -> Python -> C++) exception handling"""

tools/pybind11NewTools.cmake

@@ -274,10 +274,6 @@ function(pybind11_add_module target_name)
     target_link_libraries(${target_name} PRIVATE pybind11::embed)
   endif()
 
-  if(MSVC)
-    target_link_libraries(${target_name} PRIVATE pybind11::windows_extras)
-  endif()
-
   # -fvisibility=hidden is required to allow multiple modules compiled against
   # different pybind versions to work properly, and for some features (e.g.
   # py::module_local).  We force it on everything inside the `pybind11`