WIP: PyPy support (#527)
This commit includes modifications that are needed to get pybind11 to work with PyPy. The full test suite compiles and runs except for a last few functions that are commented out (due to problems in PyPy that were reported on the PyPy bugtracker).
Two somewhat intrusive changes were needed to make it possible: two new tags ``py::buffer_protocol()`` and ``py::metaclass()`` must now be specified to the ``class_`` constructor if the class uses the buffer protocol and/or requires a metaclass (e.g. for static properties).
Note that this is only for the PyPy version based on Python 2.7 for now. When the PyPy 3.x has caught up in terms of cpyext compliance, a PyPy 3.x patch will follow.
diff --git a/docs/advanced/classes.rst b/docs/advanced/classes.rst
index 4a423b5..e20895e 100644
--- a/docs/advanced/classes.rst
+++ b/docs/advanced/classes.rst
@@ -422,15 +422,24 @@
that are implemented in terms of C++ getters and setters.
Static properties can also be created in a similar way to expose getters and
-setters of static class attributes. It is important to note that the implicit
-``self`` argument also exists in this case and is used to pass the Python
-``type`` subclass instance. This parameter will often not be needed by the C++
-side, and the following example illustrates how to instantiate a lambda getter
-function that ignores it:
+setters of static class attributes. Two things are important to note:
+
+1. Static properties are implemented by instrumenting the *metaclass* of the
+ class in question -- however, this requires the class to have a modifiable
+ metaclass in the first place. pybind11 provides a ``py::metaclass()``
+ annotation that must be specified in the ``class_`` constructor, or any
+ later method calls to ``def_{property_,∅}_{readwrite,readonly}_static`` will
+ fail (see the example below).
+
+2. For static properties defined in terms of setter and getter functions, note
+ that the implicit ``self`` argument also exists in this case and is used to
+ pass the Python ``type`` subclass instance. This parameter will often not be
+ needed by the C++ side, and the following example illustrates how to
+ instantiate a lambda getter function that ignores it:
.. code-block:: cpp
- py::class_<Foo>(m, "Foo")
+ py::class_<Foo>(m, "Foo", py::metaclass())
.def_property_readonly_static("foo", [](py::object /* self */) { return Foo(); });
Operator overloading
diff --git a/docs/advanced/pycpp/numpy.rst b/docs/advanced/pycpp/numpy.rst
index 8b46b7c..111ff0e 100644
--- a/docs/advanced/pycpp/numpy.rst
+++ b/docs/advanced/pycpp/numpy.rst
@@ -33,7 +33,7 @@
.. code-block:: cpp
- py::class_<Matrix>(m, "Matrix")
+ py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
.def_buffer([](Matrix &m) -> py::buffer_info {
return py::buffer_info(
m.data(), /* Pointer to buffer */
@@ -46,9 +46,12 @@
);
});
-The snippet above binds a lambda function, which can create ``py::buffer_info``
-description records on demand describing a given matrix. The contents of
-``py::buffer_info`` mirror the Python buffer protocol specification.
+Supporting the buffer protocol in a new type involves specifying the special
+``py::buffer_protocol()`` tag in the ``py::class_`` constructor and calling the
+``def_buffer()`` method with a lambda function that creates a
+``py::buffer_info`` description record on demand describing a given matrix
+instance. The contents of ``py::buffer_info`` mirror the Python buffer protocol
+specification.
.. code-block:: cpp
@@ -77,7 +80,7 @@
typedef Matrix::Scalar Scalar;
constexpr bool rowMajor = Matrix::Flags & Eigen::RowMajorBit;
- py::class_<Matrix>(m, "Matrix")
+ py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
.def("__init__", [](Matrix &m, py::buffer b) {
typedef Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic> Strides;
diff --git a/docs/intro.rst b/docs/intro.rst
index 429a01c..f22eeed 100644
--- a/docs/intro.rst
+++ b/docs/intro.rst
@@ -51,6 +51,9 @@
*******
In addition to the core functionality, pybind11 provides some extra goodies:
+- Python 2.7, 3.x, and PyPy (PyPy2.7 >= 5.5) 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 Python function object.