Pybind11 compatibility

* Add some compatibility structures to a separate header file
* Integrate scope handling to match pybind11 API
* register_enum and register_g3module functions

Author: arahlin

CMakeLists.txt

@@ -52,7 +52,7 @@ set(Boost_USE_STATIC_LIBS OFF)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
 set(Boost_PYTHON_VERSION ${Python_VERSION})
-find_package(Boost COMPONENTS python REQUIRED)
+find_package(Boost CONFIG COMPONENTS python REQUIRED)
 
 # Interface library for flags and library dependencies
 add_library(spt3g INTERFACE)

calibration/src/BoloProperties.cxx

@@ -57,7 +57,7 @@ std::string BolometerProperties::Description() const
 G3_SERIALIZABLE_CODE(BolometerProperties);
 G3_SERIALIZABLE_CODE(BolometerPropertiesMap);
 
-PYBINDINGS("calibration") {
+PYBINDINGS("calibration", scope) {
 	EXPORT_FRAMEOBJECT(BolometerProperties, py::init<>(),
 	    "Physical bolometer properties, such as detector angular offsets. "
 	    "Does not include tuning-dependent properties of the detectors.")
@@ -89,7 +89,7 @@ PYBINDINGS("calibration") {
 	       "Name of the pixel type of which this detector is a part")
 	;
 
-	py::enum_<BolometerProperties::CouplingType>("BolometerCouplingType",
+	register_enum<BolometerProperties::CouplingType>(scope, "BolometerCouplingType",
 	  "Coupling type for BolometerProperties objects.")
 	    .value("Unknown", BolometerProperties::Unknown)
 	    .value("Optical", BolometerProperties::Optical)

calibration/src/PointingProperties.cxx

@@ -26,7 +26,7 @@ std::string PointingProperties::Description() const
 G3_SERIALIZABLE_CODE(PointingProperties);
 G3_SERIALIZABLE_CODE(PointingPropertiesMap);
 
-PYBINDINGS("calibration") {
+PYBINDINGS("calibration", scope) {
 	EXPORT_FRAMEOBJECT(PointingProperties, py::init<>(),
 	    "Pointing model parameters to be used for offline pointing corrections.")
 	    .def_readwrite("tiltLat", &PointingProperties::tiltLat,

calibration/src/python.cxx

@@ -1,14 +1,8 @@
 #include <pybindings.h>
 
-SPT3G_PYTHON_MODULE(calibration)
+SPT3G_PYTHON_MODULE(calibration, scope)
 {
 	// Python bindings dependencies
-	py::import("spt3g.core");
-
-	// Disable noise in doc strings
-	py::docstring_options docopts(true, true, false);
-
-	// Python bindings for this module
-	G3ModuleRegistrator::CallRegistrarsFor("calibration");
+	scope.import("spt3g.core");
 }
 

core/include/core/pybind11_compat.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include <boost/python.hpp>
+#include <string>
+
+#include <G3Logging.h>
+
+namespace py = boost::python;
+
+// Python runtime context to simplify acquiring or releasing the GIL as necessary.
+// To use, simply construct the context object where necessary, e.g.
+//    G3PythonContext ctx("mycontext", false);
+// The context destructor will clean up after itself (releasing the GIL if acquired, and
+// vice versa).  If hold_gil is true, the context will ensure the GIL is held at construction,
+// and released at destruction.  If hold_gil is false, the context will save the current thread
+// state and release the GIL at construction, and re-acquire it at destruction.
+class G3PythonContext {
+public:
+	G3PythonContext(std::string name, bool hold_gil=false);
+	~G3PythonContext();
+
+private:
+	std::string name_;
+	bool hold_;
+	PyGILState_STATE gil_;
+	PyThreadState *thread_;
+
+	SET_LOGGER("G3PythonContext");
+};
+
+// Convenience class for initializing and finalizing the Python interpreter.  This class
+// will initialize the python interpeter at construction (e.g. at the beginning of a C++
+// compiled program), and immediately initialize the appropriate G3PythonContext depending
+// on the value of hold_gil.  At destruction, it will exit the python context and finalize
+// the interpreter.  The python interpreter should be initialized only once, typically at
+// the beginning of the main program.
+class G3PythonInterpreter {
+public:
+	G3PythonInterpreter();
+	~G3PythonInterpreter();
+
+private:
+	bool init_;
+
+	SET_LOGGER("G3PythonInterpreter");
+};
+
+// pybind11 compatibility functions
+namespace boost { namespace python {
+
+class module_ : public scope
+{
+public:
+	static auto import(const std::string &name) {
+		return py::import(name.c_str());
+	}
+
+	py::object def_submodule(const std::string &name);
+
+	template <typename...Args>
+	static auto def(Args&&... args) {
+		return py::def(std::forward<Args>(args)...);
+	}
+};
+
+class gil_scoped_release : public G3PythonContext
+{
+public:
+	gil_scoped_release() : G3PythonContext("release", false) {};
+};
+
+class gil_scoped_acquire : public G3PythonContext
+{
+public:
+	gil_scoped_acquire() : G3PythonContext("acquire", true) {};
+};
+
+class scoped_interpreter : public G3PythonInterpreter {};
+
+template <typename T>
+T cast(const py::object &obj)
+{
+	return py::extract<T>(obj)();
+}
+
+template <typename T>
+bool isinstance(const py::object &obj)
+{
+	return py::extract<T>(obj).check();
+}
+
+class value_error : std::exception
+{
+public:
+	std::string msg;
+	value_error(std::string msg="") : msg(msg) {};
+	const char * what() const throw() { return msg.c_str(); }
+};
+
+class index_error : std::exception
+{
+public:
+	std::string msg;
+	index_error(std::string msg="") : msg(msg) {};
+	const char * what() const throw() { return msg.c_str(); }
+};
+
+class type_error : std::exception
+{
+public:
+	std::string msg;
+	type_error(std::string msg="") : msg(msg) {};
+	const char * what() const throw() { return msg.c_str(); }
+};
+
+class key_error : std::exception
+{
+public:
+	std::string msg;
+	key_error(std::string msg="") : msg(msg) {};
+	const char * what() const throw() { return msg.c_str(); }
+};
+
+class buffer_error : std::exception
+{
+public:
+	std::string msg;
+	buffer_error(std::string msg="") : msg(msg) {};
+	const char * what() const throw() { return msg.c_str(); }
+};
+
+}}