Update deprecated macro

SylvainCorlay · SylvainCorlay · commit e24ee72b9c05 · 2018-01-24T22:34:23.000+01:00
diff --git a/README.md b/README.md
@@ -10,7 +10,7 @@ Python bindings for the [xtensor](https://github.com/QuantStack/xtensor) C++ mul
  - `xtensor` is a C++ library for multi-dimensional arrays enabling numpy-style broadcasting and lazy computing.
  - `xtensor-python` enables inplace use of numpy arrays in C++ with all the benefits from `xtensor`
 
-     - C++ universal function and broadcasting 
+     - C++ universal function and broadcasting
      - STL - compliant APIs.
      - A broad coverage of numpy APIs (see [the numpy to xtensor cheat sheet](http://xtensor.readthedocs.io/en/latest/numpy.html)).
 
@@ -54,14 +54,12 @@ double sum_of_sines(xt::pyarray<double>& m)
     return std::accumulate(sines.begin(), sines.end(), 0.0);
 }
 
-PYBIND11_PLUGIN(xtensor_python_test)
+PYBIND11_MODULE(xtensor_python_test, m)
 {
     xt::import_numpy();
-    pybind11::module m("xtensor_python_test", "Test module for xtensor python bindings");
+    m.doc() = "Test module for xtensor python bindings";
 
     m.def("sum_of_sines", sum_of_sines, "Sum the sines of the input values");
-
-    return m.ptr();
 }
 ```
 
@@ -80,7 +78,7 @@ s
 
 ```
 1.2853996391883833
-``` 
+```
 
 ### Example 2: Create a universal function from a C++ scalar function
 
@@ -99,13 +97,11 @@ double scalar_func(double i, double j)
     return std::sin(i) - std::cos(j);
 }
 
-PYBIND11_PLUGIN(xtensor_python_test)
+PYBIND11_MODULE(xtensor_python_test, m)
 {
-    py::module m("xtensor_python_test", "Test module for xtensor python bindings");
+    m.doc() = "Test module for xtensor python bindings";
 
     m.def("vectorized_func", xt::pyvectorize(scalar_func), "");
-
-    return m.ptr();
 }
 ```
 
@@ -127,7 +123,7 @@ z
 [[-0.540302,  1.257618,  1.89929 ,  0.794764, -1.040465],
  [-1.499227,  0.136731,  1.646979,  1.643002,  0.128456],
  [-1.084323, -0.583843,  0.45342 ,  1.073811,  0.706945]]
-``` 
+```
 
 ## Installation
 
@@ -155,7 +151,7 @@ Testing `xtensor-python` requires `pytest`
   py.test .
   ```
 
-To pick up changes in `xtensor-python` while rebuilding, delete the `build/` directory. 
+To pick up changes in `xtensor-python` while rebuilding, delete the `build/` directory.
 
 ## Building the HTML Documentation
 
@@ -169,7 +165,7 @@ While doxygen must be installed separately, you can install breathe by typing
 
 ```bash
 pip install breathe
-``` 
+```
 
 Breathe can also be installed with `conda`
 
diff --git a/benchmark/main.cpp b/benchmark/main.cpp
@@ -12,15 +12,15 @@ using complex_t = std::complex<double>;
 
 namespace py = pybind11;
 
-PYBIND11_PLUGIN(benchmark_xtensor_python)
+PYBIND11_MODULE(benchmark_xtensor_python, m)
 {
     if(_import_array() < 0)
     {
         PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import");
         return nullptr;
     }
 
-    py::module m("benchmark_xtensor_python", "Benchmark module for xtensor python bindings");
+    m.doc() = "Benchmark module for xtensor python bindings";
 
     m.def("sum_array", [](xt::pyarray<double> const& x) {
         double sum = 0;
@@ -55,6 +55,4 @@ PYBIND11_PLUGIN(benchmark_xtensor_python)
         else
             throw py::type_error("rect_to_polar unhandled type");
     });
-
-    return m.ptr();
 }
diff --git a/docs/source/basic_usage.rst b/docs/source/basic_usage.rst
@@ -26,14 +26,12 @@ Example 1: Use an algorithm of the C++ library on a numpy array inplace
         return std::accumulate(sines.cbegin(), sines.cend(), 0.0);
     }
 
-    PYBIND11_PLUGIN(xtensor_python_test)
+    PYBIND11_MODULE(xtensor_python_test, m)
     {
         xt::import_numpy();
-        pybind11::module m("xtensor_python_test", "Test module for xtensor python bindings");
+        m.doc() = "Test module for xtensor python bindings";
 
         m.def("sum_of_sines", sum_of_sines, "Sum the sines of the input values");
-
-        return m.ptr();
     }
 
 **Python code:**
@@ -74,14 +72,12 @@ Example 2: Create a numpy-style universal function from a C++ scalar function
         return std::sin(i) - std::cos(j);
     }
 
-    PYBIND11_PLUGIN(xtensor_python_test)
+    PYBIND11_MODULE(xtensor_python_test, m)
     {
         xt::import_numpy();
-        py::module m("xtensor_python_test", "Test module for xtensor python bindings");
+        m.doc() = "Test module for xtensor python bindings";
 
         m.def("vectorized_func", xt::pyvectorize(scalar_func), "");
-
-        return m.ptr();
     }
 
 **Python code:**
diff --git a/docs/source/numpy_capi.rst b/docs/source/numpy_capi.rst
@@ -27,12 +27,10 @@ Thus the basic skeleton of the module looks like:
     #define FORCE_IMPORT_ARRAY
     #include "xtensor-python/pyarray.hpp"
 
-    PYBIND11_PLUGIN(plugin_name)
+    PYBIND11_MODULE(plugin_name, m)
     {
         xt::import_numpy();
-        pybind11::module m(//...
         //...
-        return m.ptr();
     }
 
 
diff --git a/test_python/main.cpp b/test_python/main.cpp
@@ -107,11 +107,11 @@ void dump_numpy_constant()
     std::cout << "NPY_UINT64 = " << NPY_UINT64 << std::endl;
 }
 
-PYBIND11_PLUGIN(xtensor_python_test)
+PYBIND11_MODULE(xtensor_python_test, m)
 {
     xt::import_numpy();
 
-    py::module m("xtensor_python_test", "Test module for xtensor python bindings");
+    m.doc() = "Test module for xtensor python bindings";
 
     m.def("example1", example1);
     m.def("example2", example2);
@@ -142,6 +142,4 @@ PYBIND11_PLUGIN(xtensor_python_test)
     m.def("int_overload", int_overload<int64_t>);
 
     m.def("dump_numpy_constant", dump_numpy_constant);
-
-    return m.ptr();
 }

Original file line number	Diff line number	Diff line change
`@@ -12,15 +12,15 @@ using complex_t = std::complex<double>;`
`12`	`12`
`13`	`13`	`namespace py = pybind11;`
`14`	`14`
`15`		`-PYBIND11_PLUGIN(benchmark_xtensor_python)`
	`15`	`+PYBIND11_MODULE(benchmark_xtensor_python, m)`
`16`	`16`	`{`
`17`	`17`	`if(_import_array() < 0)`
`18`	`18`	`{`
`19`	`19`	`PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import");`
`20`	`20`	`return nullptr;`
`21`	`21`	`}`
`22`	`22`
`23`		`- py::module m("benchmark_xtensor_python", "Benchmark module for xtensor python bindings");`
	`23`	`+ m.doc() = "Benchmark module for xtensor python bindings";`
`24`	`24`
`25`	`25`	`m.def("sum_array", [](xt::pyarray<double> const& x) {`
`26`	`26`	`double sum = 0;`
`@@ -55,6 +55,4 @@ PYBIND11_PLUGIN(benchmark_xtensor_python)`
`55`	`55`	`else`
`56`	`56`	`throw py::type_error("rect_to_polar unhandled type");`
`57`	`57`	`});`
`58`		`-`
`59`		`- return m.ptr();`
`60`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,14 +26,12 @@ Example 1: Use an algorithm of the C++ library on a numpy array inplace`
`26`	`26`	`return std::accumulate(sines.cbegin(), sines.cend(), 0.0);`
`27`	`27`	`}`
`28`	`28`
`29`		`- PYBIND11_PLUGIN(xtensor_python_test)`
	`29`	`+ PYBIND11_MODULE(xtensor_python_test, m)`
`30`	`30`	`{`
`31`	`31`	`xt::import_numpy();`
`32`		`- pybind11::module m("xtensor_python_test", "Test module for xtensor python bindings");`
	`32`	`+ m.doc() = "Test module for xtensor python bindings";`
`33`	`33`
`34`	`34`	`m.def("sum_of_sines", sum_of_sines, "Sum the sines of the input values");`
`35`		`-`
`36`		`- return m.ptr();`
`37`	`35`	`}`
`38`	`36`
`39`	`37`	`Python code:`
`@@ -74,14 +72,12 @@ Example 2: Create a numpy-style universal function from a C++ scalar function`
`74`	`72`	`return std::sin(i) - std::cos(j);`
`75`	`73`	`}`
`76`	`74`
`77`		`- PYBIND11_PLUGIN(xtensor_python_test)`
	`75`	`+ PYBIND11_MODULE(xtensor_python_test, m)`
`78`	`76`	`{`
`79`	`77`	`xt::import_numpy();`
`80`		`- py::module m("xtensor_python_test", "Test module for xtensor python bindings");`
	`78`	`+ m.doc() = "Test module for xtensor python bindings";`
`81`	`79`
`82`	`80`	`m.def("vectorized_func", xt::pyvectorize(scalar_func), "");`
`83`		`-`
`84`		`- return m.ptr();`
`85`	`81`	`}`
`86`	`82`
`87`	`83`	`Python code:`
Original file line number	Diff line number	Diff line change
`@@ -27,12 +27,10 @@ Thus the basic skeleton of the module looks like:`
`27`	`27`	`#define FORCE_IMPORT_ARRAY`
`28`	`28`	`#include "xtensor-python/pyarray.hpp"`
`29`	`29`
`30`		`- PYBIND11_PLUGIN(plugin_name)`
	`30`	`+ PYBIND11_MODULE(plugin_name, m)`
`31`	`31`	`{`
`32`	`32`	`xt::import_numpy();`
`33`		`- pybind11::module m(//...`
`34`	`33`	`//...`
`35`		`- return m.ptr();`
`36`	`34`	`}`
`37`	`35`
`38`	`36`
Original file line number	Diff line number	Diff line change
`@@ -107,11 +107,11 @@ void dump_numpy_constant()`
`107`	`107`	`std::cout << "NPY_UINT64 = " << NPY_UINT64 << std::endl;`
`108`	`108`	`}`
`109`	`109`
`110`		`-PYBIND11_PLUGIN(xtensor_python_test)`
	`110`	`+PYBIND11_MODULE(xtensor_python_test, m)`
`111`	`111`	`{`
`112`	`112`	`xt::import_numpy();`
`113`	`113`
`114`		`- py::module m("xtensor_python_test", "Test module for xtensor python bindings");`
	`114`	`+ m.doc() = "Test module for xtensor python bindings";`
`115`	`115`
`116`	`116`	`m.def("example1", example1);`
`117`	`117`	`m.def("example2", example2);`
`@@ -142,6 +142,4 @@ PYBIND11_PLUGIN(xtensor_python_test)`
`142`	`142`	`m.def("int_overload", int_overload<int64_t>);`
`143`	`143`
`144`	`144`	`m.def("dump_numpy_constant", dump_numpy_constant);`
`145`		`-`
`146`		`- return m.ptr();`
`147`	`145`	`}`