Starting with version 1.8.0, pybind11 releases use a semantic versioning policy.
See upgrade-guide-2.6
for help upgrading to the new version.
New features:
- Keyword-only arguments supported in Python 2 or 3 with
py::kw_only()
. #2100 - Positional-only arguments supported in Python 2 or 3 with
py::pos_only()
. #2459 py::is_final()
class modifier to block subclassing (CPython only). #2151- Added
py::prepend()
, allowing a function to be placed at the beginning of the overload chain. #1131 - Access to the type object now provided with
py::type::of<T>()
andpy::type::of(h)
. #2364 - Perfect forwarding support for methods. #2048
- Added
py::error_already_set::discard_as_unraisable()
. #2372 py::hash
is now public. #2217py::class_<union_type>
is now supported. Note that writing to one data member of the union and reading another (type punning) is UB in C++. Thus pybind11-bound enums should never be used for such conversions. #2320.- Classes now check local scope when registering members, allowing a subclass to have a member with the same name as a parent (such as an enum). #2335
Code correctness features:
- Error now thrown when
__init__
is forgotten on subclasses. #2152 - Throw error if conversion to a pybind11 type if the Python object isn't a valid instance of that type, such as
py::bytes(o)
whenpy::object o
isn't a bytes instance. #2349 - Throw if conversion to
str
fails. #2477
API changes:
py::module
was renamedpy::module_
to avoid issues with C++20 when used unqualified, but an aliaspy::module
is provided for backward compatibility. #2489- Public constructors for
py::module_
have been deprecated; please usepybind11::module_::create_extension_module
if you were using the public constructor (fairly rare afterPYBIND11_MODULE
was introduced). Provisional in 2.6.0rc1. #2552 PYBIND11_OVERLOAD*
macros andget_overload
function replaced by correctly-namedPYBIND11_OVERRIDE*
andget_override
, fixing inconsistencies in the presence of a closing;
in these macros.get_type_overload
is deprecated. #2325
Packaging / building improvements:
- The Python package was reworked to be more powerful and useful. #2433
build-setuptools
is easier thanks to a newpybind11.setup_helpers
module, which provides utilities to use setuptools with pybind11. It can be used via PEP 518,setup_requires
, or by directly importing or copyingsetup_helpers.py
into your project.- CMake configuration files are now included in the Python package. Use
pybind11.get_cmake_dir()
orpython -m pybind11 --cmakedir
to get the directory with the CMake configuration files, or include the site-packages location in yourCMAKE_MODULE_PATH
. Or you can use the newpybind11[global]
extra when you installpybind11
, which installs the CMake files and headers into your base environment in the standard location. pybind11-config
is another way to writepython -m pybind11
if you have your PATH set up.
- Minimum CMake required increased to 3.4. #2338 and #2370
- 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 versions.
- Virtual environments prioritized if
PYTHON_EXECUTABLE
is not set (venv
,virtualenv
, andconda
) (similar to the new FindPython mode). - Other CMake features now natively supported, like
CMAKE_INTERPROCEDURAL_OPTIMIZATION
,set(CMAKE_CXX_VISIBILITY_PRESET hidden)
. CUDA
as a language is now supported.- Helper functions
pybind11_strip
,pybind11_extension
,pybind11_find_import
added, seecmake/index
. - Optional
find-python-mode
andnopython-mode
with CMake. #2370
- Full integration with CMake’s C++ standard system and compile features replaces
- Uninstall target added. #2265 and #2346
pybind11_add_module()
now accepts an optionalOPT_SIZE
flag that switches the binding target to size-based optimization if the global build type can not always be fixed toMinSizeRel
(except in debug mode, where optimizations remain disabled).MinSizeRel
or this flag reduces binary size quite substantially (~25% on some platforms). #2463
Smaller or developer focused features:
- Moved
mkdoc.py
to a new repo, pybind11-mkdoc. There are no longer submodules in the main repo. py::memoryview
segfault fix and update, with newpy::memoryview::from_memory
in Python 3, and documentation. #2223- Fix for
buffer_info
on Python 2. #2503 - If
__eq__
defined but not__hash__
,__hash__
is now set toNone
. #2291 py::ellipsis
now also works on Python 2. #2360- Pointer to
std::tuple
&std::pair
supported in cast. #2334 - Small fixes in NumPy support.
py::array
now usespy::ssize_t
as first argument type. #2293 - Added missing signature for
py::array
. #2363 unchecked_mutable_reference
has access to operator()
and[]
when const. #2514py::vectorize
is now supported on functions that return void. #1969py::capsule
supportsget_pointer
andset_pointer
. #1131- Fix crash when different instances share the same pointer of the same type. #2252
- Bugfixes related to more extensive testing, new GitHub Actions CI. #2321
- Bug in timezone issue in Eastern hemisphere midnight fixed. #2438
std::chrono::time_point
now works when the resolution is not the same as the system. #2481- Bug fixed where
py::array_t
could accept arrays that did not match the requested ordering. #2484 - PyPy fixes, PyPy 7.3.x now supported, including PyPy3. #2146
- CPython 3.9 fixes. #2253
- More C++20 support. #2489
- Debug Python interpreter support. #2025
- NVCC (CUDA 11) now supported and tested in CI. #2461
- NVIDIA PGI compilers now supported and tested in CI. #2475
- Intel 18 now explicitly required.
- Extensive style checking in CI, with pre-commit support. Code modernization, checked by clang-tidy.
- Expanded docs, including new main page, new installing section, and CMake helpers page, along with over a dozen new sections on existing pages.
- In GitHub, new docs for contributing and new issue templates.
- Use C++17 fold expressions in type casters, if available. This can improve performance during overload resolution when functions have multiple arguments. #2043.
- Changed include directory resolution in
pybind11/__init__.py
and installation insetup.py
. This fixes a number of open issues where pybind11 headers could not be found in certain environments. #1995. - C++20
char8_t
andu8string
support. #2026. - CMake: search for Python 3.9. bb9c91.
- Fixes for MSYS-based build environments. #2087, #2053.
- STL bindings for
std::vector<...>::clear
. #2074. - Read-only flag for
py::buffer
. #1466. - Exception handling during module initialization. bf2b031.
- Support linking against a CPython debug build. #2025.
- Fixed issues involving the availability and use of aligned
new
anddelete
. #1988, 759221. - Fixed a resource leak upon interpreter shutdown. #2020.
- Fixed error handling in the boolean caster. #1976.
- Adapt pybind11 to a C API convention change in Python 3.8. #1950.
- Replaced usage of a C++14 only construct. #1929.
- Made an ifdef future-proof for Python >= 4. f3109d.
- Fixed a problem involving implicit conversion from enumerations to integers on Python 3.8. #1780.
- Try harder to keep pybind11-internal data structures separate when there are potential ABI incompatibilities. Fixes crashes that occurred when loading multiple pybind11 extensions that were e.g. compiled by GCC (libstdc++) and Clang (libc++). #1588 and c9f5a.
- Added support for
__await__
,__aiter__
, and__anext__
protocols. #1842. pybind11_add_module()
: don't strip symbols when compiling inRelWithDebInfo
mode. #1980.enum_
: Reproduce Python behavior when comparing against invalid values (e.g.None
, strings, etc.). Add back support for__invert__()
. #1912, #1907.- List insertion operation for
py::list
. Added.empty()
to all collection types. Addedpy::set::contains()
andpy::dict::contains()
. #1887, #1884, #1888. py::details::overload_cast_impl
is available in C++11 mode, can be used likeoverload_cast
with an additional set of parantheses. #1581.- Fixed
get_include()
on Conda. #1877. stl_bind.h
: negative indexing support. #1882.- Minor CMake fix to add MinGW compatibility. #1851.
- GIL-related fixes. #1836, 8b90b.
- Other very minor/subtle fixes and improvements. #1329, #1910, #1863, #1847, #1890, #1860, #1848, #1821, #1837, #1833, #1748, #1852.
- Significantly reduced module binary size (10-20%) when compiled in C++11 mode with GCC/Clang, or in any mode with MSVC. Function signatures are now always precomputed at compile time (this was previously only available in C++14 mode for non-MSVC compilers). #934.
- Add basic support for tag-based static polymorphism, where classes provide a method to returns the desired type of an instance. #1326.
- Python type wrappers (
py::handle
,py::object
, etc.) now support map Python's number protocol onto C++ arithmetic operators such asoperator+
,operator/=
, etc. #1511. A number of improvements related to enumerations:
- The
enum_
implementation was rewritten from scratch to reduce code bloat. Rather than instantiating a full implementation for each enumeration, most code is now contained in a generic base class. #1511. - The
value()
method ofpy::enum_
now accepts an optional docstring that will be shown in the documentation of the associated enumeration. #1160. - check for already existing enum value and throw an error if present. #1453.
- The
- Support for over-aligned type allocation via C++17's aligned
new
statement. #1582. - Added
py::ellipsis()
method for slicing of multidimensional NumPy arrays #1502. - Numerous Improvements to the
mkdoc.py
script for extracting documentation from C++ header files. #1788. pybind11_add_module()
: allow including Python as aSYSTEM
include path. #1416.pybind11/stl.h
does not convert strings tovector<string>
anymore. #1258.- Mark static methods as such to fix auto-generated Sphinx documentation. #1732.
- Re-throw forced unwind exceptions (e.g. during pthread termination). #1208.
- Added
__contains__
method to the bindings of maps (std::map
,std::unordered_map
). #1767. - Improvements to
gil_scoped_acquire
. #1211. - Type caster support for
std::deque<T>
. #1609. - Support for
std::unique_ptr
holders, whose deleters differ between a base and derived class. #1353. - Construction of STL array/vector-like data structures from iterators. Added an
extend()
operation. #1709, - CMake build system improvements for projects that include non-C++ files (e.g. plain C, CUDA) in
pybind11_add_module
et al. #1678. - Fixed asynchronous invocation and deallocation of Python functions wrapped in
std::function
. #1595. - Fixes regarding return value policy propagation in STL type casters. #1603.
- Fixed scoped enum comparisons. #1571.
- Fixed iostream redirection for code that releases the GIL. #1368,
- A number of CI-related fixes. #1757, #1744, #1670.
- Use new Python 3.7 Thread Specific Storage (TSS) implementation if available. #1454, #1517.
- Fixes for newer MSVC versions and C++17 mode. #1347, #1462.
- Propagate return value policies to type-specific casters when casting STL containers. #1455.
- Allow ostream-redirection of more than 1024 characters. #1479.
- Set
Py_DEBUG
define when compiling against a debug Python build. #1438. - Untangle integer logic in number type caster to work for custom types that may only be castable to a restricted set of builtin types. #1442.
- CMake build system: Remember Python version in cache file. #1434.
- Fix for custom smart pointers: use
std::addressof
to obtain holder address instead ofoperator&
. #1435. - Properly report exceptions thrown during module initialization. #1362.
- Fixed a segmentation fault when creating empty-shaped NumPy array. #1371.
- The version of Intel C++ compiler must be >= 2017, and this is now checked by the header files. #1363.
- A few minor typo fixes and improvements to the test suite, and patches that silence compiler warnings.
- Vectors now support construction from generators, as well as
extend()
from a list or generator. #1496.
- The pybind11 header location detection was replaced by a new implementation that no longer depends on
pip
internals (the recently releasedpip
10 has restricted access to this API). #1190. - Small adjustment to an implementation detail to work around a compiler segmentation fault in Clang 3.3/3.4. #1350.
- The minimal supported version of the Intel compiler was >= 17.0 since pybind11 v2.1. This check is now explicit, and a compile-time error is raised if the compiler meet the requirement. #1363.
- Fixed an endianness-related fault in the test suite. #1287.
- Fixed a segfault when combining embedded interpreter shutdown/reinitialization with external loaded pybind11 modules. #1092.
- Eigen support: fixed a bug where Nx1/1xN numpy inputs couldn't be passed as arguments to Eigen vectors (which for Eigen are simply compile-time fixed Nx1/1xN matrices). #1106.
- Clarified to license by moving the licensing of contributions from
LICENSE
intoCONTRIBUTING.md
: the licensing of contributions is not actually part of the software license as distributed. This isn't meant to be a substantial change in the licensing of the project, but addresses concerns that the clause made the license non-standard. #1109. - Fixed a regression introduced in 2.1 that broke binding functions with lvalue character literal arguments. #1128.
- MSVC: fix for compilation failures under /permissive-, and added the flag to the appveyor test suite. #1155.
- Fixed
__qualname__
generation, and in turn, fixes how class names (especially nested class names) are shown in generated docstrings. #1171. - Updated the FAQ with a suggested project citation reference. #1189.
- Added fixes for deprecation warnings when compiled under C++17 with
-Wdeprecated
turned on, and add-Wdeprecated
to the test suite compilation flags. #1191. - Fixed outdated PyPI URLs in
setup.py
. #1213. - Fixed a refcount leak for arguments that end up in a
py::args
argument for functions with both fixed positional andpy::args
arguments. #1216. - Fixed a potential segfault resulting from possible premature destruction of
py::args
/py::kwargs
arguments with overloaded functions. #1223. - Fixed
del map[item]
for astl_bind.h
bound stl map. #1229. - Fixed a regression from v2.1.x where the aggregate initialization could unintentionally end up at a constructor taking a templated
std::initializer_list<T>
argument. #1249. - Fixed an issue where calling a function with a keep_alive policy on the same nurse/patient pair would cause the internal patient storage to needlessly grow (unboundedly, if the nurse is long-lived). #1251.
- Various other minor fixes.
- Added
py::module_::reload()
member function for reloading a module. #1040. - Fixed a reference leak in the number converter. #1078.
- Fixed compilation with Clang on host GCC < 5 (old libstdc++ which isn't fully C++11 compliant). #1062.
- Fixed a regression where the automatic
std::vector<bool>
caster would fail to compile. The same fix also applies to any container which returns element proxies instead of references. #1053. - Fixed a regression where the
py::keep_alive
policy could not be applied to constructors. #1065. - Fixed a nullptr dereference when loading a
py::module_local
type that's only registered in an external module. #1058. - Fixed implicit conversion of accessors to types derived from
py::object
. #1076. - The
name
inPYBIND11_MODULE(name, variable)
can now be a macro. #1082. - Relaxed overly strict
py::pickle()
check for matching get and set types. #1064. - Conversion errors now try to be more informative when it's likely that a missing header is the cause (e.g. forgetting
<pybind11/stl.h>
). #1077.
Support for embedding the Python interpreter. See the
documentation page </advanced/embedding>
for a full overview of the new features. #774, #889, #892, #920.#include <pybind11/embed.h> namespace py = pybind11; int main() { py::scoped_interpreter guard{}; // start the interpreter and keep it alive py::print("Hello, World!"); // use the Python API }
Support for inheriting from multiple C++ bases in Python. #693.
from cpp_module import CppBase1, CppBase2 class PyDerived(CppBase1, CppBase2): def __init__(self): CppBase1.__init__(self) # C++ bases must be initialized explicitly CppBase2.__init__(self)
PYBIND11_MODULE
is now the preferred way to create module entry points.PYBIND11_PLUGIN
is deprecated. Seemacros
for details. #879.// new PYBIND11_MODULE(example, m) { m.def("add", [](int a, int b) { return a + b; }); } // old PYBIND11_PLUGIN(example) { py::module m("example"); m.def("add", [](int a, int b) { return a + b; }); return m.ptr(); }
- pybind11's headers and build system now more strictly enforce hidden symbol visibility for extension modules. This should be seamless for most users, but see the
upgrade
if you use a custom build system. #995. - Support for
py::module_local
types which allow multiple modules to export the same C++ types without conflicts. This is useful for opaque types likestd::vector<int>
.py::bind_vector
andpy::bind_map
now default topy::module_local
if their elements are builtins or local types. Seemodule_local
for details. #949, #981, #995, #997. Custom constructors can now be added very easily using lambdas or factory functions which return a class instance by value, pointer or holder. This supersedes the old placement-new
__init__
technique. Seecustom_constructors
for details. #805, #1014.struct Example { Example(std::string); }; py::class_<Example>(m, "Example") .def(py::init<std::string>()) // existing constructor .def(py::init([](int n) { // custom constructor return std::make_unique<Example>(std::to_string(n)); }));
- Similarly to custom constructors, pickling support functions are now bound using the
py::pickle()
adaptor which improves type safety. See theupgrade
andpickling
for details. #1038. - Builtin support for converting C++17 standard library types and general conversion improvements:
- C++17
std::variant
is supported right out of the box. C++11/14 equivalents (e.g.boost::variant
) can also be added with a simple user-defined specialization. Seecpp17_container_casters
for details. #811, #845, #989. - Out-of-the-box support for C++17
std::string_view
. #906. - Improved compatibility of the builtin
optional
converter. #874. - The
bool
converter now acceptsnumpy.bool_
and types which define__bool__
(Python 3.x) or__nonzero__
(Python 2.7). #925. - C++-to-Python casters are now more efficient and move elements out of rvalue containers whenever possible. #851, #936, #938.
- Fixed
bytes
tostd::string/char*
conversion on Python 3. #817. - Fixed lifetime of temporary C++ objects created in Python-to-C++ conversions. #924.
- C++17
- Scope guard call policy for RAII types, e.g.
py::call_guard<py::gil_scoped_release>()
,py::call_guard<py::scoped_ostream_redirect>()
. Seecall_policies
for details. #740. - Utility for redirecting C++ streams to Python (e.g.
std::cout
->sys.stdout
). Scope guardpy::scoped_ostream_redirect
in C++ and a context manager in Python. Seeostream_redirect
. #1009. - Improved handling of types and exceptions across module boundaries. #915, #951, #995.
- Fixed destruction order of
py::keep_alive
nurse/patient objects in reference cycles. #856. - NumPy and buffer protocol related improvements:
- Support for negative strides in Python buffer objects/numpy arrays. This required changing integers from unsigned to signed for the related C++ APIs. Note: If you have compiler warnings enabled, you may notice some new conversion warnings after upgrading. These can be resolved with
static_cast
. #782. - Support
std::complex
and arrays insidePYBIND11_NUMPY_DTYPE
. #831, #832. - Support for constructing
py::buffer_info
andpy::arrays
using arbitrary containers or iterators instead of requiring astd::vector
. #788, #822, #860. - Explicitly check numpy version and require >= 1.7.0. #819.
- Support for negative strides in Python buffer objects/numpy arrays. This required changing integers from unsigned to signed for the related C++ APIs. Note: If you have compiler warnings enabled, you may notice some new conversion warnings after upgrading. These can be resolved with
- Support for allowing/prohibiting
None
for specific arguments and improvedNone
overload resolution order. Seenone_arguments
for details. #843. #859. - Added
py::exec()
as a shortcut forpy::eval<py::eval_statements>()
and support for C++11 raw string literals as input. Seeeval
. #766, #827. py::vectorize()
ignores non-vectorizable arguments and supports member functions. #762.- Support for bound methods as callbacks (
pybind11/functional.h
). #815. - Allow aliasing pybind11 methods:
cls.attr("foo") = cls.attr("bar")
. #802. - Don't allow mixed static/non-static overloads. #804.
- Fixed overriding static properties in derived classes. #784.
- Added support for write only properties. #1144.
Improved deduction of member functions of a derived class when its bases aren't registered with pybind11. #855.
struct Base { int foo() { return 42; } } struct Derived : Base {} // Now works, but previously required also binding `Base` py::class_<Derived>(m, "Derived") .def("foo", &Derived::foo); // function is actually from `Base`
The implementation of
py::init<>
now uses C++11 brace initialization syntax to construct instances, which permits binding implicit constructors of aggregate types. #1015.struct Aggregate { int a; std::string b; }; py::class_<Aggregate>(m, "Aggregate") .def(py::init<int, const std::string &>());
- Fixed issues with multiple inheritance with offset base/derived pointers. #812, #866, #960.
- Fixed reference leak of type objects. #1030.
- Improved support for the
/std:c++14
and/std:c++latest
modes on MSVC 2017. #841, #999. - Fixed detection of private operator new on MSVC. #893, #918.
- Intel C++ compiler compatibility fixes. #937.
- Fixed implicit conversion of py::enum_ to integer types on Python 2.7. #821.
- Added
py::hash
to fetch the hash value of Python objects, and.def(hash(py::self))
to provide the C++std::hash
as the Python__hash__
method. #1034. - Fixed
__truediv__
on Python 2 and__itruediv__
on Python 3. #867. py::capsule
objects now support thename
attribute. This is useful for interfacing withscipy.LowLevelCallable
. #902.- Fixed
py::make_iterator
's__next__()
for past-the-end calls. #897. - Added
error_already_set::matches()
for checking Python exceptions. #772. - Deprecated
py::error_already_set::clear()
. It's no longer needed following a simplification of thepy::error_already_set
class. #954. - Deprecated
py::handle::operator==()
in favor ofpy::handle::is()
#825. - Deprecated
py::object::borrowed
/py::object::stolen
. Usepy::object::borrowed_t{}
/py::object::stolen_t{}
instead. #771. - Changed internal data structure versioning to avoid conflicts between modules compiled with different revisions of pybind11. #1012.
- Additional compile-time and run-time error checking and more informative messages. #786, #794, #803.
- Various minor improvements and fixes. #764, #791, #795, #840, #844, #846, #849, #858, #862, #871, #872, #881, #888, #899, #928, #931, #944, #950, #952, #962, #965, #970, #978, #979, #986, #1020, #1027, #1037.
- Testing improvements. #798, #882, #898, #900, #921, #923, #963.
- Fixed minimum version requirement for MSVC 2015u3 #773.
- pybind11 now performs function overload resolution in two phases. The first phase only considers exact type matches, while the second allows for implicit conversions to take place. A special
noconvert()
syntax can be used to completely disable implicit conversions for specific arguments. #643, #634, #650. - Fixed a regression where static properties no longer worked with classes using multiple inheritance. The
py::metaclass
attribute is no longer necessary (and deprecated as of this release) when binding classes with static properties. #679, - Classes bound using
pybind11
can now use custom metaclasses. #679, py::args
andpy::kwargs
can now be mixed with other positional arguments when binding functions using pybind11. #611.- Improved support for C++11 unicode string and character types; added extensive documentation regarding pybind11's string conversion behavior. #624, #636, #715.
- pybind11 can now avoid expensive copies when converting Eigen arrays to NumPy arrays (and vice versa). #610.
- The "fast path" in
py::vectorize
now works for any full-size group of C or F-contiguous arrays. The non-fast path is also faster since it no longer performs copies of the input arguments (except when type conversions are necessary). #610. - Added fast, unchecked access to NumPy arrays via a proxy object. #746.
- Transparent support for class-specific
operator new
andoperator delete
implementations. #755. - Slimmer and more efficient STL-compatible iterator interface for sequence types. #662.
- Improved custom holder type support. #607.
nullptr
toNone
conversion fixed in various builtin type casters. #732.enum_
now exposes its members via a special__members__
attribute. #666.std::vector
bindings created usingstl_bind.h
can now optionally implement the buffer protocol. #488.- Automated C++ reference documentation using doxygen and breathe. #598.
- Added minimum compiler version assertions. #727.
- Improved compatibility with C++1z. #677.
- Improved
py::capsule
API. Can be used to implement cleanup callbacks that are involved at module destruction time. #752. - Various minor improvements and fixes. #595, #588, #589, #603, #619, #648, #695, #720, #723, #729, #724, #742, #753.
- Fix pointer to reference error in type_caster on MSVC #583.
- Fixed a segmentation in the test suite due to a typo cd7eac.
- Fixed a reference counting regression affecting types with custom metaclasses (introduced in v2.0.0-rc1). #571.
- Quenched a CMake policy warning. #570.
The pybind11 developers are excited to issue a release candidate of pybind11 with a subsequent v2.0.0 release planned in early January next year.
An incredible amount of effort by went into pybind11 over the last ~5 months, leading to a release that is jam-packed with exciting new features and numerous usability improvements. The following list links PRs or individual commits whenever applicable.
Happy Christmas!
- Support for binding C++ class hierarchies that make use of multiple inheritance. #410.
- PyPy support: pybind11 now supports nightly builds of PyPy and will interoperate with the future 5.7 release. No code changes are necessary, everything "just" works as usual. Note that we only target the Python 2.7 branch for now; support for 3.x will be added once its
cpyext
extension support catches up. A few minor features remain unsupported for the time being (notably dynamic attributes in custom types). #527. - Significant work on the documentation -- in particular, the monolithic
advanced.rst
file was restructured into a easier to read hierarchical organization. #448. - Many NumPy-related improvements:
- Object-oriented API to access and modify NumPy
ndarray
instances, replicating much of the corresponding NumPy C API functionality. #402. - NumPy array
dtype
array descriptors are now first-class citizens and are exposed via a new classpy::dtype
. Structured dtypes can be registered using the
PYBIND11_NUMPY_DTYPE()
macro. Specialarray
constructors accepting dtype objects were also added.One potential caveat involving this change: format descriptor strings should now be accessed via
format_descriptor::format()
(however, for compatibility purposes, the old syntaxformat_descriptor::value
will still work for non-structured data types). #308.- Further improvements to support structured dtypes throughout the system. #472, #474, #459, #453, #452, and #505.
- Fast access operators. #497.
- Constructors for arrays whose storage is owned by another object. #440.
- Added constructors for
array
andarray_t
explicitly accepting shape and strides; if strides are not provided, they are deduced assuming C-contiguity. Also added simplified constructors for 1-dimensional case. - Added buffer/NumPy support for
char[N]
andstd::array<char, N>
types. - Added
memoryview
wrapper type which is constructible frombuffer_info
.
- Object-oriented API to access and modify NumPy
- Eigen: many additional conversions and support for non-contiguous arrays/slices. #427, #315, #316, #312, and #267
Incompatible changes in
class_<...>::class_()
:- Declarations of types that provide access via the buffer protocol must now include the
py::buffer_protocol()
annotation as an argument to theclass_
constructor. Declarations of types that require a custom metaclass (i.e. all classes which include static properties via commands such as
def_readwrite_static()
) must now include thepy::metaclass()
annotation as an argument to theclass_
constructor.These two changes were necessary to make type definitions in pybind11 future-proof, and to support PyPy via its cpyext mechanism. #527.
This version of pybind11 uses a redesigned mechanism for instantiating trampoline classes that are used to override virtual methods from within Python. This led to the following user-visible syntax change: instead of
py::class_<TrampolineClass>("MyClass") .alias<MyClass>() ....
write
py::class_<MyClass, TrampolineClass>("MyClass") ....
Importantly, both the original and the trampoline class are now specified as an arguments (in arbitrary order) to the
py::class_
template, and thealias<..>()
call is gone. The new scheme has zero overhead in cases when Python doesn't override any functions of the underlying C++ class. rev. 86d825.
- Declarations of types that provide access via the buffer protocol must now include the
- Added
eval
andeval_file
functions for evaluating expressions and statements from a string or file. rev. 0d3fc3. - pybind11 can now create types with a modifiable dictionary. #437 and #444.
- Support for translation of arbitrary C++ exceptions to Python counterparts. #296 and #273.
- Report full backtraces through mixed C++/Python code, better reporting for import errors, fixed GIL management in exception processing. #537, #494, rev. e72d95, and rev. 099d6e.
- Support for bit-level operations, comparisons, and serialization of C++ enumerations. #503, #508, #380, #309. #311.
- The
class_
constructor now accepts its template arguments in any order. #385. - Attribute and item accessors now have a more complete interface which makes it possible to chain attributes as in
obj.attr("a")[key].attr("b").attr("method")(1, 2, 3)
. #425. - Major redesign of the default and conversion constructors in
pytypes.h
. #464. - Added built-in support for
std::shared_ptr
holder type. It is no longer necessary to to include a declaration of the formPYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
(though continuing to do so won't cause an error). #454. New
py::overload_cast
casting operator to select among multiple possible overloads of a function. An example:py::class_<Pet>(m, "Pet") .def("set", py::overload_cast<int>(&Pet::set), "Set the pet's age") .def("set", py::overload_cast<const std::string &>(&Pet::set), "Set the pet's name");
This feature only works on C++14-capable compilers. #541.
C++ types are automatically cast to Python types, e.g. when assigning them as an attribute. For instance, the following is now legal:
py::module m = /* ... */ m.attr("constant") = 123;
(Previously, a
py::cast
call was necessary to avoid a compilation error.) #551.- Redesigned
pytest
-based test suite. #321. - Instance tracking to detect reference leaks in test suite. #324
- pybind11 can now distinguish between multiple different instances that are located at the same memory address, but which have different types. #329.
- Improved logic in
move
return value policy. #510, #297. - Generalized unpacking API to permit calling Python functions from C++ using notation such as
foo(a1, a2, *args, "ka"_a=1, "kb"_a=2, **kwargs)
. #372. py::print()
function whose behavior matches that of the native Pythonprint()
function. #372.- Added
py::dict
keyword constructor:auto d = dict("number"_a=42, "name"_a="World");
. #372. - Added
py::str::format()
method and_s
literal:py::str s = "1 + 2 = {}"_s.format(3);
. #372. - Added
py::repr()
function which is equivalent to Python's builtinrepr()
. #333. - Improved construction and destruction logic for holder types. It is now possible to reference instances with smart pointer holder types without constructing the holder if desired. The
PYBIND11_DECLARE_HOLDER_TYPE
macro now accepts an optional second parameter to indicate whether the holder type uses intrusive reference counting. #533 and #561. - Mapping a stateless C++ function to Python and back is now "for free" (i.e. no extra indirections or argument conversion overheads). rev. 954b79.
- Bindings for
std::valarray<T>
. #545. - Improved support for C++17 capable compilers. #562.
- Bindings for
std::optional<t>
. #475, #476, #479, #499, and #501. stl_bind.h
: general improvements and support forstd::map
andstd::unordered_map
. #490, #282, #235.- The
std::tuple
,std::pair
,std::list
, andstd::vector
type casters now accept any Python sequence type as input. rev. 107285. - Improved CMake Python detection on multi-architecture Linux. #532.
- Infrastructure to selectively disable or enable parts of the automatically generated docstrings. #486.
reference
andreference_internal
are now the default return value properties for static and non-static properties, respectively. #473. (the previous defaults wereautomatic
). #473.- Support for
std::unique_ptr
with non-default deleters or no deleter at all (py::nodelete
). #384. - Deprecated
handle::call()
method. The new syntax to call Python functions is simplyhandle()
. It can also be invoked explicitly viahandle::operator<X>()
, whereX
is an optional return value policy. - Print more informative error messages when
make_tuple()
orcast()
fail. #262. - Creation of holder types for classes deriving from
std::enable_shared_from_this<>
now also works forconst
values. #260. make_iterator()
improvements for better compatibility with various types (now uses prefix increment operator); it now also accepts iterators with different begin/end types as long as they are equality comparable. #247.arg()
now accepts a wider range of argument types for default values. #244.- Support
keep_alive
where the nurse object may beNone
. #341. - Added constructors for
str
andbytes
from zero-terminated char pointers, and from char pointers and length. Added constructors forstr
frombytes
and forbytes
fromstr
, which will perform UTF-8 decoding/encoding as required. - Many other improvements of library internals without user-visible changes
- Fixed a rare but potentially very severe issue when the garbage collector ran during pybind11 type creation.
- Redesigned CMake build system which exports a convenient
pybind11_add_module
function to parent projects. std::vector<>
type bindings analogous to Boost.Python'sindexing_suite
- Transparent conversion of sparse and dense Eigen matrices and vectors (
eigen.h
) - Added an
ExtraFlags
template argument to the NumPyarray_t<>
wrapper to disable an enforced cast that may lose precision, e.g. to create overloads for different precisions and complex vs real-valued matrices. - Prevent implicit conversion of floating point values to integral types in function arguments
- Fixed incorrect default return value policy for functions returning a shared pointer
- Don't allow registering a type via
class_
twice - Don't allow casting a
None
value into a C++ lvalue reference - Fixed a crash in
enum_::operator==
that was triggered by thehelp()
command - Improved detection of whether or not custom C++ types can be copy/move-constructed
- Extended
str
type to also work withbytes
instances - Added a
"name"_a
user defined string literal that is equivalent topy::arg("name")
. - When specifying function arguments via
py::arg
, the test that verifies the number of arguments now runs at compile time. - Added
[[noreturn]]
attribute topybind11_fail()
to quench some compiler warnings - List function arguments in exception text when the dispatch code cannot find a matching overload
- Added
PYBIND11_OVERLOAD_NAME
andPYBIND11_OVERLOAD_PURE_NAME
macros which can be used to override virtual methods whose name differs in C++ and Python (e.g.__call__
andoperator()
) - Various minor
iterator
andmake_iterator()
improvements - Transparently support
__bool__
on Python 2.x and Python 3.x - Fixed issue with destructor of unpickled object not being called
- Minor CMake build system improvements on Windows
- New
pybind11::args
andpybind11::kwargs
types to create functions which take an arbitrary number of arguments and keyword arguments - New syntax to call a Python function from C++ using
*args
and*kwargs
- The functions
def_property_*
now correctly process docstring arguments (these formerly caused a segmentation fault) - Many
mkdoc.py
improvements (enumerations, template arguments,DOC()
macro accepts more arguments) - Cygwin support
- Documentation improvements (pickling support,
keep_alive
, macro usage)
- Added a new
move
return value policy that triggers C++11 move semantics. The automatic return value policy falls back to this case whenever a rvalue reference is encountered - Significantly more general GIL state routines that are used instead of Python's troublesome
PyGILState_Ensure
andPyGILState_Release
API - Redesign of opaque types that drastically simplifies their usage
- Extended ability to pass values of type
[const] void *
keep_alive
fix: don't fail when there is no patientfunctional.h
: acquire the GIL before calling a Python function- Added Python RAII type wrappers
none
anditerable
- Added
*args
and*kwargs
pass-through parameters topybind11.get_include()
function - Iterator improvements and fixes
- Documentation on return value policies and opaque types improved
- Skipped due to upload to PyPI gone wrong and inability to recover (pypa/packaging-problems#74)
- For polymorphic types, use RTTI to try to return the closest type registered with pybind11
- Pickling support for serializing and unserializing C++ instances to a byte stream in Python
- Added a convenience routine
make_iterator()
which turns a range indicated by a pair of C++ iterators into a iterable Python object - Added
len()
and a variadicmake_tuple()
function - Addressed a rare issue that could confuse the current virtual function dispatcher and another that could lead to crashes in multi-threaded applications
- Added a
get_include()
function to the Python module that returns the path of the directory containing the installed pybind11 header files - Documentation improvements: import issues, symbol visibility, pickling, limitations
- Added casting support for
std::reference_wrapper<>
- Transparent type conversion for
std::wstring
andwchar_t
- Allow passing
nullptr
-valued strings - Transparent passing of
void *
pointers using capsules - Transparent support for returning values wrapped in
std::unique_ptr<>
- Improved docstring generation for compatibility with Sphinx
- Nicer debug error message when default parameter construction fails
- Support for "opaque" types that bypass the transparent conversion layer for STL containers
- Redesigned type casting interface to avoid ambiguities that could occasionally cause compiler errors
- Redesigned property implementation; fixes crashes due to an unfortunate default return value policy
- Anaconda package generation support
- Added support for the Intel C++ compiler (v15+)
- Added support for the STL unordered set/map data structures
- Added support for the STL linked list data structure
- NumPy-style broadcasting support in
pybind11::vectorize
- pybind11 now displays more verbose error messages when
arg::operator=()
fails - pybind11 internal data structures now live in a version-dependent namespace to avoid ABI issues
- Many, many bugfixes involving corner cases and advanced usage
- Optional: efficient generation of function signatures at compile time using C++14
- Switched to a simpler and more general way of dealing with function default arguments. Unused keyword arguments in function calls are now detected and cause errors as expected
- New
keep_alive
call policy analogous to Boost.Python'swith_custodian_and_ward
- New
pybind11::base<>
attribute to indicate a subclass relationship - Improved interface for RAII type wrappers in
pytypes.h
- Use RAII type wrappers consistently within pybind11 itself. This fixes various potential refcount leaks when exceptions occur
- Added new
bytes
RAII type wrapper (maps tostring
in Python 2.7) - Made handle and related RAII classes const correct, using them more consistently everywhere now
- Got rid of the ugly
__pybind11__
attributes on the Python side---they are now stored in a C++ hash table that is not visible in Python - Fixed refcount leaks involving NumPy arrays and bound functions
- Vastly improved handling of shared/smart pointers
- Removed an unnecessary copy operation in
pybind11::vectorize
- Fixed naming clashes when both pybind11 and NumPy headers are included
- Added conversions for additional exception types
- Documentation improvements (using multiple extension modules, smart pointers, other minor clarifications)
- unified infrastructure for parsing variadic arguments in
class_
and cpp_function - Fixed license text (was: ZLIB, should have been: 3-clause BSD)
- Python 3.2 compatibility
- Fixed remaining issues when accessing types in another plugin module
- Added enum comparison and casting methods
- Improved SFINAE-based detection of whether types are copy-constructible
- Eliminated many warnings about unused variables and the use of
offsetof()
- Support for
std::array<>
conversions
- Documentation improvements (GIL, wrapping functions, casting, fixed many typos)
- Generalized conversion of integer types
- Improved support for casting function objects
- Improved support for
std::shared_ptr<>
conversions - Initial support for
std::set<>
conversions - Fixed type resolution issue for types defined in a separate plugin module
- CMake build system improvements
- Factored out generic functionality to non-templated code (smaller code size)
- Added a code size / compile time benchmark vs Boost.Python
- Added an appveyor CI script
- Initial release