python: Separating exposed Python data structures

- Separating exposed Python data structures into logical sections
- Exposes all of the multi_usrp API
- Adds a layer of Python for documentation and adding helper methods
- Adds improvements and fixes to the MultiUSRP object
- Includes additional exposed data structures (like time_spec_t, etc.)
- Add code to release the Python GIL during long C++ calls

13 files changed, 1198 insertions, 0 deletions

diff --git a/host/lib/stream_python.hpp b/host/lib/stream_python.hpp
new file mode 100644
index 000000000..c283d34a6
--- /dev/null
+++ b/host/lib/stream_python.hpp
@@ -0,0 +1,199 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_STREAM_PYTHON_HPP
+#define INCLUDED_UHD_STREAM_PYTHON_HPP
+
+#include "utils/gil_release_python.hpp"
+#include <uhd/stream.hpp>
+#include <uhd/types/metadata.hpp>
+
+#include <boost/format.hpp>
+
+static size_t wrap_recv(uhd::rx_streamer *rx_stream,
+                        bp::object &np_array,
+                        bp::object &metadata)
+{
+    // Release the GIL
+    scoped_gil_release gil_release;
+
+    // Extract the metadata
+    bp::extract<uhd::rx_metadata_t&> get_metadata(metadata);
+    if (not get_metadata.check())
+    {
+        return 0;
+    }
+
+    // Get a numpy array object from given python object
+    // No sanity checking possible!
+    PyObject* array_obj = PyArray_FROM_OF(np_array.ptr(), NPY_ARRAY_CARRAY);
+    PyArrayObject* array_type_obj = reinterpret_cast<PyArrayObject*>(array_obj);
+
+    // Get dimensions of the numpy array
+    const size_t dims = PyArray_NDIM(array_type_obj);
+    const npy_intp* shape = PyArray_SHAPE(array_type_obj);
+
+    // How many bytes to jump to get to the next element of this stride
+    // (next row)
+    const npy_intp* strides = PyArray_STRIDES(array_type_obj);
+    const size_t channels = rx_stream->get_num_channels();
+
+    // Check if numpy array sizes are okay
+    if (((channels > 1) && (dims != 2))
+     or ((size_t) shape[0] < channels))
+    {
+        // Manually decrement the ref count
+        Py_DECREF(array_obj);
+        // If we don't have a 2D NumPy array, assume we have a 1D array
+        size_t input_channels = (dims != 2) ? 1 : shape[0];
+        throw uhd::runtime_error(str(boost::format(
+            "Number of RX channels (%d) does not match the dimensions of the data array (%d)")
+            % channels % input_channels));
+    }
+
+    // Get a pointer to the storage
+    std::vector<void*> channel_storage;
+    char* data = PyArray_BYTES(array_type_obj);
+    for (size_t i = 0; i < channels; ++i)
+    {
+        channel_storage.push_back((void*)(data + i * strides[0]));
+    }
+
+    // Get data buffer and size of the array
+    size_t nsamps_per_buff;
+    if (dims > 1) {
+        nsamps_per_buff = (size_t) shape[1];
+    } else {
+        nsamps_per_buff = PyArray_SIZE(array_type_obj);
+    }
+
+    // Call the real recv()
+    const size_t result = rx_stream->recv(
+        channel_storage,
+        nsamps_per_buff,
+        get_metadata()
+    );
+
+    // Manually decrement the ref count
+    Py_DECREF(array_obj);
+    return result;
+}
+
+static size_t wrap_send(uhd::tx_streamer *tx_stream,
+                        bp::object &np_array,
+                        bp::object &metadata)
+{
+    // Release the GIL
+    scoped_gil_release gil_release;
+
+    // Extract the metadata
+    bp::extract<uhd::tx_metadata_t&> get_metadata(metadata);
+    // TODO: throw an error here?
+    if (not get_metadata.check())
+    {
+        return 0;
+    }
+
+    // Get a numpy array object from given python object
+    // No sanity checking possible!
+    // Note: this increases the ref count, which we'll need to manually decrease at the end
+    PyObject* array_obj = PyArray_FROM_OF(np_array.ptr(),NPY_ARRAY_CARRAY);
+    PyArrayObject* array_type_obj = reinterpret_cast<PyArrayObject*>(array_obj);
+
+    // Get dimensions of the numpy array
+    const size_t dims = PyArray_NDIM(array_type_obj);
+    const npy_intp* shape = PyArray_SHAPE(array_type_obj);
+
+    // How many bytes to jump to get to the next element of the stride
+    // (next row)
+    const npy_intp* strides = PyArray_STRIDES(array_type_obj);
+    const size_t channels = tx_stream->get_num_channels();
+
+    // Check if numpy array sizes are ok
+    if (((channels > 1) && (dims != 2))
+     or ((size_t) shape[0] < channels))
+    {
+        // Manually decrement the ref count
+        Py_DECREF(array_obj);
+        // If we don't have a 2D NumPy array, assume we have a 1D array
+        size_t input_channels = (dims != 2) ? 1 : shape[0];
+        throw uhd::runtime_error(str(boost::format(
+            "Number of TX channels (%d) does not match the dimensions of the data array (%d)")
+            % channels % input_channels));
+    }
+
+    // Get a pointer to the storage
+    std::vector<void*> channel_storage;
+    char* data = PyArray_BYTES(array_type_obj);
+    for (size_t i = 0; i < channels; ++i)
+    {
+        channel_storage.push_back((void*)(data + i * strides[0]));
+    }
+
+    // Get data buffer and size of the array
+    size_t nsamps_per_buff = (dims > 1) ? (size_t) shape[1] : PyArray_SIZE(array_type_obj);
+
+    // Call the real recv()
+    const size_t result = tx_stream->send(
+        channel_storage,
+        nsamps_per_buff,
+        get_metadata()
+    );
+
+    // Manually decrement the ref count
+    Py_DECREF(array_obj);
+    return result;
+}
+
+void export_stream()
+{
+    using stream_args_t = uhd::stream_args_t;
+    using rx_streamer   = uhd::rx_streamer;
+    using tx_streamer   = uhd::tx_streamer;
+    using async_metadata_t = uhd::async_metadata_t;
+
+    bp::class_<stream_args_t>
+        ("stream_args", bp::init<const std::string&, const std::string&>())
+
+        // Properties
+        .def_readwrite("cpu_format", &stream_args_t::cpu_format)
+        .def_readwrite("otw_format", &stream_args_t::otw_format)
+        .def_readwrite("args"      , &stream_args_t::args      )
+        .def_readwrite("channels"  , &stream_args_t::channels  )
+        ;
+
+    bp::class_<
+        rx_streamer,
+        boost::shared_ptr<rx_streamer>,
+        boost::noncopyable>("rx_streamer", "See: uhd::rx_streamer", bp::no_init)
+
+        // Methods
+        .def("recv"             , &wrap_recv                          )
+        .def("get_num_channels" , &uhd::rx_streamer::get_num_channels )
+        .def("get_max_num_samps", &uhd::rx_streamer::get_max_num_samps)
+        .def("issue_stream_cmd" , &uhd::rx_streamer::issue_stream_cmd )
+        ;
+
+    bp::class_<
+        tx_streamer,
+        boost::shared_ptr<tx_streamer>,
+        boost::noncopyable>("tx_streamer", "See: uhd::tx_streamer", bp::no_init)
+
+        // Methods
+        .def("send"             , &wrap_send                     )
+        .def("get_num_channels" , &tx_streamer::get_num_channels )
+        .def("get_max_num_samps", &tx_streamer::get_max_num_samps)
+        // FIXME: the timeout isn't actually an optional argument right now in Python
+        .def("recv_async_msg"   , +[](tx_streamer& self, async_metadata_t& metadata, double timeout = 0.1) {
+            // Release the GIL
+            scoped_gil_release gil_release;
+
+            return self.recv_async_msg(metadata, timeout);
+        })
+        ;
+}
+
+#endif /* INCLUDED_UHD_STREAM_PYTHON_HPP */
diff --git a/host/lib/types/filters_python.hpp b/host/lib/types/filters_python.hpp
new file mode 100644
index 000000000..ff5785345
--- /dev/null
+++ b/host/lib/types/filters_python.hpp
@@ -0,0 +1,60 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_FILTERS_PYTHON_HPP
+#define INCLUDED_UHD_FILTERS_PYTHON_HPP
+
+#include <uhd/types/filters.hpp>
+
+void export_filters()
+{
+    using filter_info_base   = uhd::filter_info_base;
+    using filter_info_type   = filter_info_base::filter_type;
+    using analog_filter_base = uhd::analog_filter_base;
+    using analog_filter_lp   = uhd::analog_filter_lp;
+
+    bp::enum_<filter_info_type>("filter_type")
+        .value("analog_low_pass" , filter_info_base::ANALOG_LOW_PASS )
+        .value("analog_band_pass", filter_info_base::ANALOG_BAND_PASS)
+        .value("digital_i16"     , filter_info_base::DIGITAL_I16     )
+        .value("digital_fir_i16" , filter_info_base::DIGITAL_FIR_I16 )
+        ;
+
+    bp::class_<
+        filter_info_base,
+        boost::shared_ptr<filter_info_base> >
+        ("filter_info_base", bp::init<filter_info_type, bool, size_t>())
+
+        // Methods
+        .def("is_bypassed", &filter_info_base::is_bypassed )
+        .def("get_type"   , &filter_info_base::get_type    )
+        .def("__str__"    , &filter_info_base::to_pp_string)
+        ;
+
+    bp::class_<
+        analog_filter_base,
+        boost::shared_ptr<analog_filter_base>,
+        bp::bases<filter_info_base> >
+        ("analog_filter_base", bp::init<filter_info_type, bool, size_t, std::string>())
+
+        // Methods
+        .def("get_analog_type", &analog_filter_base::get_analog_type, bp::return_value_policy<bp::copy_const_reference>())
+    ;
+
+    bp::class_<
+        analog_filter_lp,
+        boost::shared_ptr<analog_filter_lp>,
+        bp::bases<analog_filter_base> >
+        ("analog_filter_lp", bp::init<filter_info_type, bool, size_t, const std::string, double, double>())
+
+        // Methods
+        .def("get_cutoff" , &analog_filter_lp::get_cutoff )
+        .def("get_rolloff", &analog_filter_lp::get_rolloff)
+        .def("set_cutoff" , &analog_filter_lp::set_cutoff )
+        ;
+}
+
+#endif /* INCLUDED_UHD_FILTERS_PYTHON_HPP */
diff --git a/host/lib/types/metadata_python.hpp b/host/lib/types/metadata_python.hpp
new file mode 100644
index 000000000..876756d73
--- /dev/null
+++ b/host/lib/types/metadata_python.hpp
@@ -0,0 +1,111 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_METADATA_PYTHON_HPP
+#define INCLUDED_UHD_METADATA_PYTHON_HPP
+
+#include <uhd/types/ranges.hpp>
+
+void export_metadata()
+{
+    using range_t       = uhd::range_t;
+    using meta_range_t  = uhd::meta_range_t;
+    using rx_metadata_t = uhd::rx_metadata_t;
+    using error_code_t  = rx_metadata_t::error_code_t;
+    using tx_metadata_t = uhd::tx_metadata_t;
+    using async_metadata_t = uhd::async_metadata_t;
+    using event_code_t = async_metadata_t::event_code_t;
+
+    bp::enum_<error_code_t>("rx_metadata_error_code")
+        .value("none"        , error_code_t::ERROR_CODE_NONE        )
+        .value("timeout"     , error_code_t::ERROR_CODE_TIMEOUT     )
+        .value("late"        , error_code_t::ERROR_CODE_LATE_COMMAND)
+        .value("broken_chain", error_code_t::ERROR_CODE_BROKEN_CHAIN)
+        .value("overflow"    , error_code_t::ERROR_CODE_OVERFLOW    )
+        .value("alignment"   , error_code_t::ERROR_CODE_ALIGNMENT   )
+        .value("bad_packet"  , error_code_t::ERROR_CODE_BAD_PACKET  )
+        ;
+
+    bp::class_<range_t>
+        ("range", bp::init<double>())
+
+        // Constructors
+        .def(bp::init<double, double, double>())
+
+        // Methods
+        .def("start"  , &range_t::start       )
+        .def("stop"   , &range_t::stop        )
+        .def("step"   , &range_t::step        )
+        .def("__str__", &range_t::to_pp_string)
+        ;
+
+    bp::class_<std::vector<range_t> >("range_vector")
+        .def(bp::vector_indexing_suite<std::vector<range_t> >());
+
+    bp::class_<meta_range_t, bp::bases<std::vector<range_t> > >
+        ("meta_range", bp::init<>())
+
+        // Constructors
+        .def(bp::init<double, double, double>())
+
+        // Methods
+        .def("start"  , &meta_range_t::start       )
+        .def("stop"   , &meta_range_t::stop        )
+        .def("step"   , &meta_range_t::step        )
+        .def("clip"   , &meta_range_t::clip        )
+        .def("__str__", &meta_range_t::to_pp_string)
+        ;
+
+    bp::class_<rx_metadata_t>("rx_metadata", bp::init<>())
+
+        // Methods
+        .def("reset"       , &rx_metadata_t::reset       )
+        .def("to_pp_string", &rx_metadata_t::to_pp_string)
+        .def("strerror"    , &rx_metadata_t::strerror    )
+        .def("__str__"     , &rx_metadata_t::to_pp_string, bp::args("compact") = false)
+
+        // Properties
+        .def_readonly("has_time_spec"  , &rx_metadata_t::has_time_spec  )
+        .def_readonly("time_spec"      , &rx_metadata_t::time_spec      )
+        .def_readonly("more_fragments" , &rx_metadata_t::more_fragments )
+        .def_readonly("start_of_burst" , &rx_metadata_t::start_of_burst )
+        .def_readonly("end_of_burst"   , &rx_metadata_t::end_of_burst   )
+        .def_readonly("error_code"     , &rx_metadata_t::error_code     )
+        .def_readonly("out_of_sequence", &rx_metadata_t::out_of_sequence)
+        ;
+
+    bp::class_<tx_metadata_t>("tx_metadata", bp::init<>())
+
+        // Properties
+        .def_readwrite("has_time_spec" , &tx_metadata_t::has_time_spec )
+        .def_readwrite("time_spec"     , &tx_metadata_t::time_spec     )
+        .def_readwrite("start_of_burst", &tx_metadata_t::start_of_burst)
+        .def_readwrite("end_of_burst"  , &tx_metadata_t::end_of_burst  )
+        ;
+
+    bp::enum_<event_code_t>("tx_metadata_event_code")
+        .value("burst_ack"          , event_code_t::EVENT_CODE_BURST_ACK          )
+        .value("underflow"          , event_code_t::EVENT_CODE_UNDERFLOW          )
+        .value("seq_error"          , event_code_t::EVENT_CODE_SEQ_ERROR          )
+        .value("time_error"         , event_code_t::EVENT_CODE_TIME_ERROR         )
+        .value("underflow_in_packet", event_code_t::EVENT_CODE_UNDERFLOW_IN_PACKET)
+        .value("seq_error_in_packet", event_code_t::EVENT_CODE_SEQ_ERROR_IN_BURST )
+        .value("user_payload"       , event_code_t::EVENT_CODE_USER_PAYLOAD       )
+        ;
+
+    bp::class_<async_metadata_t>("async_metadata", bp::init<>())
+
+        // Properties
+        .def_readwrite("channel"      , &async_metadata_t::channel      )
+        .def_readwrite("has_time_spec", &async_metadata_t::has_time_spec)
+        .def_readwrite("time_spec"    , &async_metadata_t::time_spec    )
+        .def_readwrite("event_code"   , &async_metadata_t::event_code   )
+        // TODO: Expose user payloads
+        //.def_readwrite("user_payload" , &async_metadata_t::user_payload )
+        ;
+}
+
+#endif /* INCLUDED_UHD_METADATA_PYTHON_HPP */
diff --git a/host/lib/types/sensors_python.hpp b/host/lib/types/sensors_python.hpp
new file mode 100644
index 000000000..8fd9da4e3
--- /dev/null
+++ b/host/lib/types/sensors_python.hpp
@@ -0,0 +1,46 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_SENSORS_PYTHON_HPP
+#define INCLUDED_UHD_SENSORS_PYTHON_HPP
+
+#include <uhd/types/sensors.hpp>
+
+void export_sensors()
+{
+    using sensor_value_t = uhd::sensor_value_t;
+    using data_type_t    = sensor_value_t::data_type_t;
+
+    bp::enum_<data_type_t>("data_type")
+        .value("b", data_type_t::BOOLEAN)
+        .value("i", data_type_t::INTEGER)
+        .value("r", data_type_t::REALNUM)
+        .value("s", data_type_t::STRING )
+        ;
+
+    bp::class_<sensor_value_t>
+        ("sensor_value", bp::init<const std::string&, bool, const std::string&, const std::string&>())
+
+        // Constructors
+        .def(bp::init<const std::string&, signed, const std::string&, const std::string&>())
+        .def(bp::init<const std::string&, double, const std::string&, const std::string&>())
+        .def(bp::init<const std::string&, const std::string&        , const std::string&>())
+
+        // Methods
+        .def("to_bool", &sensor_value_t::to_bool     )
+        .def("to_int",  &sensor_value_t::to_int      )
+        .def("to_real", &sensor_value_t::to_real     )
+        .def("__str__", &sensor_value_t::to_pp_string)
+
+        // Properties
+        .add_property("name",  &sensor_value_t::name )
+        .add_property("value", &sensor_value_t::value)
+        .add_property("unit",  &sensor_value_t::unit )
+        .add_property("type",  &sensor_value_t::type )
+        ;
+}
+
+#endif /* INCLUDED_UHD_SENSORS_PYTHON_HPP */
diff --git a/host/lib/types/serial_python.hpp b/host/lib/types/serial_python.hpp
new file mode 100644
index 000000000..441bcc4d7
--- /dev/null
+++ b/host/lib/types/serial_python.hpp
@@ -0,0 +1,32 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_SERIAL_PYTHON_HPP
+#define INCLUDED_UHD_SERIAL_PYTHON_HPP
+
+#include <uhd/types/serial.hpp>
+
+void export_spi_config()
+{
+    using spi_config_t = uhd::spi_config_t;
+    using spi_edge_t   = spi_config_t::edge_t;
+
+    bp::enum_<spi_edge_t>("spi_edge")
+        .value("EDGE_RISE" , spi_edge_t::EDGE_RISE)
+        .value("EDGE_FALL",  spi_edge_t::EDGE_FALL)
+        ;
+
+    bp::class_<spi_config_t>("spi_config", bp::init<spi_edge_t>())
+
+        // Properties
+        .add_property("mosi_edge"         , &spi_config_t::mosi_edge         )
+        .add_property("miso_edge"         , &spi_config_t::miso_edge         )
+        .add_property("use_custom_divider", &spi_config_t::use_custom_divider)
+        .add_property("divider"           , &spi_config_t::divider           )
+        ;
+}
+
+#endif /* INCLUDED_UHD_SERIAL_PYTHON_HPP */
diff --git a/host/lib/types/time_spec_python.hpp b/host/lib/types/time_spec_python.hpp
new file mode 100644
index 000000000..f411af0b0
--- /dev/null
+++ b/host/lib/types/time_spec_python.hpp
@@ -0,0 +1,35 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_TIME_SPEC_PYTHON_HPP
+#define INCLUDED_UHD_TIME_SPEC_PYTHON_HPP
+
+#include <uhd/types/time_spec.hpp>
+
+void export_time_spec()
+{
+    using time_spec_t = uhd::time_spec_t;
+
+    bp::class_<time_spec_t>("time_spec", bp::init<double>())
+
+        // Methods
+        .def("from_ticks"     , &time_spec_t::from_ticks     )
+        .staticmethod("from_ticks"                           )
+
+        .def("get_tick_count" , &time_spec_t::get_tick_count )
+        .def("to_ticks"       , &time_spec_t::to_ticks       )
+        .def("get_real_secs"  , &time_spec_t::get_real_secs  )
+        .def("get_frac_secs"  , &time_spec_t::get_frac_secs  )
+
+        .def(bp::self += time_spec_t())
+        .def(bp::self += double())
+        .def(bp::self + double())
+        .def(bp::self + time_spec_t())
+        .def(bp::self -= time_spec_t())
+        ;
+}
+
+#endif /* INCLUDED_UHD_TIME_SPEC_PYTHON_HPP */
diff --git a/host/lib/types/tune_python.hpp b/host/lib/types/tune_python.hpp
new file mode 100644
index 000000000..532cc2f8e
--- /dev/null
+++ b/host/lib/types/tune_python.hpp
@@ -0,0 +1,39 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_TUNE_PYTHON_HPP
+#define INCLUDED_UHD_TUNE_PYTHON_HPP
+
+#include <uhd/types/tune_result.hpp>
+#include <uhd/types/tune_request.hpp>
+
+void export_tune()
+{
+    using tune_request_t = uhd::tune_request_t;
+    using tune_result_t  = uhd::tune_result_t;
+    using policy_t       = tune_request_t::policy_t;
+
+    bp::enum_<policy_t>("tune_request_policy")
+        .value("none",   tune_request_t::POLICY_NONE  )
+        .value("auto",   tune_request_t::POLICY_AUTO  )
+        .value("manual", tune_request_t::POLICY_MANUAL)
+        ;
+
+    bp::class_<tune_request_t>("tune_request", bp::init<double>())
+        .def(bp::init<double, double>())
+        .def_readwrite("target_freq"    , &tune_request_t::target_freq    )
+        .def_readwrite("rf_freq_policy" , &tune_request_t::rf_freq_policy )
+        .def_readwrite("dsp_freq_policy", &tune_request_t::dsp_freq_policy)
+        .def_readwrite("rf_freq"        , &tune_request_t::rf_freq        )
+        .def_readwrite("dsp_freq"       , &tune_request_t::dsp_freq       )
+        .def_readwrite("args"           , &tune_request_t::args           )
+        ;
+
+    bp::class_<tune_result_t>("tune_result", bp::init<>())
+        ;
+}
+
+#endif /* INCLUDED_UHD_TUNE_PYTHON_HPP */
diff --git a/host/lib/types/types_python.hpp b/host/lib/types/types_python.hpp
new file mode 100644
index 000000000..4cda00d0d
--- /dev/null
+++ b/host/lib/types/types_python.hpp
@@ -0,0 +1,33 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_TYPES_PYTHON_HPP
+#define INCLUDED_UHD_TYPES_PYTHON_HPP
+
+#include <uhd/types/stream_cmd.hpp>
+
+void export_types()
+{
+    using stream_cmd_t  = uhd::stream_cmd_t;
+    using stream_mode_t = stream_cmd_t::stream_mode_t;
+
+    bp::enum_<stream_mode_t>("stream_mode")
+        .value("start_cont", stream_cmd_t::STREAM_MODE_START_CONTINUOUS  )
+        .value("stop_cont" , stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS   )
+        .value("num_done"  , stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE)
+        .value("num_more"  , stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_MORE)
+        ;
+
+    bp::class_<stream_cmd_t>("stream_cmd", bp::init<stream_cmd_t::stream_mode_t>())
+
+        // Properties
+        .def_readwrite("num_samps" , &stream_cmd_t::num_samps )
+        .def_readwrite("time_spec" , &stream_cmd_t::time_spec )
+        .def_readwrite("stream_now", &stream_cmd_t::stream_now)
+        ;
+}
+
+#endif /* INCLUDED_UHD_TYPES_PYTHON_HPP */
diff --git a/host/lib/usrp/dboard_iface_python.hpp b/host/lib/usrp/dboard_iface_python.hpp
new file mode 100644
index 000000000..df86fdcc8
--- /dev/null
+++ b/host/lib/usrp/dboard_iface_python.hpp
@@ -0,0 +1,95 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_USRP_DBOARD_IFACE_PYTHON_HPP
+#define INCLUDED_UHD_USRP_DBOARD_IFACE_PYTHON_HPP
+
+#include <uhd/usrp/dboard_iface.hpp>
+#include <uhd/usrp/gpio_defs.hpp>
+#include "../include/uhdlib/usrp/gpio_defs.hpp"
+
+void export_dboard_iface()
+{
+    using dboard_iface    = uhd::usrp::dboard_iface;
+    using special_props_t = uhd::usrp::dboard_iface_special_props_t;
+    using unit_t          = dboard_iface::unit_t;
+
+    using aux_dac_t       = dboard_iface::aux_dac_t;
+    using aux_adc_t       = dboard_iface::aux_adc_t;
+
+    using gpio_atr_reg_t  = uhd::usrp::gpio_atr::gpio_atr_reg_t;
+    using gpio_atr_mode_t = uhd::usrp::gpio_atr::gpio_atr_mode_t;
+
+    bp::enum_<gpio_atr_reg_t>("gpio_atr_reg")
+        .value("ATR_REG_IDLE"       , gpio_atr_reg_t::ATR_REG_IDLE       )
+        .value("ATR_REG_TX_ONLY"    , gpio_atr_reg_t::ATR_REG_TX_ONLY    )
+        .value("ATR_REG_RX_ONLY"    , gpio_atr_reg_t::ATR_REG_RX_ONLY    )
+        .value("ATR_REG_FULL_DUPLEX", gpio_atr_reg_t::ATR_REG_FULL_DUPLEX)
+        ;
+
+    bp::enum_<gpio_atr_mode_t>("gpio_atr_mode")
+        .value("MODE_ATR" , gpio_atr_mode_t::MODE_ATR )
+        .value("MODE_GPIO", gpio_atr_mode_t::MODE_GPIO)
+        ;
+
+    bp::enum_<unit_t>("unit")
+        .value("UNIT_RX"  , unit_t::UNIT_RX  )
+        .value("UNIT_TX"  , unit_t::UNIT_TX  )
+        .value("UNIT_BOTH", unit_t::UNIT_BOTH)
+        ;
+
+    bp::enum_<aux_dac_t>("aux_dac")
+        .value("AUX_DAC_A", aux_dac_t::AUX_DAC_A)
+        .value("AUX_DAC_B", aux_dac_t::AUX_DAC_B)
+        .value("AUX_DAC_C", aux_dac_t::AUX_DAC_C)
+        .value("AUX_DAC_D", aux_dac_t::AUX_DAC_D)
+        ;
+
+    bp::enum_<aux_adc_t>("aux_adc")
+        .value("AUX_ADC_A", aux_adc_t::AUX_ADC_A)
+        .value("AUX_ADC_B", aux_adc_t::AUX_ADC_B)
+        ;
+
+    bp::class_<special_props_t>("special_props")
+
+        // Properties
+        .add_property("soft_clock_divider", &special_props_t::soft_clock_divider)
+        .add_property("mangle_i2c_addrs"  , &special_props_t::mangle_i2c_addrs  )
+        ;
+
+    bp::class_<
+        dboard_iface,
+        boost::shared_ptr<dboard_iface>,
+        boost::noncopyable>("dboard_iface", bp::no_init)
+
+        // Methods
+        .def("get_special_props", &dboard_iface::get_special_props)
+        .def("write_aux_dac"    , &dboard_iface::write_aux_dac    )
+        .def("read_aux_adc"     , &dboard_iface::read_aux_adc     )
+        .def("set_pin_ctrl"     , &dboard_iface::set_pin_ctrl     )
+        .def("get_pin_ctrl"     , &dboard_iface::get_pin_ctrl     )
+        .def("set_atr_reg"      , &dboard_iface::set_atr_reg      )
+        .def("get_atr_reg"      , &dboard_iface::get_atr_reg      )
+        .def("set_gpio_ddr"     , &dboard_iface::set_gpio_ddr     )
+        .def("get_gpio_ddr"     , &dboard_iface::get_gpio_ddr     )
+        .def("get_gpio_out"     , &dboard_iface::get_gpio_out     )
+        .def("set_gpio_out"     , &dboard_iface::set_gpio_out     )
+        .def("read_gpio"        , &dboard_iface::read_gpio        )
+        .def("write_spi"        , &dboard_iface::write_spi        )
+        .def("read_write_spi"   , &dboard_iface::read_write_spi   )
+        .def("set_clock_rate"   , &dboard_iface::set_clock_rate   )
+        .def("get_clock_rate"   , &dboard_iface::get_clock_rate   )
+        .def("get_clock_rates"  , &dboard_iface::get_clock_rates  )
+        .def("set_clock_enabled", &dboard_iface::set_clock_enabled)
+        .def("get_codec_rate"   , &dboard_iface::get_codec_rate   )
+        .def("set_fe_connection", &dboard_iface::set_fe_connection)
+        .def("get_command_time" , &dboard_iface::get_command_time )
+        .def("set_command_time" , &dboard_iface::set_command_time )
+        .def("sleep"            , &dboard_iface::sleep            )
+        ;
+}
+
+#endif /* INCLUDED_UHD_USRP_DBOARD_IFACE_PYTHON_HPP */
diff --git a/host/lib/usrp/fe_connection_python.hpp b/host/lib/usrp/fe_connection_python.hpp
new file mode 100644
index 000000000..29bba1746
--- /dev/null
+++ b/host/lib/usrp/fe_connection_python.hpp
@@ -0,0 +1,39 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_USRP_FE_CONNECTION_PYTHON_HPP
+#define INCLUDED_UHD_USRP_FE_CONNECTION_PYTHON_HPP
+
+#include <uhd/usrp/fe_connection.hpp>
+
+void export_fe_connection()
+{
+    using fe_connection_t = uhd::usrp::fe_connection_t;
+    using sampling_t      = fe_connection_t::sampling_t;
+
+    bp::enum_<sampling_t>("sampling")
+        .value("QUADRATURE", sampling_t::QUADRATURE)
+        .value("HETERODYNE", sampling_t::HETERODYNE)
+        .value("REAL"      , sampling_t::REAL      )
+        ;
+
+    bp::class_<fe_connection_t>
+        ("fe_connection", bp::init<sampling_t, bool, bool, bool, double>())
+
+        // Constructors
+        .def(bp::init<const std::string&, double>())
+
+        // Methods
+        .def("get_sampling_mode", &fe_connection_t::get_sampling_mode)
+        .def("is_iq_swapped"    , &fe_connection_t::is_iq_swapped    )
+        .def("is_i_inverted"    , &fe_connection_t::is_i_inverted    )
+        .def("is_q_inverted"    , &fe_connection_t::is_q_inverted    )
+        .def("get_if_freq"      , &fe_connection_t::get_if_freq      )
+        .def("set_if_freq"      , &fe_connection_t::set_if_freq      )
+        ;
+}
+
+#endif /* INCLUDED_UHD_USRP_FE_CONNECTION_PYTHON_HPP */
diff --git a/host/lib/usrp/multi_usrp_python.hpp b/host/lib/usrp/multi_usrp_python.hpp
new file mode 100644
index 000000000..2c1bc6b59
--- /dev/null
+++ b/host/lib/usrp/multi_usrp_python.hpp
@@ -0,0 +1,441 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_USRP_MULTI_USRP_PYTHON_HPP
+#define INCLUDED_UHD_USRP_MULTI_USRP_PYTHON_HPP
+
+#include <uhd/usrp/multi_usrp.hpp>
+
+//
+// Boost.Python needs overloaded API calls to be defined
+//
+static void set_rx_gain_0(
+    uhd::usrp::multi_usrp *multi_usrp, double gain, const std::string &name, size_t chan = 0)
+{
+    multi_usrp->set_rx_gain(gain, name, chan);
+}
+
+static void set_rx_gain_1(
+    uhd::usrp::multi_usrp *multi_usrp, double gain, size_t chan = 0)
+{
+    multi_usrp->set_rx_gain(gain, chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_gain_0, set_rx_gain_0, 3, 4);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_gain_1, set_rx_gain_1, 2, 3);
+
+static void set_tx_gain_0(
+    uhd::usrp::multi_usrp *multi_usrp, double gain, const std::string &name, size_t chan = 0)
+{
+    multi_usrp->set_tx_gain(gain, name, chan);
+}
+
+static void set_tx_gain_1(
+    uhd::usrp::multi_usrp *multi_usrp, double gain, size_t chan = 0)
+{
+    multi_usrp->set_tx_gain(gain, chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_gain_0, set_tx_gain_0, 3, 4);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_gain_1, set_tx_gain_1, 2, 3);
+
+static double get_rx_gain_0(
+    uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
+{
+    return multi_usrp->get_rx_gain(name, chan);
+}
+
+static double get_rx_gain_1(
+    uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
+{
+    return multi_usrp->get_rx_gain(chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_0, get_rx_gain_0, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_1, get_rx_gain_1, 1, 2);
+
+static double get_tx_gain_0(
+    uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
+{
+    return multi_usrp->get_tx_gain(name, chan);
+}
+
+static double get_tx_gain_1(
+    uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
+{
+    return multi_usrp->get_tx_gain(chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_0, get_tx_gain_0, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_1, get_tx_gain_1, 1, 2);
+
+static uhd::gain_range_t get_rx_gain_range_0(
+    uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
+{
+    return multi_usrp->get_rx_gain_range(name, chan);
+}
+
+static uhd::gain_range_t get_rx_gain_range_1(
+    uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
+{
+    return multi_usrp->get_rx_gain_range(chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_range_0, get_rx_gain_range_0, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_range_1, get_rx_gain_range_1, 1, 2);
+
+static uhd::gain_range_t get_tx_gain_range_0(
+    uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
+{
+    return multi_usrp->get_tx_gain_range(name, chan);
+}
+
+static uhd::gain_range_t get_tx_gain_range_1(
+    uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
+{
+    return multi_usrp->get_tx_gain_range(chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_range_0, get_tx_gain_range_0, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_range_1, get_tx_gain_range_1, 1, 2);
+
+static void set_rx_dc_offset_0(
+    uhd::usrp::multi_usrp *multi_usrp, const bool enb, size_t chan = 0)
+{
+    multi_usrp->set_rx_dc_offset(enb, chan);
+}
+
+static void set_rx_dc_offset_1(
+    uhd::usrp::multi_usrp *multi_usrp, const std::complex<double> &offset, size_t chan = 0)
+{
+    multi_usrp->set_rx_dc_offset(offset, chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_dc_offset_0, set_rx_dc_offset_0, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_dc_offset_1, set_rx_dc_offset_1, 2, 3);
+
+static void set_tx_dc_offset_0(
+    uhd::usrp::multi_usrp *multi_usrp, const bool enb, size_t chan = 0)
+{
+    multi_usrp->set_tx_dc_offset(enb, chan);
+}
+
+static void set_tx_dc_offset_1(
+    uhd::usrp::multi_usrp *multi_usrp, const std::complex<double> &offset, size_t chan = 0)
+{
+    multi_usrp->set_tx_dc_offset(offset, chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_dc_offset_0, set_tx_dc_offset_0, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_dc_offset_1, set_tx_dc_offset_1, 2, 3);
+
+static void set_rx_iq_balance_0(
+    uhd::usrp::multi_usrp *multi_usrp, const bool enb, size_t chan = 0)
+{
+    multi_usrp->set_rx_iq_balance(enb, chan);
+}
+
+static void set_rx_iq_balance_1(
+    uhd::usrp::multi_usrp *multi_usrp, const std::complex<double> &offset, size_t chan = 0)
+{
+    multi_usrp->set_rx_iq_balance(offset, chan);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_iq_balance_0, set_rx_iq_balance_0, 2, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_iq_balance_1, set_rx_iq_balance_1, 2, 3);
+
+static void set_gpio_attr_0(uhd::usrp::multi_usrp *multi_usrp,
+                            const std::string &bank,
+                            const std::string &attr,
+                            const uint32_t value,
+                            const uint32_t mask = 0xffffffff,
+                            const size_t mboard = 0)
+{
+    multi_usrp->set_gpio_attr(bank, attr, value, mask, mboard);
+}
+
+static void set_gpio_attr_1(uhd::usrp::multi_usrp *multi_usrp,
+                            const std::string &bank,
+                            const std::string &attr,
+                            const std::string &value,
+                            const uint32_t mask = 0xffffffff,
+                            const size_t mboard = 0)
+{
+    multi_usrp->set_gpio_attr(bank, attr, value, mask, mboard);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_gpio_attr_0, set_gpio_attr_0, 4, 6);
+BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_gpio_attr_1, set_gpio_attr_1, 4, 6);
+
+//
+// Boost.Python needs to know about default argument overloads
+//
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_freq, get_rx_freq, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_rate, get_rx_rate, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_freq, set_rx_freq, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_rate, set_rx_rate, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_freq, get_tx_freq, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_rate, get_tx_rate, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_freq, set_tx_freq, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_rate, set_tx_rate, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_usrp_rx_info, get_usrp_rx_info, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_usrp_tx_info, get_usrp_rx_info, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_master_clock_rate, set_master_clock_rate, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_master_clock_rate, get_master_clock_rate, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_master_clock_rate_range, get_master_clock_rate_range, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_mboard_name, get_mboard_name, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_time_now, get_time_now, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_time_last_pps, get_time_last_pps, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_now, set_time_now, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_next_pps, set_time_next_pps, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_command_time, set_command_time, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_clear_command_time, clear_command_time, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_issue_stream_cmd, issue_stream_cmd, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_clock_config, set_clock_config, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_source, set_time_source, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_clock_source, set_clock_source, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_clock_source_out, set_clock_source_out, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_source_out, set_time_source_out, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_mboard_sensor, get_mboard_sensor, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_mboard_sensor_names, get_mboard_sensor_names, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_user_register, set_user_register, 2, 3);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_subdev_spec, set_rx_subdev_spec, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_subdev_spec, get_rx_subdev_spec, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_subdev_name, get_rx_subdev_name, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_rates, get_rx_rates, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_freq_range, get_rx_freq_range, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_fe_rx_freq_range, get_fe_rx_freq_range, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_names, get_rx_lo_names, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_source, get_rx_lo_source, 0, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_lo_source, set_rx_lo_source, 1, 3);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_sources, get_rx_lo_sources, 0, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_lo_export_enabled, set_rx_lo_export_enabled, 1, 3);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_export_enabled, get_rx_lo_export_enabled, 0, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_lo_freq, set_rx_lo_freq, 2, 3);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_freq, get_rx_lo_freq, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_freq_range, get_rx_lo_freq_range, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_normalized_rx_gain, set_normalized_rx_gain, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_normalized_rx_gain, get_normalized_rx_gain, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_agc, set_rx_agc, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_gain_names, get_rx_gain_names, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_antenna, set_rx_antenna, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_antenna, get_rx_antenna, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_antennas, get_rx_antennas, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_bandwidth, set_rx_bandwidth, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_bandwidth, get_rx_bandwidth, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_bandwidth_range, get_rx_bandwidth_range, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_dboard_iface, get_rx_dboard_iface, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_sensor, get_rx_sensor, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_sensor_names, get_rx_sensor_names, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_subdev_spec, set_tx_subdev_spec, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_subdev_spec, get_tx_subdev_spec, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_subdev_name, get_tx_subdev_name, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_rates, get_tx_rates, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_freq_range, get_tx_freq_range, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_fe_tx_freq_range, get_fe_tx_freq_range, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_normalized_tx_gain, set_normalized_tx_gain, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_normalized_tx_gain, get_normalized_tx_gain, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_gain_names, get_tx_gain_names, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_antenna, set_tx_antenna, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_antenna, get_tx_antenna, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_antennas, get_tx_antennas, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_bandwidth, set_tx_bandwidth, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_bandwidth, get_tx_bandwidth, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_bandwidth_range, get_tx_bandwidth_range, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_dboard_iface, get_tx_dboard_iface, 0, 1);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_sensor, get_tx_sensor, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_sensor_names, get_tx_sensor_names, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_iq_balance, set_tx_iq_balance, 1, 2);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_gpio_attr, get_gpio_attr, 2, 3);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_enumerate_registers, enumerate_registers, 0, 1);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_register_info, get_register_info, 1, 2);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_write_register, write_register, 3, 4);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_read_register, read_register, 2, 3);
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_filter_names, get_filter_names, 0, 1);
+
+void export_multi_usrp()
+{
+    using multi_usrp      = uhd::usrp::multi_usrp;
+    using register_info_t = multi_usrp::register_info_t;
+
+    bp::class_<register_info_t>("register_info")
+        .add_property("bitwidth", &register_info_t::bitwidth)
+        .add_property("readable", &register_info_t::readable)
+        .add_property("writable", &register_info_t::writable)
+        ;
+
+    bp::class_<
+        multi_usrp,
+        boost::shared_ptr<multi_usrp>,
+        boost::noncopyable>("multi_usrp", bp::no_init)
+
+        .def("__init__", bp::make_constructor(&multi_usrp::make))
+
+        // Methods
+        .def("make", &multi_usrp::make)
+        .staticmethod("make")
+
+        // General USRP methods
+        .def("get_rx_freq"             , &multi_usrp::get_rx_freq, overload_get_rx_freq())
+        .def("get_rx_num_channels"     , &multi_usrp::get_rx_num_channels)
+        .def("get_rx_rate"             , &multi_usrp::get_rx_rate, overload_get_rx_rate())
+        .def("get_rx_stream"           , &multi_usrp::get_rx_stream) 
+        .def("set_rx_freq"             , &multi_usrp::set_rx_freq, overload_set_rx_freq())
+        .def("set_rx_gain"             , &set_rx_gain_0, overload_set_rx_gain_0())
+        .def("set_rx_gain"             , &set_rx_gain_1, overload_set_rx_gain_1())
+        .def("set_rx_rate"             , &multi_usrp::set_rx_rate, overload_set_rx_rate())
+        .def("get_tx_freq"             , &multi_usrp::get_tx_freq, overload_get_tx_freq())
+        .def("get_tx_num_channels"     , &multi_usrp::get_tx_num_channels)
+        .def("get_tx_rate"             , &multi_usrp::get_tx_rate, overload_get_tx_rate())
+        .def("get_tx_stream"           , &multi_usrp::get_tx_stream)
+        .def("set_tx_freq"             , &multi_usrp::set_tx_freq, overload_set_tx_freq())
+        .def("set_tx_gain"             , &set_tx_gain_0, overload_set_tx_gain_0())
+        .def("set_tx_gain"             , &set_tx_gain_1, overload_set_tx_gain_1())
+        .def("set_tx_rate"             , &multi_usrp::set_tx_rate, overload_set_tx_rate())
+        .def("get_usrp_rx_info"        , &multi_usrp::get_usrp_rx_info, overload_get_usrp_rx_info())
+        .def("get_usrp_tx_info"        , &multi_usrp::get_usrp_tx_info, overload_get_usrp_tx_info())
+        .def("set_master_clock_rate"   , &multi_usrp::set_master_clock_rate, overload_set_master_clock_rate())
+        .def("get_master_clock_rate"   , &multi_usrp::get_master_clock_rate, overload_get_master_clock_rate())
+        .def("get_master_clock_rate_range", &multi_usrp::get_master_clock_rate_range, overload_get_master_clock_rate_range())
+        .def("get_pp_string"           , &multi_usrp::get_pp_string)
+        .def("get_mboard_name"         , &multi_usrp::get_mboard_name, overload_get_mboard_name())
+        .def("get_time_now"            , &multi_usrp::get_time_now, overload_get_time_now())
+        .def("get_time_last_pps"       , &multi_usrp::get_time_last_pps, overload_get_time_last_pps())
+        .def("set_time_now"            , &multi_usrp::set_time_now, overload_set_time_now())
+        .def("set_time_next_pps"       , &multi_usrp::set_time_next_pps, overload_set_time_next_pps())
+        .def("set_time_unknown_pps"    , &multi_usrp::set_time_unknown_pps)
+        .def("get_time_synchronized"   , &multi_usrp::get_time_synchronized)
+        .def("set_command_time"        , &multi_usrp::set_command_time, overload_set_command_time())
+        .def("clear_command_time"      , &multi_usrp::clear_command_time, overload_clear_command_time())
+        .def("issue_stream_cmd"        , &multi_usrp::issue_stream_cmd, overload_issue_stream_cmd())
+        .def("set_clock_config"        , &multi_usrp::set_clock_config, overload_set_clock_config())
+        .def("set_time_source"         , &multi_usrp::set_time_source, overload_set_time_source())
+        .def("get_time_source"         , &multi_usrp::get_time_source)
+        .def("get_time_sources"        , &multi_usrp::get_time_sources)
+        .def("set_clock_source"        , &multi_usrp::set_clock_source, overload_set_clock_source())
+        .def("get_clock_source"        , &multi_usrp::get_clock_source)
+        .def("get_clock_sources"       , &multi_usrp::get_clock_sources)
+        .def("set_clock_source_out"    , &multi_usrp::set_clock_source_out, overload_set_clock_source_out())
+        .def("set_time_source_out"     , &multi_usrp::set_time_source_out, overload_set_time_source_out())
+        .def("get_num_mboards"         , &multi_usrp::get_num_mboards)
+        .def("get_mboard_sensor"       , &multi_usrp::get_mboard_sensor, overload_get_mboard_sensor())
+        .def("get_mboard_sensor_names" , &multi_usrp::get_mboard_sensor_names, overload_get_mboard_sensor_names())
+        .def("set_user_register"       , &multi_usrp::set_user_register, overload_set_user_register())
+
+        // RX methods
+        .def("set_rx_subdev_spec"      , &multi_usrp::set_rx_subdev_spec, overload_set_rx_subdev_spec())
+        .def("get_rx_subdev_spec"      , &multi_usrp::get_rx_subdev_spec, overload_get_rx_subdev_spec())
+        .def("get_rx_subdev_name"      , &multi_usrp::get_rx_subdev_name, overload_get_rx_subdev_name())
+        .def("get_rx_rates"            , &multi_usrp::get_rx_rates, overload_get_rx_rates())
+        .def("get_rx_freq_range"       , &multi_usrp::get_rx_freq_range, overload_get_rx_freq_range())
+        .def("get_fe_rx_freq_range"    , &multi_usrp::get_fe_rx_freq_range, overload_get_fe_rx_freq_range())
+        .def("get_rx_lo_names"         , &multi_usrp::get_rx_lo_names, overload_get_rx_lo_names())
+        .def("set_rx_lo_source"        , &multi_usrp::set_rx_lo_source, overload_set_rx_lo_source())
+        .def("get_rx_lo_source"        , &multi_usrp::get_rx_lo_source, overload_get_rx_lo_source())
+        .def("get_rx_lo_sources"       , &multi_usrp::get_rx_lo_sources, overload_get_rx_lo_sources())
+        .def("set_rx_lo_export_enabled", &multi_usrp::set_rx_lo_export_enabled, overload_set_rx_lo_export_enabled())
+        .def("get_rx_lo_export_enabled", &multi_usrp::get_rx_lo_export_enabled, overload_get_rx_lo_export_enabled())
+        .def("set_rx_lo_freq"          , &multi_usrp::set_rx_lo_freq, overload_set_rx_lo_freq())
+        .def("get_rx_lo_freq"          , &multi_usrp::get_rx_lo_freq, overload_get_rx_lo_freq())
+        .def("get_rx_lo_freq_range"    , &multi_usrp::get_rx_lo_freq_range, overload_get_rx_lo_freq_range())
+        .def("set_normalized_rx_gain"  , &multi_usrp::set_normalized_rx_gain, overload_set_normalized_rx_gain())
+        .def("get_normalized_rx_gain"  , &multi_usrp::get_normalized_rx_gain, overload_get_normalized_rx_gain())
+        .def("set_rx_agc"              , &multi_usrp::set_rx_agc, overload_set_rx_agc())
+        .def("get_rx_gain"             , &get_rx_gain_0, overload_get_rx_gain_0())
+        .def("get_rx_gain"             , &get_rx_gain_1, overload_get_rx_gain_1())
+        .def("get_rx_gain_range"       , &get_rx_gain_range_0, overload_get_rx_gain_range_0())
+        .def("get_rx_gain_range"       , &get_rx_gain_range_1, overload_get_rx_gain_range_1())
+        .def("get_rx_gain_names"       , &multi_usrp::get_rx_gain_names, overload_get_rx_gain_names())
+        .def("set_rx_antenna"          , &multi_usrp::set_rx_antenna, overload_set_rx_antenna())
+        .def("get_rx_antenna"          , &multi_usrp::get_rx_antenna, overload_get_rx_antenna())
+        .def("get_rx_antennas"         , &multi_usrp::get_rx_antennas, overload_get_rx_antennas())
+        .def("set_rx_bandwidth"        , &multi_usrp::set_rx_bandwidth, overload_set_rx_bandwidth())
+        .def("get_rx_bandwidth"        , &multi_usrp::get_rx_bandwidth, overload_get_rx_bandwidth())
+        .def("get_rx_bandwidth_range"  , &multi_usrp::get_rx_bandwidth_range, overload_get_rx_bandwidth_range())
+        .def("get_rx_dboard_iface"     , &multi_usrp::get_rx_dboard_iface, overload_get_rx_dboard_iface())
+        .def("get_rx_sensor"           , &multi_usrp::get_rx_sensor, overload_get_rx_sensor())
+        .def("get_rx_sensor_names"     , &multi_usrp::get_rx_sensor_names, overload_get_rx_sensor_names())
+        .def("set_rx_dc_offset"        , &set_rx_dc_offset_0, overload_set_rx_dc_offset_0())
+        .def("set_rx_dc_offset"        , &set_rx_dc_offset_1, overload_set_rx_dc_offset_1())
+        .def("set_rx_iq_balance"       , &set_rx_iq_balance_0, overload_set_rx_iq_balance_0())
+        .def("set_rx_iq_balance"       , &set_rx_iq_balance_1, overload_set_rx_iq_balance_1())
+
+        // TX methods
+        .def("set_tx_subdev_spec"      , &multi_usrp::set_tx_subdev_spec, overload_set_tx_subdev_spec())
+        .def("get_tx_subdev_spec"      , &multi_usrp::get_tx_subdev_spec, overload_get_tx_subdev_spec())
+        .def("get_tx_subdev_name"      , &multi_usrp::get_tx_subdev_name, overload_get_tx_subdev_name())
+        .def("get_tx_rates"            , &multi_usrp::get_tx_rates, overload_get_rx_rates())
+        .def("get_tx_freq_range"       , &multi_usrp::get_tx_freq_range, overload_get_tx_freq_range())
+        .def("get_fe_tx_freq_range"    , &multi_usrp::get_fe_tx_freq_range, overload_get_fe_tx_freq_range())
+        .def("set_normalized_tx_gain"  , &multi_usrp::set_normalized_tx_gain, overload_set_normalized_tx_gain())
+        .def("get_normalized_tx_gain"  , &multi_usrp::get_normalized_tx_gain, overload_get_normalized_tx_gain())
+        .def("get_tx_gain"             , &get_tx_gain_0, overload_get_tx_gain_0())
+        .def("get_tx_gain"             , &get_tx_gain_1, overload_get_tx_gain_1())
+        .def("get_tx_gain_range"       , &get_tx_gain_range_0, overload_get_tx_gain_range_0())
+        .def("get_tx_gain_range"       , &get_tx_gain_range_1, overload_get_tx_gain_range_1())
+        .def("get_tx_gain_names"       , &multi_usrp::get_tx_gain_names, overload_get_tx_gain_names())
+        .def("set_tx_antenna"          , &multi_usrp::set_tx_antenna, overload_set_tx_antenna())
+        .def("get_tx_antenna"          , &multi_usrp::get_tx_antenna, overload_get_tx_antenna())
+        .def("get_tx_antennas"         , &multi_usrp::get_tx_antennas, overload_get_tx_antennas())
+        .def("set_tx_bandwidth"        , &multi_usrp::set_tx_bandwidth, overload_set_tx_bandwidth())
+        .def("get_tx_bandwidth"        , &multi_usrp::get_tx_bandwidth, overload_get_tx_bandwidth())
+        .def("get_tx_bandwidth_range"  , &multi_usrp::get_tx_bandwidth_range, overload_get_tx_bandwidth_range())
+        .def("get_tx_dboard_iface"     , &multi_usrp::get_tx_dboard_iface, overload_get_tx_dboard_iface())
+        .def("get_tx_sensor"           , &multi_usrp::get_tx_sensor, overload_get_tx_sensor())
+        .def("get_tx_sensor_names"     , &multi_usrp::get_tx_sensor_names, overload_get_tx_sensor_names())
+        .def("set_tx_dc_offset"        , &set_tx_dc_offset_0, overload_set_tx_dc_offset_0())
+        .def("set_tx_dc_offset"        , &set_tx_dc_offset_1, overload_set_tx_dc_offset_1())
+        .def("set_tx_iq_balance"       , &multi_usrp::set_tx_iq_balance, overload_set_tx_iq_balance())
+
+        // GPIO methods
+        .def("get_gpio_banks"          , &multi_usrp::get_gpio_banks)
+        .def("set_gpio_attr"           , &set_gpio_attr_0, overload_set_gpio_attr_0())
+        .def("set_gpio_attr"           , &set_gpio_attr_1, overload_set_gpio_attr_1())
+        .def("get_gpio_attr"           , &multi_usrp::get_gpio_attr, overload_get_gpio_attr())
+        .def("enumerate_registers"     , &multi_usrp::enumerate_registers, overload_enumerate_registers())
+        .def("get_register_info"       , &multi_usrp::get_register_info, overload_get_register_info())
+        .def("write_register"          , &multi_usrp::write_register, overload_write_register())
+        .def("read_register"           , &multi_usrp::read_register, overload_read_register())
+
+        // Filter API methods
+        .def("get_filter_names"        , &multi_usrp::get_filter_names, overload_get_filter_names())
+        .def("get_filter"              , &multi_usrp::get_filter)
+        .def("set_filter"              , &multi_usrp::set_filter)
+        ;
+}
+
+#endif /* INCLUDED_UHD_USRP_MULTI_USRP_PYTHON_HPP */
diff --git a/host/lib/usrp/subdev_spec_python.hpp b/host/lib/usrp/subdev_spec_python.hpp
new file mode 100644
index 000000000..ed91099f9
--- /dev/null
+++ b/host/lib/usrp/subdev_spec_python.hpp
@@ -0,0 +1,37 @@
+//
+// Copyright 2017-2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_UHD_USRP_SUBDEV_SPEC_PYTHON_HPP
+#define INCLUDED_UHD_USRP_SUBDEV_SPEC_PYTHON_HPP
+
+#include <uhd/usrp/subdev_spec.hpp>
+
+void export_subdev_spec()
+{
+    using subdev_spec_pair_t = uhd::usrp::subdev_spec_pair_t;
+    using subdev_spec_t      = uhd::usrp::subdev_spec_t;
+
+    bp::class_<subdev_spec_pair_t>
+        ("subdev_spec_pair", bp::init<const std::string&, const std::string &>())
+
+        // Properties
+        .add_property("db_name", &subdev_spec_pair_t::db_name)
+        .add_property("sd_name", &subdev_spec_pair_t::sd_name)
+        ;
+
+    bp::class_<std::vector<subdev_spec_pair_t> >("subdev_spec_vector")
+        .def(bp::vector_indexing_suite<std::vector<subdev_spec_pair_t> >());
+
+    bp::class_<subdev_spec_t, bp::bases<std::vector<subdev_spec_pair_t> > >
+        ("subdev_spec", bp::init<const std::string &>())
+
+        // Methods
+        .def("__str__",   &subdev_spec_t::to_pp_string)
+        .def("to_string", &subdev_spec_t::to_string)
+        ;
+}
+
+#endif /* INCLUDED_UHD_USRP_SUBDEV_SPEC_PYTHON_HPP */
diff --git a/host/lib/utils/gil_release_python.hpp b/host/lib/utils/gil_release_python.hpp
new file mode 100644
index 000000000..287ba240e
--- /dev/null
+++ b/host/lib/utils/gil_release_python.hpp
@@ -0,0 +1,31 @@
+//
+// Copyright 2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+//! 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();
+    }
+
+    inline ~scoped_gil_release()
+    {
+        PyEval_RestoreThread(_thread_state);
+        _thread_state = nullptr;
+    }
+
+private:
+    PyThreadState* _thread_state;
+};