mpm: python: Move from Boost.Python to PyBind11

15 files changed, 126 insertions, 268 deletions

diff --git a/mpm/CMakeLists.txt b/mpm/CMakeLists.txt
index 1a5946b63..4f6c3b651 100644
--- a/mpm/CMakeLists.txt
+++ b/mpm/CMakeLists.txt
@@ -76,7 +76,6 @@ message(STATUS "")
 message(STATUS "Configuring Boost C++ Libraries...")
 set(BOOST_REQUIRED_COMPONENTS
     system
-    python3
     thread
 )
 # Same as with Python version: MPM might work with other versions of Boost,
diff --git a/mpm/include/mpm/ad9361/ad9361_ctrl.hpp b/mpm/include/mpm/ad9361/ad9361_ctrl.hpp
index 8bcd7f7c4..7673d7460 100644
--- a/mpm/include/mpm/ad9361/ad9361_ctrl.hpp
+++ b/mpm/include/mpm/ad9361/ad9361_ctrl.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -20,23 +21,18 @@ using uhd::usrp::ad9361_ctrl;
 
 // TODO: pull in filter_info_base
 #ifdef LIBMPM_PYTHON
-void export_catalina()
+void export_catalina(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("ad9361")
     using namespace mpm::chips;
-    bp::class_<ad9361_ctrl, boost::noncopyable, boost::shared_ptr<ad9361_ctrl>>(
-        "ad9361_ctrl", bp::no_init)
-        .def("get_gain_names", &ad9361_ctrl::get_gain_names)
-        .staticmethod("get_gain_names")
+    auto m = top_module.def_submodule("ad9361");
+
+    py::class_<ad9361_ctrl, boost::shared_ptr<ad9361_ctrl>>(m, "ad9361_ctrl")
+        .def_static("get_gain_names", &ad9361_ctrl::get_gain_names)
         // Make this "Python private" because the return value can't be serialized
-        .def("_get_gain_range", &ad9361_ctrl::get_gain_range)
-        .staticmethod("_get_gain_range")
-        .def("get_rf_freq_range", &ad9361_ctrl::get_rf_freq_range)
-        .staticmethod("get_rf_freq_range")
-        .def("get_bw_filter_range", &ad9361_ctrl::get_bw_filter_range)
-        .staticmethod("get_bw_filter_range")
-        .def("get_clock_rate_range", &ad9361_ctrl::get_clock_rate_range)
-        .staticmethod("get_clock_rate_range")
+        .def_static("_get_gain_range", &ad9361_ctrl::get_gain_range)
+        .def_static("get_rf_freq_range", &ad9361_ctrl::get_rf_freq_range)
+        .def_static("get_bw_filter_range", &ad9361_ctrl::get_bw_filter_range)
+        .def_static("get_clock_rate_range", &ad9361_ctrl::get_clock_rate_range)
         .def("set_bw_filter", &ad9361_ctrl::set_bw_filter)
         .def("set_gain", &ad9361_ctrl::set_gain)
         .def("set_agc", &ad9361_ctrl::set_agc)
diff --git a/mpm/include/mpm/ad937x/ad937x_ctrl.hpp b/mpm/include/mpm/ad937x/ad937x_ctrl.hpp
index 7274c433a..6d28eccd1 100644
--- a/mpm/include/mpm/ad937x/ad937x_ctrl.hpp
+++ b/mpm/include/mpm/ad937x/ad937x_ctrl.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2017 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -274,12 +275,12 @@ public:
 }}; /* namespace mpm::chips */
 
 #ifdef LIBMPM_PYTHON
-void export_mykonos()
+void export_mykonos(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("ad937x")
     using namespace mpm::chips;
-    bp::class_<ad937x_ctrl, boost::noncopyable, std::shared_ptr<ad937x_ctrl>>(
-        "ad937x_ctrl", bp::no_init)
+    auto m = top_module.def_submodule("ad937x");
+
+    py::class_<ad937x_ctrl, std::shared_ptr<ad937x_ctrl>>(m, "ad937x_ctrl")
         .def("set_master_clock_rate", &ad937x_ctrl::set_master_clock_rate)
         .def("begin_initialization", &ad937x_ctrl::begin_initialization)
         .def("async__finish_initialization",
@@ -348,45 +349,45 @@ void export_mykonos()
         .def("set_fir", &ad937x_ctrl::set_fir)
         .def("get_fir", &ad937x_ctrl::get_fir)
         .def("get_temperature", &ad937x_ctrl::get_temperature)
-        .def_readonly("TX_BB_FILTER", &ad937x_ctrl::TX_BB_FILTER)
-        .def_readonly("ADC_TUNER", &ad937x_ctrl::ADC_TUNER)
-        .def_readonly("TIA_3DB_CORNER", &ad937x_ctrl::TIA_3DB_CORNER)
-        .def_readonly("DC_OFFSET", &ad937x_ctrl::DC_OFFSET)
-        .def_readonly("TX_ATTENUATION_DELAY", &ad937x_ctrl::TX_ATTENUATION_DELAY)
-        .def_readonly("RX_GAIN_DELAY", &ad937x_ctrl::RX_GAIN_DELAY)
-        .def_readonly("FLASH_CAL", &ad937x_ctrl::FLASH_CAL)
-        .def_readonly("PATH_DELAY", &ad937x_ctrl::PATH_DELAY)
-        .def_readonly("TX_LO_LEAKAGE_INTERNAL", &ad937x_ctrl::TX_LO_LEAKAGE_INTERNAL)
-        .def_readonly("TX_LO_LEAKAGE_EXTERNAL", &ad937x_ctrl::TX_LO_LEAKAGE_EXTERNAL)
-        .def_readonly("TX_QEC_INIT", &ad937x_ctrl::TX_QEC_INIT)
-        .def_readonly("LOOPBACK_RX_LO_DELAY", &ad937x_ctrl::LOOPBACK_RX_LO_DELAY)
-        .def_readonly("LOOPBACK_RX_RX_QEC_INIT", &ad937x_ctrl::LOOPBACK_RX_RX_QEC_INIT)
-        .def_readonly("RX_LO_DELAY", &ad937x_ctrl::RX_LO_DELAY)
-        .def_readonly("RX_QEC_INIT", &ad937x_ctrl::RX_QEC_INIT)
-        .def_readonly("DPD_INIT", &ad937x_ctrl::DPD_INIT)
-        .def_readonly("CLGC_INIT", &ad937x_ctrl::CLGC_INIT)
-        .def_readonly("VSWR_INIT", &ad937x_ctrl::VSWR_INIT)
-        .def_readonly("TRACK_RX1_QEC", &ad937x_ctrl::TRACK_RX1_QEC)
-        .def_readonly("TRACK_RX2_QEC", &ad937x_ctrl::TRACK_RX2_QEC)
-        .def_readonly("TRACK_ORX1_QEC", &ad937x_ctrl::TRACK_ORX1_QEC)
-        .def_readonly("TRACK_ORX2_QEC", &ad937x_ctrl::TRACK_ORX2_QEC)
-        .def_readonly("TRACK_TX1_LOL", &ad937x_ctrl::TRACK_TX1_LOL)
-        .def_readonly("TRACK_TX2_LOL", &ad937x_ctrl::TRACK_TX2_LOL)
-        .def_readonly("TRACK_TX1_QEC", &ad937x_ctrl::TRACK_TX1_QEC)
-        .def_readonly("TRACK_TX2_QEC", &ad937x_ctrl::TRACK_TX2_QEC)
-        .def_readonly("TRACK_TX1_DPD", &ad937x_ctrl::TRACK_TX1_DPD)
-        .def_readonly("TRACK_TX2_DPD", &ad937x_ctrl::TRACK_TX2_DPD)
-        .def_readonly("TRACK_TX1_CLGC", &ad937x_ctrl::TRACK_TX1_CLGC)
-        .def_readonly("TRACK_TX2_CLGC", &ad937x_ctrl::TRACK_TX2_CLGC)
-        .def_readonly("TRACK_TX1_VSWR", &ad937x_ctrl::TRACK_TX1_VSWR)
-        .def_readonly("TRACK_TX2_VSWR", &ad937x_ctrl::TRACK_TX2_VSWR)
-        .def_readonly("TRACK_ORX1_QEC_SNLO", &ad937x_ctrl::TRACK_ORX1_QEC_SNLO)
-        .def_readonly("TRACK_ORX2_QEC_SNLO", &ad937x_ctrl::TRACK_ORX2_QEC_SNLO)
-        .def_readonly("TRACK_SRX_QEC", &ad937x_ctrl::TRACK_SRX_QEC)
-        .def_readonly("DEFAULT_INIT_CALS_MASKS", &ad937x_ctrl::DEFAULT_INIT_CALS_MASKS)
-        .def_readonly(
+        .def_readonly_static("TX_BB_FILTER", &ad937x_ctrl::TX_BB_FILTER)
+        .def_readonly_static("ADC_TUNER", &ad937x_ctrl::ADC_TUNER)
+        .def_readonly_static("TIA_3DB_CORNER", &ad937x_ctrl::TIA_3DB_CORNER)
+        .def_readonly_static("DC_OFFSET", &ad937x_ctrl::DC_OFFSET)
+        .def_readonly_static("TX_ATTENUATION_DELAY", &ad937x_ctrl::TX_ATTENUATION_DELAY)
+        .def_readonly_static("RX_GAIN_DELAY", &ad937x_ctrl::RX_GAIN_DELAY)
+        .def_readonly_static("FLASH_CAL", &ad937x_ctrl::FLASH_CAL)
+        .def_readonly_static("PATH_DELAY", &ad937x_ctrl::PATH_DELAY)
+        .def_readonly_static("TX_LO_LEAKAGE_INTERNAL", &ad937x_ctrl::TX_LO_LEAKAGE_INTERNAL)
+        .def_readonly_static("TX_LO_LEAKAGE_EXTERNAL", &ad937x_ctrl::TX_LO_LEAKAGE_EXTERNAL)
+        .def_readonly_static("TX_QEC_INIT", &ad937x_ctrl::TX_QEC_INIT)
+        .def_readonly_static("LOOPBACK_RX_LO_DELAY", &ad937x_ctrl::LOOPBACK_RX_LO_DELAY)
+        .def_readonly_static("LOOPBACK_RX_RX_QEC_INIT", &ad937x_ctrl::LOOPBACK_RX_RX_QEC_INIT)
+        .def_readonly_static("RX_LO_DELAY", &ad937x_ctrl::RX_LO_DELAY)
+        .def_readonly_static("RX_QEC_INIT", &ad937x_ctrl::RX_QEC_INIT)
+        .def_readonly_static("DPD_INIT", &ad937x_ctrl::DPD_INIT)
+        .def_readonly_static("CLGC_INIT", &ad937x_ctrl::CLGC_INIT)
+        .def_readonly_static("VSWR_INIT", &ad937x_ctrl::VSWR_INIT)
+        .def_readonly_static("TRACK_RX1_QEC", &ad937x_ctrl::TRACK_RX1_QEC)
+        .def_readonly_static("TRACK_RX2_QEC", &ad937x_ctrl::TRACK_RX2_QEC)
+        .def_readonly_static("TRACK_ORX1_QEC", &ad937x_ctrl::TRACK_ORX1_QEC)
+        .def_readonly_static("TRACK_ORX2_QEC", &ad937x_ctrl::TRACK_ORX2_QEC)
+        .def_readonly_static("TRACK_TX1_LOL", &ad937x_ctrl::TRACK_TX1_LOL)
+        .def_readonly_static("TRACK_TX2_LOL", &ad937x_ctrl::TRACK_TX2_LOL)
+        .def_readonly_static("TRACK_TX1_QEC", &ad937x_ctrl::TRACK_TX1_QEC)
+        .def_readonly_static("TRACK_TX2_QEC", &ad937x_ctrl::TRACK_TX2_QEC)
+        .def_readonly_static("TRACK_TX1_DPD", &ad937x_ctrl::TRACK_TX1_DPD)
+        .def_readonly_static("TRACK_TX2_DPD", &ad937x_ctrl::TRACK_TX2_DPD)
+        .def_readonly_static("TRACK_TX1_CLGC", &ad937x_ctrl::TRACK_TX1_CLGC)
+        .def_readonly_static("TRACK_TX2_CLGC", &ad937x_ctrl::TRACK_TX2_CLGC)
+        .def_readonly_static("TRACK_TX1_VSWR", &ad937x_ctrl::TRACK_TX1_VSWR)
+        .def_readonly_static("TRACK_TX2_VSWR", &ad937x_ctrl::TRACK_TX2_VSWR)
+        .def_readonly_static("TRACK_ORX1_QEC_SNLO", &ad937x_ctrl::TRACK_ORX1_QEC_SNLO)
+        .def_readonly_static("TRACK_ORX2_QEC_SNLO", &ad937x_ctrl::TRACK_ORX2_QEC_SNLO)
+        .def_readonly_static("TRACK_SRX_QEC", &ad937x_ctrl::TRACK_SRX_QEC)
+        .def_readonly_static("DEFAULT_INIT_CALS_MASKS", &ad937x_ctrl::DEFAULT_INIT_CALS_MASKS)
+        .def_readonly_static(
             "DEFAULT_TRACKING_CALS_MASKS", &ad937x_ctrl::DEFAULT_TRACKING_CALS_MASKS)
-        .def_readonly(
+        .def_readonly_static(
             "DEFAULT_INIT_CALS_TIMEOUT", &ad937x_ctrl::DEFAULT_INIT_CALS_TIMEOUT);
 }
 #endif
diff --git a/mpm/include/mpm/dboards/magnesium_manager.hpp b/mpm/include/mpm/dboards/magnesium_manager.hpp
index ab2a20864..76f61d203 100644
--- a/mpm/include/mpm/dboards/magnesium_manager.hpp
+++ b/mpm/include/mpm/dboards/magnesium_manager.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2017 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -45,12 +46,13 @@ private:
 }}; /* namespace mpm::dboards */
 
 #ifdef LIBMPM_PYTHON
-void export_magnesium()
+void export_magnesium(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("dboards")
     using namespace mpm::dboards;
-    bp::class_<mpm::dboards::magnesium_manager>(
-        "magnesium_manager", bp::init<std::string, size_t>())
+    auto m = top_module.def_submodule("dboards");
+
+    py::class_<mpm::dboards::magnesium_manager>(m, "magnesium_manager")
+        .def(py::init<std::string, size_t>())
         .def("get_spi_lock", &mpm::dboards::magnesium_manager::get_spi_lock)
         .def("get_radio_ctrl", &mpm::dboards::magnesium_manager::get_radio_ctrl);
 }
diff --git a/mpm/include/mpm/dboards/neon_manager.hpp b/mpm/include/mpm/dboards/neon_manager.hpp
index 580b9cd38..22f0f0544 100644
--- a/mpm/include/mpm/dboards/neon_manager.hpp
+++ b/mpm/include/mpm/dboards/neon_manager.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -33,11 +34,13 @@ private:
 }}; /* namespace mpm::dboards */
 
 #ifdef LIBMPM_PYTHON
-void export_neon()
+void export_neon(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("dboards")
     using namespace mpm::dboards;
-    bp::class_<mpm::dboards::neon_manager>("neon_manager", bp::init<std::string>())
+    auto m = top_module.def_submodule("dboards");
+
+    py::class_<mpm::dboards::neon_manager>(m, "neon_manager")
+        .def(py::init<std::string>())
         .def("get_radio_ctrl", &mpm::dboards::neon_manager::get_radio_ctrl);
 }
 #endif
diff --git a/mpm/include/mpm/i2c/i2c_python.hpp b/mpm/include/mpm/i2c/i2c_python.hpp
index f358ea687..ebc9cb0a1 100644
--- a/mpm/include/mpm/i2c/i2c_python.hpp
+++ b/mpm/include/mpm/i2c/i2c_python.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -9,21 +10,9 @@
 #include "i2c_iface.hpp"
 #include "i2c_regs_iface.hpp"
 
-void export_i2c()
+void export_i2c(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("i2c")
+    auto m = top_module.def_submodule("i2c");
 
-    bp::def("make_i2cdev_regs_iface", &mpm::i2c::make_i2cdev_regs_iface);
-    /*
-        bp::def("make_i2cdev", &mpm::i2c::i2c_iface::make_i2cdev);
-
-        int (mpm::i2c::i2c_iface::*transfer_vec)(std::vector<uint8_t>*,
-                                                 std::vector<uint8_t>*) =
-            &mpm::i2c::i2c_iface::transfer;
-
-        bp::class_<mpm::i2c::i2c_iface, boost::noncopyable,
-                   std::shared_ptr<mpm::i2c::i2c_iface> >("i2c_iface", bp::no_init)
-            .def("transfer", transfer_vec)
-        ;
-    */
+    m.def("make_i2cdev_regs_iface", &mpm::i2c::make_i2cdev_regs_iface);
 }
diff --git a/mpm/include/mpm/spi/spi_python.hpp b/mpm/include/mpm/spi/spi_python.hpp
index 2b609c44a..464df8d8b 100644
--- a/mpm/include/mpm/spi/spi_python.hpp
+++ b/mpm/include/mpm/spi/spi_python.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2017 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -9,15 +10,13 @@
 #include "spi_iface.hpp"
 #include "spi_regs_iface.hpp"
 
-void export_spi()
+void export_spi(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("spi")
+    auto m = top_module.def_submodule("spi");
 
-    bp::def("make_spidev_regs_iface", &mpm::spi::make_spidev_regs_iface);
-    bp::def("make_spidev", &mpm::spi::spi_iface::make_spidev);
+    m.def("make_spidev_regs_iface", &mpm::spi::make_spidev_regs_iface);
+    m.def("make_spidev", &mpm::spi::spi_iface::make_spidev);
 
-    bp::class_<mpm::spi::spi_iface,
-        boost::noncopyable,
-        std::shared_ptr<mpm::spi::spi_iface>>("spi_iface", bp::no_init)
+    py::class_<mpm::spi::spi_iface, std::shared_ptr<mpm::spi::spi_iface>>(m, "spi_iface")
         .def("transfer24_8", &mpm::spi::spi_iface::transfer24_8);
 }
diff --git a/mpm/include/mpm/types/types_python.hpp b/mpm/include/mpm/types/types_python.hpp
index d523c2065..b934605ad 100644
--- a/mpm/include/mpm/types/types_python.hpp
+++ b/mpm/include/mpm/types/types_python.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2017 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -11,39 +12,36 @@
 #include "mmap_regs_iface.hpp"
 #include "regs_iface.hpp"
 
-void export_types()
+void export_types(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("types")
     using namespace mpm::types;
-    bp::class_<lockable, boost::noncopyable, std::shared_ptr<lockable>>(
-        "lockable", bp::no_init)
+    auto m = top_module.def_submodule("types");
+
+    py::class_<lockable, std::shared_ptr<lockable>>(m, "lockable")
         .def("lock", &lockable::lock)
         .def("unlock", &lockable::unlock);
 
-    bp::class_<regs_iface, boost::noncopyable, std::shared_ptr<regs_iface>>(
-        "regs_iface", bp::no_init)
+    py::class_<regs_iface, std::shared_ptr<regs_iface>>(m, "regs_iface")
         .def("peek8", &regs_iface::peek8)
         .def("poke8", &regs_iface::poke8)
         .def("peek16", &regs_iface::peek16)
         .def("poke16", &regs_iface::poke16);
 
-    bp::class_<log_buf, boost::noncopyable, std::shared_ptr<log_buf>>(
-        "log_buf", bp::no_init)
-        .def("make_singleton", &log_buf::make_singleton)
-        .staticmethod("make_singleton")
+    py::class_<log_buf, std::shared_ptr<log_buf>>(m, "log_buf")
+        .def_static("make_singleton", &log_buf::make_singleton)
         .def("set_notify_callback",
-            +[](log_buf& self, boost::python::object object) {
+            +[](log_buf& self, py::object object) {
                 self.set_notify_callback(object);
             })
-        .def("pop", +[](log_buf& self) {
+        .def("pop", [](log_buf& self) {
             auto log_msg = self.pop();
-            return bp::make_tuple(static_cast<int>(std::get<0>(log_msg)),
+            return py::make_tuple(static_cast<int>(std::get<0>(log_msg)),
                 std::get<1>(log_msg),
                 std::get<2>(log_msg));
         });
 
-    bp::class_<mmap_regs_iface, boost::noncopyable, std::shared_ptr<mmap_regs_iface>>(
-        "mmap_regs_iface", bp::init<std::string, size_t, size_t, bool, bool>())
+    py::class_<mmap_regs_iface, std::shared_ptr<mmap_regs_iface>>(m, "mmap_regs_iface")
+        .def(py::init<std::string, size_t, size_t, bool, bool>())
         .def("open", &mmap_regs_iface::open)
         .def("close", &mmap_regs_iface::close)
         .def("peek32", &mmap_regs_iface::peek32)
diff --git a/mpm/include/mpm/xbar_iface.hpp b/mpm/include/mpm/xbar_iface.hpp
index c76aed640..bf4399593 100644
--- a/mpm/include/mpm/xbar_iface.hpp
+++ b/mpm/include/mpm/xbar_iface.hpp
@@ -1,5 +1,6 @@
 //
 // Copyright 2017 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
@@ -47,13 +48,12 @@ private:
 
 
 #ifdef LIBMPM_PYTHON
-void export_xbar()
+void export_xbar(py::module& top_module)
 {
-    LIBMPM_BOOST_PREAMBLE("xbar")
-    bp::class_<mpm::xbar_iface, boost::noncopyable, std::shared_ptr<mpm::xbar_iface>>(
-        "xbar", bp::no_init)
-        .def("make", &mpm::xbar_iface::make)
-        .staticmethod("make")
+    auto m = top_module.def_submodule("xbar");
+
+    py::class_<mpm::xbar_iface, std::shared_ptr<mpm::xbar_iface>>(m, "xbar")
+        .def(py::init(&mpm::xbar_iface::make))
         .def("set_route", &mpm::xbar_iface::set_route)
         .def("del_route", &mpm::xbar_iface::del_route);
 }
diff --git a/mpm/python/CMakeLists.txt b/mpm/python/CMakeLists.txt
index 84cff3e54..c78dc60b1 100644
--- a/mpm/python/CMakeLists.txt
+++ b/mpm/python/CMakeLists.txt
@@ -19,8 +19,9 @@ target_include_directories(pyusrp_periphs PUBLIC
     ${CMAKE_SOURCE_DIR}/lib/
     ${UHD_HOST_ROOT}/lib/usrp/common
     ${UHD_HOST_ROOT}/lib/usrp/common/ad9361_driver
+    ${UHD_HOST_ROOT}/lib/deps/pybind11/include
 )
-target_link_libraries(pyusrp_periphs ${Boost_PYTHON_LIBRARY} ${Boost_LIBRARIES} usrp-periphs)
+target_link_libraries(pyusrp_periphs ${Boost_LIBRARIES} usrp-periphs)
 add_custom_command(TARGET pyusrp_periphs POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/libpyusrp_periphs.so ${CMAKE_CURRENT_BINARY_DIR}/usrp_mpm/libpyusrp_periphs.so)
 
 set(USRP_MPM_FILES "")
diff --git a/mpm/python/pyusrp_periphs/converters.hpp b/mpm/python/pyusrp_periphs/converters.hpp
deleted file mode 100644
index 849e8b90e..000000000
--- a/mpm/python/pyusrp_periphs/converters.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//
-// Copyright 2017 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-#pragma once
-
-#include <boost/python.hpp>
-#include <boost/python/stl_iterator.hpp>
-#include <string>
-#include <vector>
-
-namespace bp = boost::python;
-
-template <typename MapType> struct map_to_python_dict
-{
-    static PyObject* convert(MapType const& input_map)
-    {
-        bp::dict py_dict;
-        for (const auto& element : input_map) {
-            py_dict[element.first] = element.second;
-        }
-        return bp::incref(py_dict.ptr());
-    }
-};
-
-template <typename Container> struct iterable_to_python_list
-{
-    static PyObject* convert(Container const& input)
-    {
-        bp::list py_list;
-        for (const auto& element : input) {
-            py_list.append(element);
-        }
-        return bp::incref(py_list.ptr());
-    }
-};
-
-// Converter for std::vector / std::list arguments from python iterables
-struct iterable_converter
-{
-    template <typename Container> iterable_converter& from_python()
-    {
-        bp::converter::registry::push_back(&iterable_converter::convertible,
-            &iterable_converter::construct<Container>,
-            bp::type_id<Container>());
-        return *this;
-    }
-
-    static void* convertible(PyObject* object)
-    {
-        return PyObject_GetIter(object) ? object : NULL;
-    }
-
-    template <typename Container>
-    static void construct(
-        PyObject* object, bp::converter::rvalue_from_python_stage1_data* data)
-    {
-        // Object is a borrowed reference, so create a handle indicting it is
-        // borrowed for proper reference counting.
-        bp::handle<> handle(bp::borrowed(object));
-
-        // Obtain a handle to the memory block that the converter has allocated
-        // for the C++ type.
-        typedef bp::converter::rvalue_from_python_storage<Container> storage_type;
-        void* storage = reinterpret_cast<storage_type*>(data)->storage.bytes;
-
-        typedef bp::stl_input_iterator<typename Container::value_type> iterator;
-
-        // Allocate the C++ type into the converter's memory block, and assign
-        // its handle to the converter's convertible variable.  The C++
-        // container is populated by passing the begin and end iterators of
-        // the python object to the container's constructor.
-        new (storage) Container(iterator(bp::object(handle)), // begin
-            iterator()); // end
-        data->convertible = storage;
-    }
-};
-
-void export_converter()
-{
-    // LIBMPM_BOOST_PREAMBLE("helper")
-    bp::to_python_converter<std::vector<std::string>,
-        iterable_to_python_list<std::vector<std::string>>,
-        false>();
-}
diff --git a/mpm/python/pyusrp_periphs/e320/pyusrp_periphs.cpp b/mpm/python/pyusrp_periphs/e320/pyusrp_periphs.cpp
index 97ccfc864..74a3647db 100644
--- a/mpm/python/pyusrp_periphs/e320/pyusrp_periphs.cpp
+++ b/mpm/python/pyusrp_periphs/e320/pyusrp_periphs.cpp
@@ -1,38 +1,30 @@
 //
 // Copyright 2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-// include hackery to only include boost python and define the macro here
-#include <boost/python.hpp>
+#include <pybind11/pybind11.h>
+namespace py = pybind11;
 #define LIBMPM_PYTHON
-#define LIBMPM_BOOST_PREAMBLE(module)                                                 \
-    /* Register submodule types */                                                    \
-    namespace bp = boost::python;                                                     \
-    bp::object py_module(                                                             \
-        bp::handle<>(bp::borrowed(PyImport_AddModule("libpyusrp_periphs." module)))); \
-    bp::scope().attr(module) = py_module;                                             \
-    bp::scope io_scope       = py_module;
 
-#include "../converters.hpp"
+// Allow boost::shared_ptr<T> to be a holder class of an object (PyBind11
+// supports std::shared_ptr and std::unique_ptr out of the box)
+#include <boost/shared_ptr.hpp>
+PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr<T>);
+
 #include <mpm/ad9361/ad9361_ctrl.hpp>
 #include <mpm/dboards/neon_manager.hpp>
 #include <mpm/spi/spi_python.hpp>
 #include <mpm/types/types_python.hpp>
 #include <mpm/xbar_iface.hpp>
-#include <boost/noncopyable.hpp>
-
-namespace bp = boost::python;
 
-BOOST_PYTHON_MODULE(libpyusrp_periphs)
+PYBIND11_MODULE(libpyusrp_periphs, m)
 {
-    bp::object package       = bp::scope();
-    package.attr("__path__") = "libpyusrp_periphs";
-    export_converter();
-    export_types();
-    export_spi();
-    export_xbar();
-    export_catalina();
-    export_neon();
+    export_types(m);
+    export_spi(m);
+    export_xbar(m);
+    export_catalina(m);
+    export_neon(m);
 }
diff --git a/mpm/python/pyusrp_periphs/n3xx/pyusrp_periphs.cpp b/mpm/python/pyusrp_periphs/n3xx/pyusrp_periphs.cpp
index 85851677f..d4c430f72 100644
--- a/mpm/python/pyusrp_periphs/n3xx/pyusrp_periphs.cpp
+++ b/mpm/python/pyusrp_periphs/n3xx/pyusrp_periphs.cpp
@@ -1,67 +1,32 @@
 //
 // Copyright 2017 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-// include hackery to only include boost python and define the macro here
-#include <boost/python.hpp>
+#include <pybind11/pybind11.h>
+namespace py = pybind11;
 #define LIBMPM_PYTHON
-#define LIBMPM_BOOST_PREAMBLE(module)                                                 \
-    /* Register submodule types */                                                    \
-    namespace bp = boost::python;                                                     \
-    bp::object py_module(                                                             \
-        bp::handle<>(bp::borrowed(PyImport_AddModule("libpyusrp_periphs." module)))); \
-    bp::scope().attr(module) = py_module;                                             \
-    bp::scope io_scope       = py_module;
 
-//! RAII-style GIL release method
-//
-// To release the GIL using this method, simply instantiate this class in the
-// scope that needs to release the GIL.
-//
-// Note that using this class assumes that threads have already been
-// initialized. See also https://docs.python.org/3.5/c-api/init.html for more
-// documentation on Python initialization and threads.
-class scoped_gil_release
-{
-public:
-    inline scoped_gil_release()
-    {
-        _thread_state = PyEval_SaveThread();
-    }
+// Allow boost::shared_ptr<T> to be a holder class of an object (PyBind11
+// supports std::shared_ptr and std::unique_ptr out of the box)
+#include <boost/shared_ptr.hpp>
+PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr<T>);
 
-    inline ~scoped_gil_release()
-    {
-        PyEval_RestoreThread(_thread_state);
-        _thread_state = nullptr;
-    }
-
-private:
-    PyThreadState* _thread_state;
-};
-
-//#include "types.hpp"
-#include "../converters.hpp"
 #include <mpm/ad937x/ad937x_ctrl.hpp>
 #include <mpm/dboards/magnesium_manager.hpp>
 #include <mpm/i2c/i2c_python.hpp>
 #include <mpm/spi/spi_python.hpp>
 #include <mpm/types/types_python.hpp>
 #include <mpm/xbar_iface.hpp>
-#include <boost/noncopyable.hpp>
-
-namespace bp = boost::python;
 
-BOOST_PYTHON_MODULE(libpyusrp_periphs)
+PYBIND11_MODULE(libpyusrp_periphs, m)
 {
-    bp::object package       = bp::scope();
-    package.attr("__path__") = "libpyusrp_periphs";
-    export_converter();
-    export_types();
-    export_spi();
-    export_i2c();
-    export_mykonos();
-    export_xbar();
-    export_magnesium();
+    export_types(m);
+    export_spi(m);
+    export_i2c(m);
+    export_mykonos(m);
+    export_xbar(m);
+    export_magnesium(m);
 }
diff --git a/mpm/python/usrp_mpm/xports/xportmgr_liberio.py b/mpm/python/usrp_mpm/xports/xportmgr_liberio.py
index d5c0d2e97..b035e64fe 100644
--- a/mpm/python/usrp_mpm/xports/xportmgr_liberio.py
+++ b/mpm/python/usrp_mpm/xports/xportmgr_liberio.py
@@ -83,7 +83,7 @@ class XportMgrLiberio(object):
     def commit_xport(self, sid, xport_info):
         " Commit liberio transport "
         chan = int(xport_info['dma_chan'])
-        xbar_iface = lib.xbar.xbar.make(self.xbar_dev)
+        xbar_iface = lib.xbar.xbar(self.xbar_dev)
         xbar_iface.set_route(sid.src_addr, self.xbar_port)
         self._dma_dispatcher.set_route(sid.reversed(), chan)
         self.log.trace("Liberio transport successfully committed!")
diff --git a/mpm/python/usrp_mpm/xports/xportmgr_udp.py b/mpm/python/usrp_mpm/xports/xportmgr_udp.py
index f8fcc6ede..17762bb76 100644
--- a/mpm/python/usrp_mpm/xports/xportmgr_udp.py
+++ b/mpm/python/usrp_mpm/xports/xportmgr_udp.py
@@ -325,7 +325,7 @@ class XportMgrUDP(object):
         xbar_port = self.iface_config[eth_iface]['xbar_port']
         self.log.trace("Using Ethernet interface %s, crossbar port %d",
                        eth_iface, xbar_port)
-        xbar_iface = lib.xbar.xbar.make(self.get_xbar_dev(eth_iface))
+        xbar_iface = lib.xbar.xbar(self.get_xbar_dev(eth_iface))
         xbar_iface.set_route(sid.src_addr, xbar_port)
         self._eth_dispatchers[eth_iface].set_route(
             sid.reversed(), sender_addr, sender_port)