Commit c7129e91 authored by Sebastian Kehl's avatar Sebastian Kehl
Browse files

Cleanup.

parent de61e262
# Bits & Bytes Article (to be moved to the docs eventually)
## Introduction
With the rising popularity of the Python programming language it has become increasingly important for computational scientists to be able to make their software easily available to the Python ecosystem and community.
Historically, exposing compiled extensions from C/C++ to Python has often been cumbersome, error prone and technically challenging, given the plethora of compilers, libraries and relevant target platforms developers have to deal with.
The present article introduces a combination of two Python packages that promise to make this daunting task much easier and more stable.
First, the [Pybind11](https://github.com/pybind/pybind11) header-only library provides a convenient approach to generate Python bindings for existing or newly developed C++ code.
Second, the [scikit-build](https://github.com/scikit-build/scikit-build) package can be used to bridge Python's `setuptools` with [CMake](https://cmake.org/), leveraging the power of CMake for the build process of the Python extension.
As a result, CMake's native features such as, e.g., discovering and linking of numerical libraries, dependency management, support of various build-generators, or even cross-compilation can easily be taken advantage of during the build process of the Python extension.
A key advantage is that the file 'setup.py' stays minimal and simple, instead the aforementioned complexities are handled by CMake.
## Basic Usage
The basic usage of pybind11 in combination with scikit-build is demonstrated below by means of a simple Python extension package.
The code example can be obtained from [MPCDF GitLab](https://gitlab.mpcdf.mpg.de/sebak/pybind11-hello-world).
### Interfacing Python/NumPy with C++ using pybind11
pybind11 is a header-only library that provides conversion from C/C++ types to Python, and vice versa.
The following C++ Python extension module 'cumsum' demonstrates its use in combination with NumPy arrays.
```c++
// Python example module 'cumsum'
#include <numeric>
#include <functional>
#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>
namespace py = pybind11;
// numpy-like cumulative sum, taking a NumPy array as input and returning a NumPy array
py::array_t<double> cumsum(py::array_t<double> a)
{
// obtain information about the n-d input array
auto shape = a.request().shape;
size_t count = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<size_t>());
// create output NumPy array
py::array_t<double> b(count);
// obtain raw pointers
double * a_p = (double*) a.request().ptr;
double * b_p = (double*) b.request().ptr;
// compute cumulative sum into b
double cs = 0.0;
for (size_t i = 0; i<count; ++i) {
cs += a_p[i];
b_p[i] = cs;
}
return b;
}
PYBIND11_MODULE(cumsum, m) {
m.doc() = "pybind11 cumulative sum example"; // module docstring
m.def("cumsum", &cumsum, // third parameter is the function docstring
"return the cumulative sum of a double-precision numpy array");
}
```
The 'cumsum' example module could finally be used and tested as follows:
```python
import numpy as np
import cumsum
a = np.random.rand(20)
b = cumsum.cumsum(a)
c = np.cumsum(a)
assert(np.allclose(b, c))
```
In order for this example to be compiled, the pybind11 headers (as any other potential dependency) must be available. pybind11 can be installed in [several ways](https://pybind11.readthedocs.io/en/stable/installing.html), and it natively supports various [build systems](https://pybind11.readthedocs.io/en/stable/compiling.html#compiling).
However using scikit-build provides a particularly easy approach which is shown in the following.
### build with scikit-learn
The package scikit-build provides a drop-in replacement for the `setuptools.setup` function that can be used in a project's `setup.py` via
```python
from skbuild import setup
```
Beside the standard setuptools options, it provides [extra options](https://scikit-build.readthedocs.io/en/latest/usage.html#scikit-build-options) to control the CMake build.
In addition, a minimal `CMakeLists.txt` file must be available in the top-level directory of the project, e.g.:
```cmake
cmake_minimum_required(VERSION 3.18)
project(pybind11-hello-world VERSION "1.0")
find_package(pybind11)
pybind11_add_module(_cumsum MODULE src/cumsum/cumsum.cpp)
install(TARGETS _cumsum DESTINATION .)
```
Build-system dependencies have to be specified via the project's `pyproject.toml` file:
```toml
[build-system]
requires = [
"setuptools>=42",
"wheel",
"pybind11[global]>=2.6.0",
"cmake>=3.18",
"scikit-build",
]
build-backend = "setuptools.build_meta"
```
Now the Python module can be compiled and installed by running the command `pip install --user .` in the root directory of the project. Similarly Wheel archives can be created for distribution.
Note that with modern Python packaging tools it is not necessary to manually install pybind11 and scikit-build, instead all build dependencies will be installed into an isolated build environment by `pip`.
The '[global]' feature of the pybind11 requirement is necessary to install the include and cmake files correctly into the dedicated build environment, it does not affect the Python installation or environment in use and can thus be used safely.
*Sebastian Kehl, Klaus Reuter*
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment