Revert "Update pybind11 to version 2.10.4" for now.

This reverts commits 9d077c9ba5 and
b4938f5198.

They cause a crash-on-startup on Mac ARM machines, failing to get the
locale encoding (nl_langinfo(CODESET) failed).

thirdparty/pybind11/.clang-format

@@ -1,38 +0,0 @@
----
-# See all possible options and defaults with:
-# clang-format --style=llvm --dump-config
-BasedOnStyle: LLVM
-AccessModifierOffset: -4
-AllowShortLambdasOnASingleLine: true
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
-BreakBeforeBinaryOperators: All
-BreakConstructorInitializers: BeforeColon
-ColumnLimit: 99
-CommentPragmas: 'NOLINT:.*|^ IWYU pragma:'
-IncludeBlocks: Regroup
-IndentCaseLabels: true
-IndentPPDirectives: AfterHash
-IndentWidth: 4
-Language: Cpp
-SpaceAfterCStyleCast: true
-Standard: Cpp11
-StatementMacros: ['PyObject_HEAD']
-TabWidth: 4
-IncludeCategories:
-  - Regex:           '<pybind11/.*'
-    Priority:        -1
-  - Regex:           'pybind11.h"$'
-    Priority:        1
-  - Regex:           '^".*/?detail/'
-    Priority:        1
-    SortPriority:    2
-  - Regex:           '^"'
-    Priority:        1
-    SortPriority:    3
-  - Regex:           '<[[:alnum:]._]+>'
-    Priority:        4
-  - Regex:           '.*'
-    Priority:        5
-...

thirdparty/pybind11/.clang-tidy

@@ -1,77 +1,13 @@
 FormatStyle: file
 
-Checks: |
-  *bugprone*,
-  *performance*,
-  clang-analyzer-optin.cplusplus.VirtualCall,
-  clang-analyzer-optin.performance.Padding,
-  cppcoreguidelines-init-variables,
-  cppcoreguidelines-prefer-member-initializer,
-  cppcoreguidelines-pro-type-static-cast-downcast,
-  cppcoreguidelines-slicing,
-  google-explicit-constructor,
-  llvm-namespace-comment,
-  misc-definitions-in-headers,
-  misc-misplaced-const,
-  misc-non-copyable-objects,
-  misc-static-assert,
-  misc-throw-by-value-catch-by-reference,
-  misc-uniqueptr-reset-release,
-  misc-unused-parameters,
-  modernize-avoid-bind,
-  modernize-loop-convert,
-  modernize-make-shared,
-  modernize-redundant-void-arg,
-  modernize-replace-auto-ptr,
-  modernize-replace-disallow-copy-and-assign-macro,
-  modernize-replace-random-shuffle,
-  modernize-shrink-to-fit,
-  modernize-use-auto,
-  modernize-use-bool-literals,
-  modernize-use-default-member-init,
-  modernize-use-emplace,
-  modernize-use-equals-default,
-  modernize-use-equals-delete,
-  modernize-use-noexcept,
-  modernize-use-nullptr,
-  modernize-use-override,
-  modernize-use-using,
-  readability-avoid-const-params-in-decls,
-  readability-braces-around-statements,
-  readability-const-return-type,
-  readability-container-size-empty,
-  readability-delete-null-pointer,
-  readability-else-after-return,
-  readability-implicit-bool-conversion,
-  readability-inconsistent-declaration-parameter-name,
-  readability-make-member-function-const,
-  readability-misplaced-array-index,
-  readability-non-const-parameter,
-  readability-qualified-auto,
-  readability-redundant-function-ptr-dereference,
-  readability-redundant-smartptr-get,
-  readability-redundant-string-cstr,
-  readability-simplify-subscript-expr,
-  readability-static-accessed-through-instance,
-  readability-static-definition-in-anonymous-namespace,
-  readability-string-compare,
-  readability-suspicious-call-argument,
-  readability-uniqueptr-delete-release,
-  -bugprone-easily-swappable-parameters,
-  -bugprone-exception-escape,
-  -bugprone-reserved-identifier,
-  -bugprone-unused-raii,
-
-CheckOptions:
-- key:             modernize-use-equals-default.IgnoreMacros
-  value:           false
-- key:             performance-for-range-copy.WarnOnAllAutoCopies
-  value:           true
-- key:             performance-inefficient-string-concatenation.StrictMode
-  value:           true
-- key:             performance-unnecessary-value-param.AllowedTypes
-  value:           'exception_ptr$;'
-- key:             readability-implicit-bool-conversion.AllowPointerConditions
-  value:           true
+Checks: '
+llvm-namespace-comment,
+modernize-use-override,
+readability-container-size-empty,
+modernize-use-using,
+modernize-use-equals-default,
+modernize-use-auto,
+modernize-use-emplace,
+'
 
 HeaderFilterRegex: 'pybind11/.*h'

thirdparty/pybind11/.cmake-format.yaml

@@ -1,73 +0,0 @@
-parse:
-  additional_commands:
-    pybind11_add_module:
-      flags:
-        - THIN_LTO
-        - MODULE
-        - SHARED
-        - NO_EXTRAS
-        - EXCLUDE_FROM_ALL
-        - SYSTEM
-
-format:
-  line_width: 99
-  tab_size: 2
-
-  # If an argument group contains more than this many sub-groups
-  # (parg or kwarg groups) then force it to a vertical layout.
-  max_subgroups_hwrap: 2
-
-  # If a positional argument group contains more than this many
-  # arguments, then force it to a vertical layout.
-  max_pargs_hwrap: 6
-
-  # If a cmdline positional group consumes more than this many
-  # lines without nesting, then invalidate the layout (and nest)
-  max_rows_cmdline: 2
-  separate_ctrl_name_with_space: false
-  separate_fn_name_with_space: false
-  dangle_parens: false
-
-  # If the trailing parenthesis must be 'dangled' on its on
-  # 'line, then align it to this reference: `prefix`: the start'
-  # 'of the statement,  `prefix-indent`: the start of the'
-  # 'statement, plus one indentation  level, `child`: align to'
-  # the column of the arguments
-  dangle_align: prefix
-  # If the statement spelling length (including space and
-  # parenthesis) is smaller than this amount, then force reject
-  # nested layouts.
-  min_prefix_chars: 4
-
-  # If the statement spelling length (including space and
-  # parenthesis) is larger than the tab width by more than this
-  # amount, then force reject un-nested layouts.
-  max_prefix_chars: 10
-
-  # If a candidate layout is wrapped horizontally but it exceeds
-  # this many lines, then reject the layout.
-  max_lines_hwrap: 2
-
-  line_ending: unix
-
-  # Format command names consistently as 'lower' or 'upper' case
-  command_case: canonical
-
-  # Format keywords consistently as 'lower' or 'upper' case
-  # unchanged is valid too
-  keyword_case: 'upper'
-
-  # A list of command names which should always be wrapped
-  always_wrap: []
-
-  # If true, the argument lists which are known to be sortable
-  # will be sorted lexicographically
-  enable_sort: true
-
-  # If true, the parsers may infer whether or not an argument
-  # list is sortable (without annotation).
-  autosort: false
-
-# Causes a few issues - can be solved later, possibly.
-markup:
-  enable_markup: false

thirdparty/pybind11/.codespell-ignore-lines

@@ -1,24 +0,0 @@
-template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t>
-    template <typename ThisT>
-        auto &this_ = static_cast<ThisT &>(*this);
-                if (load_impl<ThisT>(temp, false)) {
-        ssize_t nd = 0;
-        auto trivial = broadcast(buffers, nd, shape);
-        auto ndim = (size_t) nd;
-    int nd;
-    ssize_t ndim() const { return detail::array_proxy(m_ptr)->nd; }
-        using op = op_impl<id, ot, Base, L_type, R_type>;
-template <op_id id, op_type ot, typename L, typename R>
-    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra &...extra) {
-    class_ &def_cast(const detail::op_<id, ot, L, R> &op, const Extra &...extra) {
-@pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"])
-struct IntStruct {
-    explicit IntStruct(int v) : value(v){};
-    ~IntStruct() { value = -value; }
-    IntStruct(const IntStruct &) = default;
-    IntStruct &operator=(const IntStruct &) = default;
-    py::class_<IntStruct>(m, "IntStruct").def(py::init([](const int i) { return IntStruct(i); }));
-    py::implicitly_convertible<int, IntStruct>();
-    m.def("test", [](int expected, const IntStruct &in) {
-        [](int expected, const IntStruct &in) {

thirdparty/pybind11/.gitattributes

@@ -1 +0,0 @@
-docs/*.svg binary

thirdparty/pybind11/.gitignore

@@ -41,6 +41,3 @@ pybind11Targets.cmake
 /.vscode
 /pybind11/include/*
 /pybind11/share/*
-/docs/_build/*
-.ipynb_checkpoints/
-tests/main.cpp

thirdparty/pybind11/CMakeLists.txt

@@ -91,16 +91,10 @@ endif()
 option(PYBIND11_INSTALL "Install pybind11 header files?" ${PYBIND11_MASTER_PROJECT})
 option(PYBIND11_TEST "Build pybind11 test suite?" ${PYBIND11_MASTER_PROJECT})
 option(PYBIND11_NOPYTHON "Disable search for Python" OFF)
-option(PYBIND11_SIMPLE_GIL_MANAGEMENT
-       "Use simpler GIL management logic that does not support disassociation" OFF)
 set(PYBIND11_INTERNALS_VERSION
     ""
     CACHE STRING "Override the ABI version, may be used to enable the unstable ABI.")
 
-if(PYBIND11_SIMPLE_GIL_MANAGEMENT)
-  add_compile_definitions(PYBIND11_SIMPLE_GIL_MANAGEMENT)
-endif()
-
 cmake_dependent_option(
   USE_PYTHON_INCLUDE_DIR
   "Install pybind11 headers in Python include directory instead of default installation prefix"
@@ -126,8 +120,6 @@ set(PYBIND11_HEADERS
     include/pybind11/complex.h
     include/pybind11/options.h
     include/pybind11/eigen.h
-    include/pybind11/eigen/matrix.h
-    include/pybind11/eigen/tensor.h
     include/pybind11/embed.h
     include/pybind11/eval.h
     include/pybind11/gil.h
@@ -206,9 +198,6 @@ else()
 endif()
 
 include("${CMAKE_CURRENT_SOURCE_DIR}/tools/pybind11Common.cmake")
-# https://github.com/jtojnar/cmake-snips/#concatenating-paths-when-building-pkg-config-files
-# TODO: cmake 3.20 adds the cmake_path() function, which obsoletes this snippet
-include("${CMAKE_CURRENT_SOURCE_DIR}/tools/JoinPaths.cmake")
 
 # Relative directory setting
 if(USE_PYTHON_INCLUDE_DIR AND DEFINED Python_INCLUDE_DIRS)
@@ -273,16 +262,6 @@ if(PYBIND11_INSTALL)
     NAMESPACE "pybind11::"
     DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
 
-  # pkg-config support
-  if(NOT prefix_for_pc_file)
-    set(prefix_for_pc_file "${CMAKE_INSTALL_PREFIX}")
-  endif()
-  join_paths(includedir_for_pc_file "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
-  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tools/pybind11.pc.in"
-                 "${CMAKE_CURRENT_BINARY_DIR}/pybind11.pc" @ONLY)
-  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/pybind11.pc"
-          DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig/")
-
   # Uninstall target
   if(PYBIND11_MASTER_PROJECT)
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake_uninstall.cmake.in"

thirdparty/pybind11/MANIFEST.in

@@ -1,6 +1,6 @@
-prune tests
 recursive-include pybind11/include/pybind11 *.h
 recursive-include pybind11 *.py
 recursive-include pybind11 py.typed
+recursive-include pybind11 *.pyi
 include pybind11/share/cmake/pybind11/*.cmake
 include LICENSE README.rst pyproject.toml setup.py setup.cfg

thirdparty/pybind11/README.rst

@@ -32,9 +32,9 @@ this heavy machinery has become an excessively large and unnecessary
 dependency.
 
 Think of this library as a tiny self-contained version of Boost.Python
-with everything stripped away that isn't relevant for binding
+with everything stripped away that isn’t relevant for binding
 generation. Without comments, the core header files only require ~4K
-lines of code and depend on Python (3.6+, or PyPy) and the C++
+lines of code and depend on Python (2.7 or 3.5+, or PyPy) and the C++
 standard library. This compact implementation was possible thanks to
 some of the new C++11 language features (specifically: tuples, lambda
 functions and variadic templates). Since its creation, this library has
@@ -78,8 +78,8 @@ Goodies
 In addition to the core functionality, pybind11 provides some extra
 goodies:
 
-- Python 3.6+, and PyPy3 7.3 are supported with an implementation-agnostic
-  interface (pybind11 2.9 was the last version to support Python 2 and 3.5).
+- Python 2.7, 3.5+, and PyPy/PyPy3 7.3 are supported with an
+  implementation-agnostic interface.
 
 - It is possible to bind C++11 lambda functions with captured
   variables. The lambda capture data is stored inside the resulting
@@ -88,8 +88,8 @@ goodies:
 - pybind11 uses C++11 move constructors and move assignment operators
   whenever possible to efficiently transfer custom data types.
 
-- It's easy to expose the internal storage of custom data types through
-  Pythons' buffer protocols. This is handy e.g. for fast conversion
+- It’s easy to expose the internal storage of custom data types through
+  Pythons’ buffer protocols. This is handy e.g. for fast conversion
   between C++ matrix classes like Eigen and NumPy without expensive
   copy operations.
 
@@ -119,10 +119,10 @@ goodies:
 Supported compilers
 -------------------
 
-1. Clang/LLVM 3.3 or newer (for Apple Xcode's clang, this is 5.0.0 or
+1. Clang/LLVM 3.3 or newer (for Apple Xcode’s clang, this is 5.0.0 or
    newer)
 2. GCC 4.8 or newer
-3. Microsoft Visual Studio 2017 or newer
+3. Microsoft Visual Studio 2015 Update 3 or newer
 4. Intel classic C++ compiler 18 or newer (ICC 20.2 tested in CI)
 5. Cygwin/GCC (previously tested on 2.5.1)
 6. NVCC (CUDA 11.0 tested in CI)

thirdparty/pybind11/docs/Doxyfile

@@ -18,4 +18,5 @@ ALIASES               += "endrst=\endverbatim"
 QUIET                  = YES
 WARNINGS               = YES
 WARN_IF_UNDOCUMENTED   = NO
-PREDEFINED             = PYBIND11_NOINLINE
+PREDEFINED             = PY_MAJOR_VERSION=3 \
+                         PYBIND11_NOINLINE

thirdparty/pybind11/docs/_static/css/custom.css

@@ -1,3 +0,0 @@
-.highlight .go {
-  color: #707070;
-}

thirdparty/pybind11/docs/_static/theme_overrides.css

@@ -0,0 +1,11 @@
+.wy-table-responsive table td,
+.wy-table-responsive table th {
+    white-space: initial !important;
+}
+.rst-content table.docutils td {
+    vertical-align: top !important;
+}
+div[class^='highlight'] pre {
+    white-space: pre;
+    white-space: pre-wrap;
+}

thirdparty/pybind11/docs/advanced/cast/custom.rst

@@ -38,7 +38,7 @@ type is explicitly allowed.
 
 .. code-block:: cpp
 
-    namespace PYBIND11_NAMESPACE { namespace detail {
+    namespace pybind11 { namespace detail {
         template <> struct type_caster<inty> {
         public:
             /**
@@ -78,7 +78,7 @@ type is explicitly allowed.
                 return PyLong_FromLong(src.long_value);
             }
         };
-    }} // namespace PYBIND11_NAMESPACE::detail
+    }} // namespace pybind11::detail
 
 .. note::
 

thirdparty/pybind11/docs/advanced/cast/overview.rst

@@ -167,4 +167,5 @@ as arguments and return values, refer to the section on binding :ref:`classes`.
 +------------------------------------+---------------------------+-----------------------------------+
 
 .. [#] ``std::filesystem::path`` is converted to ``pathlib.Path`` and
-   ``os.PathLike`` is converted to ``std::filesystem::path``.
+   ``os.PathLike`` is converted to ``std::filesystem::path``, but this requires
+   Python 3.6 (for ``__fspath__`` support).

thirdparty/pybind11/docs/advanced/cast/stl.rst

@@ -42,7 +42,7 @@ types:
 .. code-block:: cpp
 
     // `boost::optional` as an example -- can be any `std::optional`-like container
-    namespace PYBIND11_NAMESPACE { namespace detail {
+    namespace pybind11 { namespace detail {
         template <typename T>
         struct type_caster<boost::optional<T>> : optional_caster<boost::optional<T>> {};
     }}
@@ -54,7 +54,7 @@ for custom variant types:
 .. code-block:: cpp
 
     // `boost::variant` as an example -- can be any `std::variant`-like container
-    namespace PYBIND11_NAMESPACE { namespace detail {
+    namespace pybind11 { namespace detail {
         template <typename... Ts>
         struct type_caster<boost::variant<Ts...>> : variant_caster<boost::variant<Ts...>> {};
 
@@ -66,7 +66,7 @@ for custom variant types:
                 return boost::apply_visitor(args...);
             }
         };
-    }} // namespace PYBIND11_NAMESPACE::detail
+    }} // namespace pybind11::detail
 
 The ``visit_helper`` specialization is not required if your ``name::variant`` provides
 a ``name::visit()`` function. For any other function name, the specialization must be
@@ -87,6 +87,8 @@ included to tell pybind11 how to visit the variant.
 
     pybind11 only supports the modern implementation of ``boost::variant``
     which makes use of variadic templates. This requires Boost 1.56 or newer.
+    Additionally, on Windows, MSVC 2017 is required because ``boost::variant``
+    falls back to the old non-variadic implementation on MSVC 2015.
 
 .. _opaque:
 

thirdparty/pybind11/docs/advanced/cast/strings.rst

@@ -1,6 +1,14 @@
 Strings, bytes and Unicode conversions
 ######################################
 
+.. note::
+
+    This section discusses string handling in terms of Python 3 strings. For
+    Python 2.7, replace all occurrences of ``str`` with ``unicode`` and
+    ``bytes`` with ``str``.  Python 2.7 users may find it best to use ``from
+    __future__ import unicode_literals`` to avoid unintentionally using ``str``
+    instead of ``unicode``.
+
 Passing Python strings to C++
 =============================
 
@@ -50,9 +58,9 @@ Passing bytes to C++
 --------------------
 
 A Python ``bytes`` object will be passed to C++ functions that accept
-``std::string`` or ``char*`` *without* conversion.  In order to make a function
-*only* accept ``bytes`` (and not ``str``), declare it as taking a ``py::bytes``
-argument.
+``std::string`` or ``char*`` *without* conversion.  On Python 3, in order to
+make a function *only* accept ``bytes`` (and not ``str``), declare it as taking
+a ``py::bytes`` argument.
 
 
 Returning C++ strings to Python
@@ -196,6 +204,11 @@ decoded to Python ``str``.
         }
     );
 
+.. warning::
+
+    Wide character strings may not work as described on Python 2.7 or Python
+    3.3 compiled with ``--enable-unicode=ucs2``.
+
 Strings in multibyte encodings such as Shift-JIS must transcoded to a
 UTF-8/16/32 before being returned to Python.
 

thirdparty/pybind11/docs/advanced/classes.rst

@@ -133,14 +133,14 @@ a virtual method call.
     >>> from example import *
     >>> d = Dog()
     >>> call_go(d)
-    'woof! woof! woof! '
+    u'woof! woof! woof! '
     >>> class Cat(Animal):
     ...     def go(self, n_times):
     ...         return "meow! " * n_times
     ...
     >>> c = Cat()
     >>> call_go(c)
-    'meow! meow! meow! '
+    u'meow! meow! meow! '
 
 If you are defining a custom constructor in a derived Python class, you *must*
 ensure that you explicitly call the bound C++ constructor using ``__init__``,
@@ -813,21 +813,26 @@ An instance can now be pickled as follows:
 
 .. code-block:: python
 
-    import pickle
+    try:
+        import cPickle as pickle  # Use cPickle on Python 2.7
+    except ImportError:
+        import pickle
 
     p = Pickleable("test_value")
     p.setExtra(15)
-    data = pickle.dumps(p)
+    data = pickle.dumps(p, 2)
 
 
 .. note::
-    If given, the second argument to ``dumps`` must be 2 or larger - 0 and 1 are
-    not supported. Newer versions are also fine; for instance, specify ``-1`` to
-    always use the latest available version. Beware: failure to follow these
-    instructions will cause important pybind11 memory allocation routines to be
-    skipped during unpickling, which will likely lead to memory corruption
-    and/or segmentation faults. Python defaults to version 3 (Python 3-3.7) and
-    version 4 for Python 3.8+.
+    Note that only the cPickle module is supported on Python 2.7.
+
+    The second argument to ``dumps`` is also crucial: it selects the pickle
+    protocol version 2, since the older version 1 is not supported. Newer
+    versions are also fine—for instance, specify ``-1`` to always use the
+    latest available version. Beware: failure to follow these instructions
+    will cause important pybind11 memory allocation routines to be skipped
+    during unpickling, which will likely lead to memory corruption and/or
+    segmentation faults.
 
 .. seealso::
 
@@ -844,9 +849,11 @@ Python normally uses references in assignments. Sometimes a real copy is needed
 to prevent changing all copies. The ``copy`` module [#f5]_ provides these
 capabilities.
 
-A class with pickle support is automatically also (deep)copy
+On Python 3, a class with pickle support is automatically also (deep)copy
 compatible. However, performance can be improved by adding custom
-``__copy__`` and ``__deepcopy__`` methods.
+``__copy__`` and ``__deepcopy__`` methods. With Python 2.7, these custom methods
+are mandatory for (deep)copy compatibility, because pybind11 only supports
+cPickle.
 
 For simple classes (deep)copy can be enabled by using the copy constructor,
 which should look as follows:
@@ -1118,6 +1125,13 @@ described trampoline:
     py::class_<A, Trampoline>(m, "A") // <-- `Trampoline` here
         .def("foo", &Publicist::foo); // <-- `Publicist` here, not `Trampoline`!
 
+.. note::
+
+    MSVC 2015 has a compiler bug (fixed in version 2017) which
+    requires a more explicit function binding in the form of
+    ``.def("foo", static_cast<int (A::*)() const>(&Publicist::foo));``
+    where ``int (A::*)() const`` is the type of ``A::foo``.
+
 Binding final classes
 =====================
 
@@ -1228,7 +1242,7 @@ whether a downcast is safe, you can proceed by specializing the
         std::string bark() const { return sound; }
     };
 
-    namespace PYBIND11_NAMESPACE {
+    namespace pybind11 {
         template<> struct polymorphic_type_hook<Pet> {
             static const void *get(const Pet *src, const std::type_info*& type) {
                 // note that src may be nullptr
@@ -1239,7 +1253,7 @@ whether a downcast is safe, you can proceed by specializing the
                 return src;
             }
         };
-    } // namespace PYBIND11_NAMESPACE
+    } // namespace pybind11
 
 When pybind11 wants to convert a C++ pointer of type ``Base*`` to a
 Python object, it calls ``polymorphic_type_hook<Base>::get()`` to

thirdparty/pybind11/docs/advanced/exceptions.rst

@@ -177,12 +177,9 @@ section.
     may be explicitly (re-)thrown to delegate it to the other,
     previously-declared existing exception translators.
 
-    Note that ``libc++`` and ``libstdc++`` `behave differently under macOS
-    <https://stackoverflow.com/questions/19496643/using-clang-fvisibility-hidden-and-typeinfo-and-type-erasure/28827430>`_
-    with ``-fvisibility=hidden``. Therefore exceptions that are used across ABI
-    boundaries need to be explicitly exported, as exercised in
-    ``tests/test_exceptions.h``. See also:
-    "Problems with C++ exceptions" under `GCC Wiki <https://gcc.gnu.org/wiki/Visibility>`_.
+    Note that ``libc++`` and ``libstdc++`` `behave differently <https://stackoverflow.com/questions/19496643/using-clang-fvisibility-hidden-and-typeinfo-and-type-erasure/28827430>`_
+    with ``-fvisibility=hidden``. Therefore exceptions that are used across ABI boundaries need to be explicitly exported, as exercised in ``tests/test_exceptions.h``.
+    See also: "Problems with C++ exceptions" under `GCC Wiki <https://gcc.gnu.org/wiki/Visibility>`_.
 
 
 Local vs Global Exception Translators
@@ -331,8 +328,8 @@ an invalid state.
 Chaining exceptions ('raise from')
 ==================================
 
-Python has a mechanism for indicating that exceptions were caused by other
-exceptions:
+In Python 3.3 a mechanism for indicating that exceptions were caused by other
+exceptions was introduced:
 
 .. code-block:: py
 
@@ -343,7 +340,7 @@ exceptions:
 
 To do a similar thing in pybind11, you can use the ``py::raise_from`` function. It
 sets the current python error indicator, so to continue propagating the exception
-you should ``throw py::error_already_set()``.
+you should ``throw py::error_already_set()`` (Python 3 only).
 
 .. code-block:: cpp
 

thirdparty/pybind11/docs/advanced/functions.rst

@@ -372,7 +372,7 @@ like so:
 Keyword-only arguments
 ======================
 
-Python implements keyword-only arguments by specifying an unnamed ``*``
+Python 3 introduced keyword-only arguments by specifying an unnamed ``*``
 argument in a function definition:
 
 .. code-block:: python
@@ -395,18 +395,19 @@ argument annotations when registering the function:
     m.def("f", [](int a, int b) { /* ... */ },
           py::arg("a"), py::kw_only(), py::arg("b"));
 
+Note that you currently cannot combine this with a ``py::args`` argument.  This
+feature does *not* require Python 3 to work.
+
 .. versionadded:: 2.6
 
-A ``py::args`` argument implies that any following arguments are keyword-only,
-as if ``py::kw_only()`` had been specified in the same relative location of the
-argument list as the ``py::args`` argument.  The ``py::kw_only()`` may be
-included to be explicit about this, but is not required.
-
-.. versionchanged:: 2.9
-   This can now be combined with ``py::args``. Before, ``py::args`` could only
-   occur at the end of the argument list, or immediately before a ``py::kwargs``
-   argument at the end.
+As of pybind11 2.9, a ``py::args`` argument implies that any following arguments
+are keyword-only, as if ``py::kw_only()`` had been specified in the same
+relative location of the argument list as the ``py::args`` argument.  The
+``py::kw_only()`` may be included to be explicit about this, but is not
+required.  (Prior to 2.9 ``py::args`` may only occur at the end of the argument
+list, or immediately before a ``py::kwargs`` argument at the end).
 
+.. versionadded:: 2.9
 
 Positional-only arguments
 =========================

thirdparty/pybind11/docs/advanced/misc.rst

@@ -39,42 +39,15 @@ The ``PYBIND11_MAKE_OPAQUE`` macro does *not* require the above workarounds.
 Global Interpreter Lock (GIL)
 =============================
 
-The Python C API dictates that the Global Interpreter Lock (GIL) must always
-be held by the current thread to safely access Python objects. As a result,
-when Python calls into C++ via pybind11 the GIL must be held, and pybind11
-will never implicitly release the GIL.
-
-.. code-block:: cpp
-
-    void my_function() {
-        /* GIL is held when this function is called from Python */
-    }
-
-    PYBIND11_MODULE(example, m) {
-        m.def("my_function", &my_function);
-    }
-
-pybind11 will ensure that the GIL is held when it knows that it is calling
-Python code. For example, if a Python callback is passed to C++ code via
-``std::function``, when C++ code calls the function the built-in wrapper
-will acquire the GIL before calling the Python callback. Similarly, the
-``PYBIND11_OVERRIDE`` family of macros will acquire the GIL before calling
-back into Python.
-
-When writing C++ code that is called from other C++ code, if that code accesses
-Python state, it must explicitly acquire and release the GIL.
-
+When calling a C++ function from Python, the GIL is always held.
 The classes :class:`gil_scoped_release` and :class:`gil_scoped_acquire` can be
 used to acquire and release the global interpreter lock in the body of a C++
 function call. In this way, long-running C++ code can be parallelized using
-multiple Python threads, **but great care must be taken** when any
-:class:`gil_scoped_release` appear: if there is any way that the C++ code
-can access Python objects, :class:`gil_scoped_acquire` should be used to
-reacquire the GIL. Taking :ref:`overriding_virtuals` as an example, this
+multiple Python threads. Taking :ref:`overriding_virtuals` as an example, this
 could be realized as follows (important changes highlighted):
 
 .. code-block:: cpp
-    :emphasize-lines: 8,30,31
+    :emphasize-lines: 8,9,31,32
 
     class PyAnimal : public Animal {
     public:
@@ -83,7 +56,9 @@ could be realized as follows (important changes highlighted):
 
         /* Trampoline (need one for each virtual function) */
         std::string go(int n_times) {
-            /* PYBIND11_OVERRIDE_PURE will acquire the GIL before accessing Python state */
+            /* Acquire GIL before calling Python code */
+            py::gil_scoped_acquire acquire;
+
             PYBIND11_OVERRIDE_PURE(
                 std::string, /* Return type */
                 Animal,      /* Parent class */
@@ -103,8 +78,7 @@ could be realized as follows (important changes highlighted):
             .def(py::init<>());
 
         m.def("call_go", [](Animal *animal) -> std::string {
-            // GIL is held when called from Python code. Release GIL before
-            // calling into (potentially long-running) C++ code
+            /* Release GIL before calling into (potentially long-running) C++ code */
             py::gil_scoped_release release;
             return call_go(animal);
         });
@@ -118,34 +92,6 @@ The ``call_go`` wrapper can also be simplified using the ``call_guard`` policy
     m.def("call_go", &call_go, py::call_guard<py::gil_scoped_release>());
 
 
-Common Sources Of Global Interpreter Lock Errors
-==================================================================
-
-Failing to properly hold the Global Interpreter Lock (GIL) is one of the
-more common sources of bugs within code that uses pybind11. If you are
-running into GIL related errors, we highly recommend you consult the
-following checklist.
-
-- Do you have any global variables that are pybind11 objects or invoke
-  pybind11 functions in either their constructor or destructor? You are generally
-  not allowed to invoke any Python function in a global static context. We recommend
-  using lazy initialization and then intentionally leaking at the end of the program.
-
-- Do you have any pybind11 objects that are members of other C++ structures? One
-  commonly overlooked requirement is that pybind11 objects have to increase their reference count
-  whenever their copy constructor is called. Thus, you need to be holding the GIL to invoke
-  the copy constructor of any C++ class that has a pybind11 member. This can sometimes be very
-  tricky to track for complicated programs Think carefully when you make a pybind11 object
-  a member in another struct.
-
-- C++ destructors that invoke Python functions can be particularly troublesome as
-  destructors can sometimes get invoked in weird and unexpected circumstances as a result
-  of exceptions.
-
-- You should try running your code in a debug build. That will enable additional assertions
-  within pybind11 that will throw exceptions on certain GIL handling errors
-  (reference counting operations).
-
 Binding sequence data types, iterators, the slicing protocol, etc.
 ==================================================================
 
@@ -352,15 +298,6 @@ The class ``options`` allows you to selectively suppress auto-generated signatur
         m.def("add", [](int a, int b) { return a + b; }, "A function which adds two numbers");
     }
 
-pybind11 also appends all members of an enum to the resulting enum docstring.
-This default behavior can be disabled by using the ``disable_enum_members_docstring()``
-function of the ``options`` class.
-
-With ``disable_user_defined_docstrings()`` all user defined docstrings of
-``module_::def()``, ``class_::def()`` and ``enum_()`` are disabled, but the
-function signatures and enum members are included in the docstring, unless they
-are disabled separately.
-
 Note that changes to the settings affect only function bindings created during the
 lifetime of the ``options`` instance. When it goes out of scope at the end of the module's init function,
 the default settings are restored to prevent unwanted side effects.

thirdparty/pybind11/docs/advanced/pycpp/numpy.rst

@@ -87,7 +87,7 @@ buffer objects (e.g. a NumPy matrix).
             /* Request a buffer descriptor from Python */
             py::buffer_info info = b.request();
 
-            /* Some basic validation checks ... */
+            /* Some sanity checks ... */
             if (info.format != py::format_descriptor<Scalar>::format())
                 throw std::runtime_error("Incompatible format: expected a double array!");
 
@@ -395,9 +395,11 @@ uses of ``py::array``:
 Ellipsis
 ========
 
-Python provides a convenient ``...`` ellipsis notation that is often used to
+Python 3 provides a convenient ``...`` ellipsis notation that is often used to
 slice multidimensional arrays. For instance, the following snippet extracts the
 middle dimensions of a tensor with the first and last index set to zero.
+In Python 2, the syntactic sugar ``...`` is not available, but the singleton
+``Ellipsis`` (of type ``ellipsis``) can still be used directly.
 
 .. code-block:: python
 
@@ -412,6 +414,8 @@ operation on the C++ side:
    py::array a = /* A NumPy array */;
    py::array b = a[py::make_tuple(0, py::ellipsis(), 0)];
 
+.. versionchanged:: 2.6
+   ``py::ellipsis()`` is now also available in Python 2.
 
 Memory view
 ===========
@@ -433,7 +437,7 @@ following:
             { 2, 4 },                                  // shape (rows, cols)
             { sizeof(uint8_t) * 4, sizeof(uint8_t) }   // strides in bytes
         );
-    });
+    })
 
 This approach is meant for providing a ``memoryview`` for a C/C++ buffer not
 managed by Python. The user is responsible for managing the lifetime of the
@@ -449,7 +453,11 @@ We can also use ``memoryview::from_memory`` for a simple 1D contiguous buffer:
             buffer,               // buffer pointer
             sizeof(uint8_t) * 8   // buffer size
         );
-    });
+    })
+
+.. note::
+
+    ``memoryview::from_memory`` is not available in Python 2.
 
 .. versionchanged:: 2.6
     ``memoryview::from_memory`` added.

thirdparty/pybind11/docs/advanced/smart_ptrs.rst

@@ -157,7 +157,7 @@ specialized:
     PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr<T>);
 
     // Only needed if the type's `.get()` goes by another name
-    namespace PYBIND11_NAMESPACE { namespace detail {
+    namespace pybind11 { namespace detail {
         template <typename T>
         struct holder_helper<SmartPtr<T>> { // <-- specialization
             static const T *get(const SmartPtr<T> &p) { return p.getPointer(); }

thirdparty/pybind11/docs/basics.rst

@@ -32,7 +32,8 @@ The last line will both compile and run the tests.
 Windows
 -------
 
-On Windows, only **Visual Studio 2017** and newer are supported.
+On Windows, only **Visual Studio 2015** and newer are supported since pybind11 relies
+on various C++11 language features that break older versions of Visual Studio.
 
 .. Note::
 
@@ -165,12 +166,12 @@ load and execute the example:
 .. code-block:: pycon
 
     $ python
-    Python 3.9.10 (main, Jan 15 2022, 11:48:04)
-    [Clang 13.0.0 (clang-1300.0.29.3)] on darwin
+    Python 2.7.10 (default, Aug 22 2015, 20:33:39)
+    [GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.1)] on darwin
     Type "help", "copyright", "credits" or "license" for more information.
     >>> import example
     >>> example.add(1, 2)
-    3
+    3L
     >>>
 
 .. _keyword_args:

thirdparty/pybind11/docs/benchmark.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 import datetime as dt
 import os
 import random
@@ -11,20 +12,20 @@ def generate_dummy_code_pybind11(nclasses=10):
     bindings = ""
 
     for cl in range(nclasses):
-        decl += f"class cl{cl:03};\n"
+        decl += "class cl%03i;\n" % cl
     decl += "\n"
 
     for cl in range(nclasses):
-        decl += f"class {cl:03} {{\n"
+        decl += "class cl%03i {\n" % cl
         decl += "public:\n"
-        bindings += f'    py::class_<cl{cl:03}>(m, "cl{cl:03}")\n'
+        bindings += '    py::class_<cl%03i>(m, "cl%03i")\n' % (cl, cl)
         for fn in range(nfns):
             ret = random.randint(0, nclasses - 1)
             params = [random.randint(0, nclasses - 1) for i in range(nargs)]
-            decl += f"    cl{ret:03} *fn_{fn:03}("
-            decl += ", ".join(f"cl{p:03} *" for p in params)
+            decl += "    cl%03i *fn_%03i(" % (ret, fn)
+            decl += ", ".join("cl%03i *" % p for p in params)
             decl += ");\n"
-            bindings += f'        .def("fn_{fn:03}", &cl{cl:03}::fn_{fn:03})\n'
+            bindings += '        .def("fn_%03i", &cl%03i::fn_%03i)\n' % (fn, cl, fn)
         decl += "};\n\n"
         bindings += "        ;\n"
 
@@ -42,20 +43,23 @@ def generate_dummy_code_boost(nclasses=10):
     bindings = ""
 
     for cl in range(nclasses):
-        decl += f"class cl{cl:03};\n"
+        decl += "class cl%03i;\n" % cl
     decl += "\n"
 
     for cl in range(nclasses):
         decl += "class cl%03i {\n" % cl
         decl += "public:\n"
-        bindings += f'    py::class_<cl{cl:03}>("cl{cl:03}")\n'
+        bindings += '    py::class_<cl%03i>("cl%03i")\n' % (cl, cl)
         for fn in range(nfns):
             ret = random.randint(0, nclasses - 1)
             params = [random.randint(0, nclasses - 1) for i in range(nargs)]
-            decl += f"    cl{ret:03} *fn_{fn:03}("
-            decl += ", ".join(f"cl{p:03} *" for p in params)
+            decl += "    cl%03i *fn_%03i(" % (ret, fn)
+            decl += ", ".join("cl%03i *" % p for p in params)
             decl += ");\n"
-            bindings += f'        .def("fn_{fn:03}", &cl{cl:03}::fn_{fn:03}, py::return_value_policy<py::manage_new_object>())\n'
+            bindings += (
+                '        .def("fn_%03i", &cl%03i::fn_%03i, py::return_value_policy<py::manage_new_object>())\n'
+                % (fn, cl, fn)
+            )
         decl += "};\n\n"
         bindings += "        ;\n"
 
@@ -71,7 +75,7 @@ def generate_dummy_code_boost(nclasses=10):
 for codegen in [generate_dummy_code_pybind11, generate_dummy_code_boost]:
     print("{")
     for i in range(0, 10):
-        nclasses = 2**i
+        nclasses = 2 ** i
         with open("test.cpp", "w") as f:
             f.write(codegen(nclasses))
         n1 = dt.datetime.now()

thirdparty/pybind11/docs/changelog.rst

@@ -9,446 +9,49 @@ Starting with version 1.8.0, pybind11 releases use a `semantic versioning
 Changes will be added here periodically from the "Suggested changelog entry"
 block in pull request descriptions.
 
-
 IN DEVELOPMENT
 --------------
 
-Changes will be summarized here periodically.
-
-Changes:
-
-* ``PyGILState_Check()``'s in ``pybind11::handle``'s ``inc_ref()`` &
-  ``dec_ref()`` are now enabled by default again.
-  `#4246 <https://github.com/pybind/pybind11/pull/4246>`_
-
-* ``py::initialize_interpreter()`` using ``PyConfig_InitPythonConfig()``
-  instead of ``PyConfig_InitIsolatedConfig()``, to obtain complete
-  ``sys.path``.
-  `#4473 <https://github.com/pybind/pybind11/pull/4473>`_
-
-* Cast errors now always include Python type information, even if
-  ``PYBIND11_DETAILED_ERROR_MESSAGES`` is not defined. This increases binary
-  sizes slightly (~1.5%) but the error messages are much more informative.
-  `#4463 <https://github.com/pybind/pybind11/pull/4463>`_
-
-
-Build system improvements:
-
-* Update clang-tidy to 15 in CI.
-  `#4387 <https://github.com/pybind/pybind11/pull/4387>`_
-
-* Moved the linting framework over to Ruff.
-  `#4483 <https://github.com/pybind/pybind11/pull/4483>`_
-
-Version 2.10.4 (Mar 16, 2023)
-----------------------------
-
-Changes:
-
-* ``python3 -m pybind11`` gained a ``--version`` option (prints the version and
-  exits).
-  `#4526 <https://github.com/pybind/pybind11/pull/4526>`_
-
-Bug Fixes:
-
-* Fix a warning when pydebug is enabled on Python 3.11.
-  `#4461 <https://github.com/pybind/pybind11/pull/4461>`_
-
-* Ensure ``gil_scoped_release`` RAII is non-copyable.
-  `#4490 <https://github.com/pybind/pybind11/pull/4490>`_
-
-* Ensure the tests dir does not show up with new versions of setuptools.
-  `#4510 <https://github.com/pybind/pybind11/pull/4510>`_
-
-* Better stacklevel for a warning in setuptools helpers.
-  `#4516 <https://github.com/pybind/pybind11/pull/4516>`_
-
-Version 2.10.3 (Jan 3, 2023)
-----------------------------
-
-Changes:
-
-* Temporarily made our GIL status assertions (added in 2.10.2) disabled by
-  default (re-enable manually by defining
-  ``PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF``, will be enabled in 2.11).
-  `#4432 <https://github.com/pybind/pybind11/pull/4432>`_
-
-* Improved error messages when ``inc_ref``/``dec_ref`` are called with an
-  invalid GIL state.
-  `#4427 <https://github.com/pybind/pybind11/pull/4427>`_
-  `#4436 <https://github.com/pybind/pybind11/pull/4436>`_
-
-Bug Fixes:
-
-* Some minor touchups found by static analyzers.
-  `#4440 <https://github.com/pybind/pybind11/pull/4440>`_
-
-
-Version 2.10.2 (Dec 20, 2022)
------------------------------
-
-Changes:
-
-* ``scoped_interpreter`` constructor taking ``PyConfig``.
-  `#4330 <https://github.com/pybind/pybind11/pull/4330>`_
-
-* ``pybind11/eigen/tensor.h`` adds converters to and from ``Eigen::Tensor`` and
-  ``Eigen::TensorMap``.
-  `#4201 <https://github.com/pybind/pybind11/pull/4201>`_
-
-* ``PyGILState_Check()``'s  were integrated to ``pybind11::handle``
-  ``inc_ref()`` & ``dec_ref()``. The added GIL checks are guarded by
-  ``PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF``, which is the default only if
-  ``NDEBUG`` is not defined. (Made non-default in 2.10.3, will be active in 2.11)
-  `#4246 <https://github.com/pybind/pybind11/pull/4246>`_
-
-* Add option for enable/disable enum members in docstring.
-  `#2768 <https://github.com/pybind/pybind11/pull/2768>`_
-
-* Fixed typing of ``KeysView``, ``ValuesView`` and ``ItemsView`` in ``bind_map``.
-  `#4353 <https://github.com/pybind/pybind11/pull/4353>`_
-
-Bug fixes:
-
-* Bug fix affecting only Python 3.6 under very specific, uncommon conditions:
-  move ``PyEval_InitThreads()`` call to the correct location.
-  `#4350 <https://github.com/pybind/pybind11/pull/4350>`_
-
-* Fix segfault bug when passing foreign native functions to functional.h.
-  `#4254 <https://github.com/pybind/pybind11/pull/4254>`_
-
-Build system improvements:
-
-* Support setting PYTHON_LIBRARIES manually for Windows ARM cross-compilation
-  (classic mode).
-  `#4406 <https://github.com/pybind/pybind11/pull/4406>`_
-
-* Extend IPO/LTO detection for ICX (a.k.a IntelLLVM) compiler.
-  `#4402 <https://github.com/pybind/pybind11/pull/4402>`_
-
-* Allow calling ``find_package(pybind11 CONFIG)`` multiple times from separate
-  directories in the same CMake project and properly link Python (new mode).
-  `#4401 <https://github.com/pybind/pybind11/pull/4401>`_
-
-* ``multiprocessing_set_spawn`` in pytest fixture for added safety.
-  `#4377 <https://github.com/pybind/pybind11/pull/4377>`_
-
-* Fixed a bug in two pybind11/tools cmake scripts causing "Unknown arguments specified" errors.
-  `#4327 <https://github.com/pybind/pybind11/pull/4327>`_
-
-
-
-Version 2.10.1 (Oct 31, 2022)
------------------------------
-
-This is the first version to fully support embedding the newly released Python 3.11.
-
-Changes:
-
-* Allow ``pybind11::capsule`` constructor to take null destructor pointers.
-  `#4221 <https://github.com/pybind/pybind11/pull/4221>`_
-
-* ``embed.h`` was changed so that ``PYTHONPATH`` is used also with Python 3.11
-  (established behavior).
-  `#4119 <https://github.com/pybind/pybind11/pull/4119>`_
-
-* A ``PYBIND11_SIMPLE_GIL_MANAGEMENT`` option was added (cmake, C++ define),
-  along with many additional tests in ``test_gil_scoped.py``. The option may be
-  useful to try when debugging GIL-related issues, to determine if the more
-  complex default implementation is or is not to blame. See #4216 for
-  background. WARNING: Please be careful to not create ODR violations when
-  using the option: everything that is linked together with mutual symbol
-  visibility needs to be rebuilt.
-  `#4216 <https://github.com/pybind/pybind11/pull/4216>`_
-
-* ``PYBIND11_EXPORT_EXCEPTION`` was made non-empty only under macOS. This makes
-  Linux builds safer, and enables the removal of warning suppression pragmas for
-  Windows.
-  `#4298 <https://github.com/pybind/pybind11/pull/4298>`_
-
-Bug fixes:
-
-* Fixed a bug where ``UnicodeDecodeError`` was not propagated from various
-  ``py::str`` ctors when decoding surrogate utf characters.
-  `#4294 <https://github.com/pybind/pybind11/pull/4294>`_
-
-* Revert perfect forwarding for ``make_iterator``. This broke at least one
-  valid use case. May revisit later.
-  `#4234 <https://github.com/pybind/pybind11/pull/4234>`_
-
-* Fix support for safe casts to ``void*`` (regression in 2.10.0).
-  `#4275 <https://github.com/pybind/pybind11/pull/4275>`_
-
-* Fix ``char8_t`` support (regression in 2.9).
-  `#4278 <https://github.com/pybind/pybind11/pull/4278>`_
-
-* Unicode surrogate character in Python exception message leads to process
-  termination in ``error_already_set::what()``.
-  `#4297 <https://github.com/pybind/pybind11/pull/4297>`_
-
-* Fix MSVC 2019 v.1924 & C++14 mode error for ``overload_cast``.
-  `#4188 <https://github.com/pybind/pybind11/pull/4188>`_
-
-* Make augmented assignment operators non-const for the object-api. Behavior
-  was previously broken for augmented assignment operators.
-  `#4065 <https://github.com/pybind/pybind11/pull/4065>`_
-
-* Add proper error checking to C++ bindings for Python list append and insert.
-  `#4208 <https://github.com/pybind/pybind11/pull/4208>`_
-
-* Work-around for Nvidia's CUDA nvcc compiler in versions 11.4.0 - 11.8.0.
-  `#4220 <https://github.com/pybind/pybind11/pull/4220>`_
-
-* A workaround for PyPy was added in the ``py::error_already_set``
-  implementation, related to PR `#1895 <https://github.com/pybind/pybind11/pull/1895>`_
-  released with v2.10.0.
-  `#4079 <https://github.com/pybind/pybind11/pull/4079>`_
-
-* Fixed compiler errors when C++23 ``std::forward_like`` is available.
-  `#4136 <https://github.com/pybind/pybind11/pull/4136>`_
-
-* Properly raise exceptions in contains methods (like when an object in unhashable).
-  `#4209 <https://github.com/pybind/pybind11/pull/4209>`_
-
-* Further improve another error in exception handling.
-  `#4232 <https://github.com/pybind/pybind11/pull/4232>`_
-
-* ``get_local_internals()`` was made compatible with
-  ``finalize_interpreter()``, fixing potential freezes during interpreter
-  finalization.
-  `#4192 <https://github.com/pybind/pybind11/pull/4192>`_
-
-Performance and style:
-
-* Reserve space in set and STL map casters if possible. This will prevent
-  unnecessary rehashing / resizing by knowing the number of keys ahead of time
-  for Python to C++ casting. This improvement will greatly speed up the casting
-  of large unordered maps and sets.
-  `#4194 <https://github.com/pybind/pybind11/pull/4194>`_
-
-* GIL RAII scopes are non-copyable to avoid potential bugs.
-  `#4183 <https://github.com/pybind/pybind11/pull/4183>`_
-
-* Explicitly default all relevant ctors for pytypes in the ``PYBIND11_OBJECT``
-  macros and enforce the clang-tidy checks ``modernize-use-equals-default`` in
-  macros as well.
-  `#4017 <https://github.com/pybind/pybind11/pull/4017>`_
-
-* Optimize iterator advancement in C++ bindings.
-  `#4237 <https://github.com/pybind/pybind11/pull/4237>`_
-
-* Use the modern ``PyObject_GenericGetDict`` and ``PyObject_GenericSetDict``
-  for handling dynamic attribute dictionaries.
-  `#4106 <https://github.com/pybind/pybind11/pull/4106>`_
-
-* Document that users should use ``PYBIND11_NAMESPACE`` instead of using ``pybind11`` when
-  opening namespaces. Using namespace declarations and namespace qualification
-  remain the same as ``pybind11``. This is done to ensure consistent symbol
-  visibility.
-  `#4098 <https://github.com/pybind/pybind11/pull/4098>`_
-
-* Mark ``detail::forward_like`` as constexpr.
-  `#4147 <https://github.com/pybind/pybind11/pull/4147>`_
-
-* Optimize unpacking_collector when processing ``arg_v`` arguments.
-  `#4219 <https://github.com/pybind/pybind11/pull/4219>`_
-
-* Optimize casting C++ object to ``None``.
-  `#4269 <https://github.com/pybind/pybind11/pull/4269>`_
-
-
-Build system improvements:
-
-* CMake: revert overwrite behavior, now opt-in with ``PYBIND11_PYTHONLIBS_OVERRWRITE OFF``.
-  `#4195 <https://github.com/pybind/pybind11/pull/4195>`_
-
-* Include a pkg-config file when installing pybind11, such as in the Python
-  package.
-  `#4077 <https://github.com/pybind/pybind11/pull/4077>`_
-
-* Avoid stripping debug symbols when ``CMAKE_BUILD_TYPE`` is set to ``DEBUG``
-  instead of ``Debug``.
-  `#4078 <https://github.com/pybind/pybind11/pull/4078>`_
-
-* Followup to `#3948 <https://github.com/pybind/pybind11/pull/3948>`_, fixing vcpkg again.
-  `#4123 <https://github.com/pybind/pybind11/pull/4123>`_
-
-Version 2.10.0 (Jul 15, 2022)
------------------------------
-
 Removed support for Python 2.7, Python 3.5, and MSVC 2015. Support for MSVC
 2017 is limited due to availability of CI runners; we highly recommend MSVC
-2019 or 2022 be used. Initial support added for Python 3.11.
+2019 or 2022 be used.
 
 New features:
 
-* ``py::anyset`` & ``py::frozenset`` were added, with copying (cast) to
-  ``std::set`` (similar to ``set``).
-  `#3901 <https://github.com/pybind/pybind11/pull/3901>`_
-
-* Support bytearray casting to string.
-  `#3707 <https://github.com/pybind/pybind11/pull/3707>`_
-
 * ``type_caster<std::monostate>`` was added. ``std::monostate`` is a tag type
   that allows ``std::variant`` to act as an optional, or allows default
   construction of a ``std::variant`` holding a non-default constructible type.
   `#3818 <https://github.com/pybind/pybind11/pull/3818>`_
 
-* ``pybind11::capsule::set_name`` added to mutate the name of the capsule instance.
-  `#3866 <https://github.com/pybind/pybind11/pull/3866>`_
-
-* NumPy: dtype constructor from type number added, accessors corresponding to
-  Python API ``dtype.num``, ``dtype.byteorder``, ``dtype.flags`` and
-  ``dtype.alignment`` added.
-  `#3868 <https://github.com/pybind/pybind11/pull/3868>`_
-
+* Support bytearray casting to string.
+  `#3707 <https://github.com/pybind/pybind11/pull/3707>`_
 
 Changes:
 
-* Python 3.6 is now the minimum supported version.
+* Python 2 support was removed completely.
   `#3688 <https://github.com/pybind/pybind11/pull/3688>`_
-  `#3719 <https://github.com/pybind/pybind11/pull/3719>`_
 
 * The minimum version for MSVC is now 2017.
   `#3722 <https://github.com/pybind/pybind11/pull/3722>`_
 
-* Fix issues with CPython 3.11 betas and add to supported test matrix.
-  `#3923 <https://github.com/pybind/pybind11/pull/3923>`_
-
-* ``error_already_set`` is now safer and more performant, especially for
-  exceptions with long tracebacks, by delaying computation.
-  `#1895 <https://github.com/pybind/pybind11/pull/1895>`_
-
 * Improve exception handling in python ``str`` bindings.
   `#3826 <https://github.com/pybind/pybind11/pull/3826>`_
 
 * The bindings for capsules now have more consistent exception handling.
   `#3825 <https://github.com/pybind/pybind11/pull/3825>`_
 
-* ``PYBIND11_OBJECT_CVT`` and ``PYBIND11_OBJECT_CVT_DEFAULT`` macro can now be
-  used to define classes in namespaces other than pybind11.
-  `#3797 <https://github.com/pybind/pybind11/pull/3797>`_
-
-* Error printing code now uses ``PYBIND11_DETAILED_ERROR_MESSAGES`` instead of
-  requiring ``NDEBUG``, allowing use with release builds if desired.
-  `#3913 <https://github.com/pybind/pybind11/pull/3913>`_
-
-* Implicit conversion of the literal ``0`` to ``pybind11::handle`` is now disabled.
-  `#4008 <https://github.com/pybind/pybind11/pull/4008>`_
+* Fix exception handling when ``pybind11::weakref()`` fails.
+  `#3739 <https://github.com/pybind/pybind11/pull/3739>`_
 
 
 Bug fixes:
 
-* Fix exception handling when ``pybind11::weakref()`` fails.
-  `#3739 <https://github.com/pybind/pybind11/pull/3739>`_
-
-* ``module_::def_submodule`` was missing proper error handling. This is fixed now.
-  `#3973 <https://github.com/pybind/pybind11/pull/3973>`_
-
-* The behavior or ``error_already_set`` was made safer and the highly opaque
-  "Unknown internal error occurred" message was replaced with a more helpful
-  message.
-  `#3982 <https://github.com/pybind/pybind11/pull/3982>`_
-
-* ``error_already_set::what()`` now handles non-normalized exceptions correctly.
-  `#3971 <https://github.com/pybind/pybind11/pull/3971>`_
-
-* Support older C++ compilers where filesystem is not yet part of the standard
-  library and is instead included in ``std::experimental::filesystem``.
-  `#3840 <https://github.com/pybind/pybind11/pull/3840>`_
-
-* Fix ``-Wfree-nonheap-object`` warnings produced by GCC by avoiding returning
-  pointers to static objects with ``return_value_policy::take_ownership``.
-  `#3946 <https://github.com/pybind/pybind11/pull/3946>`_
-
-* Fix cast from pytype rvalue to another pytype.
-  `#3949 <https://github.com/pybind/pybind11/pull/3949>`_
-
-* Ensure proper behavior when garbage collecting classes with dynamic attributes in Python >=3.9.
-  `#4051 <https://github.com/pybind/pybind11/pull/4051>`_
-
-* A couple long-standing ``PYBIND11_NAMESPACE``
-  ``__attribute__((visibility("hidden")))`` inconsistencies are now fixed
-  (affects only unusual environments).
-  `#4043 <https://github.com/pybind/pybind11/pull/4043>`_
-
-* ``pybind11::detail::get_internals()`` is now resilient to in-flight Python
-  exceptions.
-  `#3981 <https://github.com/pybind/pybind11/pull/3981>`_
-
-* Arrays with a dimension of size 0 are now properly converted to dynamic Eigen
-  matrices (more common in NumPy 1.23).
-  `#4038 <https://github.com/pybind/pybind11/pull/4038>`_
-
-* Avoid catching unrelated errors when importing NumPy.
-  `#3974 <https://github.com/pybind/pybind11/pull/3974>`_
-
-Performance and style:
-
-* Added an accessor overload of ``(object &&key)`` to reference steal the
-  object when using python types as keys. This prevents unnecessary reference
-  count overhead for attr, dictionary, tuple, and sequence look ups. Added
-  additional regression tests. Fixed a performance bug the caused accessor
-  assignments to potentially perform unnecessary copies.
-  `#3970 <https://github.com/pybind/pybind11/pull/3970>`_
-
-* Perfect forward all args of ``make_iterator``.
-  `#3980 <https://github.com/pybind/pybind11/pull/3980>`_
-
-* Avoid potential bug in pycapsule destructor by adding an ``error_guard`` to
-  one of the dtors.
-  `#3958 <https://github.com/pybind/pybind11/pull/3958>`_
-
-* Optimize dictionary access in ``strip_padding`` for numpy.
-  `#3994 <https://github.com/pybind/pybind11/pull/3994>`_
-
-* ``stl_bind.h`` bindings now take slice args as a const-ref.
-  `#3852 <https://github.com/pybind/pybind11/pull/3852>`_
-
-* Made slice constructor more consistent, and improve performance of some
-  casters by allowing reference stealing.
-  `#3845 <https://github.com/pybind/pybind11/pull/3845>`_
-
-* Change numpy dtype from_args method to use const ref.
-  `#3878 <https://github.com/pybind/pybind11/pull/3878>`_
-
-* Follow rule of three to ensure ``PyErr_Restore`` is called only once.
-  `#3872 <https://github.com/pybind/pybind11/pull/3872>`_
-
-* Added missing perfect forwarding for ``make_iterator`` functions.
-  `#3860 <https://github.com/pybind/pybind11/pull/3860>`_
-
-* Optimize c++ to python function casting by using the rvalue caster.
-  `#3966 <https://github.com/pybind/pybind11/pull/3966>`_
-
-* Optimize Eigen sparse matrix casting by removing unnecessary temporary.
-  `#4064 <https://github.com/pybind/pybind11/pull/4064>`_
-
-* Avoid potential implicit copy/assignment constructors causing double free in
-  ``strdup_gaurd``.
-  `#3905 <https://github.com/pybind/pybind11/pull/3905>`_
-
-* Enable clang-tidy checks ``misc-definitions-in-headers``,
-  ``modernize-loop-convert``, and ``modernize-use-nullptr``.
-  `#3881 <https://github.com/pybind/pybind11/pull/3881>`_
-  `#3988 <https://github.com/pybind/pybind11/pull/3988>`_
-
+* ``PYBIND11_OBJECT_CVT`` and ``PYBIND11_OBJECT_CVT_DEFAULT`` macro can be used
+  to define classes in namespaces other than pybind11.
+  `#3797 <https://github.com/pybind/pybind11/pull/3797>`_
 
 Build system improvements:
 
-* CMake: Fix file extension on Windows with cp36 and cp37 using FindPython.
-  `#3919 <https://github.com/pybind/pybind11/pull/3919>`_
-
-* CMake: Support multiple Python targets (such as on vcpkg).
-  `#3948 <https://github.com/pybind/pybind11/pull/3948>`_
-
-* CMake: Fix issue with NVCC on Windows.
-  `#3947 <https://github.com/pybind/pybind11/pull/3947>`_
-
-* CMake: Drop the bitness check on cross compiles (like targeting WebAssembly
-  via Emscripten).
-  `#3959 <https://github.com/pybind/pybind11/pull/3959>`_
-
 * Add MSVC builds in debug mode to CI.
   `#3784 <https://github.com/pybind/pybind11/pull/3784>`_
 
@@ -456,23 +59,15 @@ Build system improvements:
   `#3732 <https://github.com/pybind/pybind11/pull/3732>`_,
   `#3741 <https://github.com/pybind/pybind11/pull/3741>`_
 
+* Avoid ``setup.py <command>`` usage in internal tests.
+  `#3734 <https://github.com/pybind/pybind11/pull/3734>`_
+
 
 Backend and tidying up:
 
-* New theme for the documentation.
-  `#3109 <https://github.com/pybind/pybind11/pull/3109>`_
-
-* Remove idioms in code comments.  Use more inclusive language.
+* Remove idioms in code comments.  Use inclusive language.
   `#3809 <https://github.com/pybind/pybind11/pull/3809>`_
 
-* ``#include <iostream>`` was removed from the ``pybind11/stl.h`` header. Your
-  project may break if it has a transitive dependency on this include. The fix
-  is to "Include What You Use".
-  `#3928 <https://github.com/pybind/pybind11/pull/3928>`_
-
-* Avoid ``setup.py <command>`` usage in internal tests.
-  `#3734 <https://github.com/pybind/pybind11/pull/3734>`_
-
 
 Version 2.9.2 (Mar 29, 2022)
 ----------------------------
@@ -1324,7 +919,7 @@ Packaging / building improvements:
   `#2338 <https://github.com/pybind/pybind11/pull/2338>`_ and
   `#2370 <https://github.com/pybind/pybind11/pull/2370>`_
 
-  * Full integration with CMake's C++ standard system and compile features
+  * Full integration with CMake’s C++ standard system and compile features
     replaces ``PYBIND11_CPP_STANDARD``.
 
   * Generated config file is now portable to different Python/compiler/CMake