# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _uhd_swig
else:
    import _uhd_swig

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_SwigPyIterator

    def value(self) -> "PyObject *":
        return _uhd_swig.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _uhd_swig.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _uhd_swig.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        return _uhd_swig.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        return _uhd_swig.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        return _uhd_swig.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        return _uhd_swig.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _uhd_swig.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _uhd_swig.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _uhd_swig.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        return _uhd_swig.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        return _uhd_swig.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _uhd_swig.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _uhd_swig.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _uhd_swig.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        return _uhd_swig.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _uhd_swig:
_uhd_swig.SwigPyIterator_swigregister(SwigPyIterator)


def high_res_timer_now() -> "gr::high_res_timer_type":
    r"""high_res_timer_now() -> gr::high_res_timer_type"""
    return _uhd_swig.high_res_timer_now()

def high_res_timer_now_perfmon() -> "gr::high_res_timer_type":
    r"""high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _uhd_swig.high_res_timer_now_perfmon()

def high_res_timer_tps() -> "gr::high_res_timer_type":
    r"""high_res_timer_tps() -> gr::high_res_timer_type"""
    return _uhd_swig.high_res_timer_tps()

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _uhd_swig.high_res_timer_epoch()

def cmd_chan_key() -> "pmt::pmt_t const":
    r"""cmd_chan_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_chan_key()

def cmd_gain_key() -> "pmt::pmt_t const":
    r"""cmd_gain_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_gain_key()

def cmd_freq_key() -> "pmt::pmt_t const":
    r"""cmd_freq_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_freq_key()

def cmd_lo_offset_key() -> "pmt::pmt_t const":
    r"""cmd_lo_offset_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_lo_offset_key()

def cmd_tune_key() -> "pmt::pmt_t const":
    r"""cmd_tune_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_tune_key()

def cmd_lo_freq_key() -> "pmt::pmt_t const":
    r"""cmd_lo_freq_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_lo_freq_key()

def cmd_dsp_freq_key() -> "pmt::pmt_t const":
    r"""cmd_dsp_freq_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_dsp_freq_key()

def cmd_rate_key() -> "pmt::pmt_t const":
    r"""cmd_rate_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_rate_key()

def cmd_bandwidth_key() -> "pmt::pmt_t const":
    r"""cmd_bandwidth_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_bandwidth_key()

def cmd_time_key() -> "pmt::pmt_t const":
    r"""cmd_time_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_time_key()

def cmd_mboard_key() -> "pmt::pmt_t const":
    r"""cmd_mboard_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_mboard_key()

def cmd_antenna_key() -> "pmt::pmt_t const":
    r"""cmd_antenna_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_antenna_key()

def cmd_direction_key() -> "pmt::pmt_t const":
    r"""cmd_direction_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_direction_key()

def cmd_tag_key() -> "pmt::pmt_t const":
    r"""cmd_tag_key() -> swig_pmt_ptr"""
    return _uhd_swig.cmd_tag_key()

def ant_direction_rx() -> "pmt::pmt_t const":
    r"""ant_direction_rx() -> swig_pmt_ptr"""
    return _uhd_swig.ant_direction_rx()

def ant_direction_tx() -> "pmt::pmt_t const":
    r"""ant_direction_tx() -> swig_pmt_ptr"""
    return _uhd_swig.ant_direction_tx()
class usrp_block(object):
    r"""Proxy of C++ gr::uhd::usrp_block class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def set_subdev_spec(self, spec: "std::string const &", mboard: "size_t"=0) -> "void":
        r"""set_subdev_spec(usrp_block self, std::string const & spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_subdev_spec(self, spec, mboard)

    def get_subdev_spec(self, mboard: "size_t"=0) -> "std::string":
        r"""get_subdev_spec(usrp_block self, size_t mboard=0) -> std::string"""
        return _uhd_swig.usrp_block_get_subdev_spec(self, mboard)

    def get_num_mboards(self) -> "size_t":
        r"""get_num_mboards(usrp_block self) -> size_t"""
        return _uhd_swig.usrp_block_get_num_mboards(self)

    def set_samp_rate(self, rate: "double") -> "void":
        r"""set_samp_rate(usrp_block self, double rate)"""
        return _uhd_swig.usrp_block_set_samp_rate(self, rate)

    def get_samp_rate(self) -> "double":
        r"""get_samp_rate(usrp_block self) -> double"""
        return _uhd_swig.usrp_block_get_samp_rate(self)

    def get_samp_rates(self) -> "::uhd::meta_range_t":
        r"""get_samp_rates(usrp_block self) -> meta_range_t"""
        return _uhd_swig.usrp_block_get_samp_rates(self)

    def set_center_freq(self, *args) -> "::uhd::tune_result_t":
        r"""
        set_center_freq(usrp_block self, tune_request_t tune_request, size_t chan=0) -> tune_result_t
        set_center_freq(usrp_block self, double freq, size_t chan=0) -> tune_result_t
        """
        return _uhd_swig.usrp_block_set_center_freq(self, *args)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""get_center_freq(usrp_block self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_block_get_center_freq(self, chan)

    def get_freq_range(self, chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_freq_range(usrp_block self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_block_get_freq_range(self, chan)

    def set_gain(self, *args) -> "void":
        r"""
        set_gain(usrp_block self, double gain, size_t chan=0)
        set_gain(usrp_block self, double gain, std::string const & name, size_t chan=0)
        """
        return _uhd_swig.usrp_block_set_gain(self, *args)

    def set_normalized_gain(self, norm_gain: "double", chan: "size_t"=0) -> "void":
        r"""set_normalized_gain(usrp_block self, double norm_gain, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_normalized_gain(self, norm_gain, chan)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(usrp_block self, size_t chan=0) -> double
        get_gain(usrp_block self, std::string const & name, size_t chan=0) -> double
        """
        return _uhd_swig.usrp_block_get_gain(self, *args)

    def get_normalized_gain(self, chan: "size_t"=0) -> "double":
        r"""get_normalized_gain(usrp_block self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_block_get_normalized_gain(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gain_names(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "::uhd::gain_range_t":
        r"""
        get_gain_range(usrp_block self, size_t chan=0) -> meta_range_t
        get_gain_range(usrp_block self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _uhd_swig.usrp_block_get_gain_range(self, *args)

    def set_antenna(self, ant: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_antenna(usrp_block self, std::string const & ant, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_antenna(self, ant, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""get_antenna(usrp_block self, size_t chan=0) -> std::string"""
        return _uhd_swig.usrp_block_get_antenna(self, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_antennas(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_antennas(self, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "void":
        r"""set_bandwidth(usrp_block self, double bandwidth, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""get_bandwidth(usrp_block self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_block_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_bandwidth_range(usrp_block self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_block_get_bandwidth_range(self, chan)

    def get_sensor(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_sensor(usrp_block self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_block_get_sensor(self, name, chan)

    def get_sensor_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_sensor_names(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_sensor_names(self, chan)

    def get_dboard_sensor(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_dboard_sensor(usrp_block self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_block_get_dboard_sensor(self, name, chan)

    def get_dboard_sensor_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_dboard_sensor_names(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_dboard_sensor_names(self, chan)

    def get_mboard_sensor(self, name: "std::string const &", mboard: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_mboard_sensor(usrp_block self, std::string const & name, size_t mboard=0) -> sensor_value_t"""
        return _uhd_swig.usrp_block_get_mboard_sensor(self, name, mboard)

    def get_mboard_sensor_names(self, mboard: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_mboard_sensor_names(usrp_block self, size_t mboard=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_mboard_sensor_names(self, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""get_time_source(usrp_block self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_block_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_time_sources(usrp_block self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_clock_source(usrp_block self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""get_clock_source(usrp_block self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_block_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_clock_sources(usrp_block self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""get_clock_rate(usrp_block self, size_t mboard=0) -> double"""
        return _uhd_swig.usrp_block_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""set_clock_rate(usrp_block self, double rate, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::uhd::time_spec_t":
        r"""get_time_now(usrp_block self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_block_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::uhd::time_spec_t":
        r"""get_time_last_pps(usrp_block self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_block_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_time_now(usrp_block self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_next_pps(usrp_block self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_block_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_unknown_pps(usrp_block self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_block_set_time_unknown_pps(self, time_spec)

    def set_command_time(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_command_time(usrp_block self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_command_time(self, time_spec, mboard)

    def clear_command_time(self, mboard: "size_t"=0) -> "void":
        r"""clear_command_time(usrp_block self, size_t mboard=0)"""
        return _uhd_swig.usrp_block_clear_command_time(self, mboard)

    def get_dboard_iface(self, chan: "size_t"=0) -> "::uhd::usrp::dboard_iface::sptr":
        r"""get_dboard_iface(usrp_block self, size_t chan=0) -> dboard_iface_sptr"""
        return _uhd_swig.usrp_block_get_dboard_iface(self, chan)

    def get_device(self) -> "::uhd::usrp::multi_usrp::sptr":
        r"""get_device(usrp_block self) -> ::uhd::usrp::multi_usrp::sptr"""
        return _uhd_swig.usrp_block_get_device(self)

    def set_user_register(self, addr: "uint8_t const", data: "uint32_t const", mboard: "size_t"=0) -> "void":
        r"""set_user_register(usrp_block self, uint8_t const addr, uint32_t const data, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_user_register(self, addr, data, mboard)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_time_source(usrp_block self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_block_set_time_source(self, source, mboard)

    def set_stream_args(self, stream_args: "stream_args_t") -> "void":
        r"""set_stream_args(usrp_block self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_block_set_stream_args(self, stream_args)

    def get_gpio_banks(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gpio_banks(usrp_block self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_gpio_banks(self, mboard)

    def set_gpio_attr(self, *args, **kwargs) -> "void":
        r"""set_gpio_attr(usrp_block self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask=0xffffffff, size_t const mboard=0)"""
        return _uhd_swig.usrp_block_set_gpio_attr(self, *args, **kwargs)

    def get_gpio_attr(self, bank: "std::string const &", attr: "std::string const &", mboard: "size_t const"=0) -> "boost::uint32_t":
        r"""get_gpio_attr(usrp_block self, std::string const & bank, std::string const & attr, size_t const mboard=0) -> boost::uint32_t"""
        return _uhd_swig.usrp_block_get_gpio_attr(self, bank, attr, mboard)

    def get_filter_names(self, *args, **kwargs) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_filter_names(usrp_block self, std::string const & search_mask="") -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_filter_names(self, *args, **kwargs)

    def set_filter(self, path: "std::string const &", filter: "filter_info_base_sptr") -> "void":
        r"""set_filter(usrp_block self, std::string const & path, filter_info_base_sptr filter)"""
        return _uhd_swig.usrp_block_set_filter(self, path, filter)

    def get_filter(self, path: "std::string const &") -> "::uhd::filter_info_base::sptr":
        r"""get_filter(usrp_block self, std::string const & path) -> filter_info_base_sptr"""
        return _uhd_swig.usrp_block_get_filter(self, path)
    __swig_destroy__ = _uhd_swig.delete_usrp_block

# Register usrp_block in _uhd_swig:
_uhd_swig.usrp_block_swigregister(usrp_block)

class uhd_string_vector_t(object):
    r"""Proxy of C++ std::vector< std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(uhd_string_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.uhd_string_vector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(uhd_string_vector_t self) -> bool"""
        return _uhd_swig.uhd_string_vector_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(uhd_string_vector_t self) -> bool"""
        return _uhd_swig.uhd_string_vector_t___bool__(self)

    def __len__(self) -> "std::vector< std::string >::size_type":
        r"""__len__(uhd_string_vector_t self) -> std::vector< std::string >::size_type"""
        return _uhd_swig.uhd_string_vector_t___len__(self)

    def __getslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "std::vector< std::string,std::allocator< std::string > > *":
        r"""__getslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> std::vector< std::string,std::allocator< std::string > > *"""
        return _uhd_swig.uhd_string_vector_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, std::vector< std::string,std::allocator< std::string > > const & v)
        """
        return _uhd_swig.uhd_string_vector_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "void":
        r"""__delslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _uhd_swig.uhd_string_vector_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(uhd_string_vector_t self, std::vector< std::string >::difference_type i)
        __delitem__(uhd_string_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.uhd_string_vector_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::string >::value_type const &":
        r"""
        __getitem__(uhd_string_vector_t self, PySliceObject * slice) -> std::vector< std::string,std::allocator< std::string > >
        __getitem__(uhd_string_vector_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _uhd_swig.uhd_string_vector_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(uhd_string_vector_t self, PySliceObject * slice, std::vector< std::string,std::allocator< std::string > > const & v)
        __setitem__(uhd_string_vector_t self, PySliceObject * slice)
        __setitem__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _uhd_swig.uhd_string_vector_t___setitem__(self, *args)

    def pop(self) -> "std::vector< std::string >::value_type":
        r"""pop(uhd_string_vector_t self) -> std::vector< std::string >::value_type"""
        return _uhd_swig.uhd_string_vector_t_pop(self)

    def append(self, x: "std::vector< std::string >::value_type const &") -> "void":
        r"""append(uhd_string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _uhd_swig.uhd_string_vector_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(uhd_string_vector_t self) -> bool"""
        return _uhd_swig.uhd_string_vector_t_empty(self)

    def size(self) -> "std::vector< std::string >::size_type":
        r"""size(uhd_string_vector_t self) -> std::vector< std::string >::size_type"""
        return _uhd_swig.uhd_string_vector_t_size(self)

    def swap(self, v: "std::vector< std::string > &") -> "void":
        r"""swap(uhd_string_vector_t self, std::vector< std::string > & v)"""
        return _uhd_swig.uhd_string_vector_t_swap(self, v)

    def begin(self) -> "std::vector< std::string >::iterator":
        r"""begin(uhd_string_vector_t self) -> std::vector< std::string >::iterator"""
        return _uhd_swig.uhd_string_vector_t_begin(self)

    def end(self) -> "std::vector< std::string >::iterator":
        r"""end(uhd_string_vector_t self) -> std::vector< std::string >::iterator"""
        return _uhd_swig.uhd_string_vector_t_end(self)

    def rbegin(self) -> "std::vector< std::string >::reverse_iterator":
        r"""rbegin(uhd_string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _uhd_swig.uhd_string_vector_t_rbegin(self)

    def rend(self) -> "std::vector< std::string >::reverse_iterator":
        r"""rend(uhd_string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _uhd_swig.uhd_string_vector_t_rend(self)

    def clear(self) -> "void":
        r"""clear(uhd_string_vector_t self)"""
        return _uhd_swig.uhd_string_vector_t_clear(self)

    def get_allocator(self) -> "std::vector< std::string >::allocator_type":
        r"""get_allocator(uhd_string_vector_t self) -> std::vector< std::string >::allocator_type"""
        return _uhd_swig.uhd_string_vector_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(uhd_string_vector_t self)"""
        return _uhd_swig.uhd_string_vector_t_pop_back(self)

    def erase(self, *args) -> "std::vector< std::string >::iterator":
        r"""
        erase(uhd_string_vector_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(uhd_string_vector_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _uhd_swig.uhd_string_vector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(uhd_string_vector_t self) -> uhd_string_vector_t
        __init__(uhd_string_vector_t self, std::vector< std::string > const & other) -> uhd_string_vector_t
        __init__(uhd_string_vector_t self, std::vector< std::string >::size_type size) -> uhd_string_vector_t
        __init__(uhd_string_vector_t self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> uhd_string_vector_t
        """
        _uhd_swig.uhd_string_vector_t_swiginit(self, _uhd_swig.new_uhd_string_vector_t(*args))

    def push_back(self, x: "std::vector< std::string >::value_type const &") -> "void":
        r"""push_back(uhd_string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _uhd_swig.uhd_string_vector_t_push_back(self, x)

    def front(self) -> "std::vector< std::string >::value_type const &":
        r"""front(uhd_string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _uhd_swig.uhd_string_vector_t_front(self)

    def back(self) -> "std::vector< std::string >::value_type const &":
        r"""back(uhd_string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _uhd_swig.uhd_string_vector_t_back(self)

    def assign(self, n: "std::vector< std::string >::size_type", x: "std::vector< std::string >::value_type const &") -> "void":
        r"""assign(uhd_string_vector_t self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _uhd_swig.uhd_string_vector_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(uhd_string_vector_t self, std::vector< std::string >::size_type new_size)
        resize(uhd_string_vector_t self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _uhd_swig.uhd_string_vector_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(uhd_string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(uhd_string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _uhd_swig.uhd_string_vector_t_insert(self, *args)

    def reserve(self, n: "std::vector< std::string >::size_type") -> "void":
        r"""reserve(uhd_string_vector_t self, std::vector< std::string >::size_type n)"""
        return _uhd_swig.uhd_string_vector_t_reserve(self, n)

    def capacity(self) -> "std::vector< std::string >::size_type":
        r"""capacity(uhd_string_vector_t self) -> std::vector< std::string >::size_type"""
        return _uhd_swig.uhd_string_vector_t_capacity(self)
    __swig_destroy__ = _uhd_swig.delete_uhd_string_vector_t

# Register uhd_string_vector_t in _uhd_swig:
_uhd_swig.uhd_string_vector_t_swigregister(uhd_string_vector_t)

class uhd_size_vector_t(object):
    r"""Proxy of C++ std::vector< size_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(uhd_size_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.uhd_size_vector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(uhd_size_vector_t self) -> bool"""
        return _uhd_swig.uhd_size_vector_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(uhd_size_vector_t self) -> bool"""
        return _uhd_swig.uhd_size_vector_t___bool__(self)

    def __len__(self) -> "std::vector< size_t >::size_type":
        r"""__len__(uhd_size_vector_t self) -> std::vector< size_t >::size_type"""
        return _uhd_swig.uhd_size_vector_t___len__(self)

    def __getslice__(self, i: "std::vector< size_t >::difference_type", j: "std::vector< size_t >::difference_type") -> "std::vector< size_t,std::allocator< size_t > > *":
        r"""__getslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j) -> gr_vsize_t"""
        return _uhd_swig.uhd_size_vector_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)
        __setslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j, gr_vsize_t v)
        """
        return _uhd_swig.uhd_size_vector_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< size_t >::difference_type", j: "std::vector< size_t >::difference_type") -> "void":
        r"""__delslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)"""
        return _uhd_swig.uhd_size_vector_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(uhd_size_vector_t self, std::vector< size_t >::difference_type i)
        __delitem__(uhd_size_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.uhd_size_vector_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< size_t >::value_type const &":
        r"""
        __getitem__(uhd_size_vector_t self, PySliceObject * slice) -> gr_vsize_t
        __getitem__(uhd_size_vector_t self, std::vector< size_t >::difference_type i) -> std::vector< size_t >::value_type const &
        """
        return _uhd_swig.uhd_size_vector_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(uhd_size_vector_t self, PySliceObject * slice, gr_vsize_t v)
        __setitem__(uhd_size_vector_t self, PySliceObject * slice)
        __setitem__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::value_type const & x)
        """
        return _uhd_swig.uhd_size_vector_t___setitem__(self, *args)

    def pop(self) -> "std::vector< size_t >::value_type":
        r"""pop(uhd_size_vector_t self) -> std::vector< size_t >::value_type"""
        return _uhd_swig.uhd_size_vector_t_pop(self)

    def append(self, x: "std::vector< size_t >::value_type const &") -> "void":
        r"""append(uhd_size_vector_t self, std::vector< size_t >::value_type const & x)"""
        return _uhd_swig.uhd_size_vector_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(uhd_size_vector_t self) -> bool"""
        return _uhd_swig.uhd_size_vector_t_empty(self)

    def size(self) -> "std::vector< size_t >::size_type":
        r"""size(uhd_size_vector_t self) -> std::vector< size_t >::size_type"""
        return _uhd_swig.uhd_size_vector_t_size(self)

    def swap(self, v: "gr_vsize_t") -> "void":
        r"""swap(uhd_size_vector_t self, gr_vsize_t v)"""
        return _uhd_swig.uhd_size_vector_t_swap(self, v)

    def begin(self) -> "std::vector< size_t >::iterator":
        r"""begin(uhd_size_vector_t self) -> std::vector< size_t >::iterator"""
        return _uhd_swig.uhd_size_vector_t_begin(self)

    def end(self) -> "std::vector< size_t >::iterator":
        r"""end(uhd_size_vector_t self) -> std::vector< size_t >::iterator"""
        return _uhd_swig.uhd_size_vector_t_end(self)

    def rbegin(self) -> "std::vector< size_t >::reverse_iterator":
        r"""rbegin(uhd_size_vector_t self) -> std::vector< size_t >::reverse_iterator"""
        return _uhd_swig.uhd_size_vector_t_rbegin(self)

    def rend(self) -> "std::vector< size_t >::reverse_iterator":
        r"""rend(uhd_size_vector_t self) -> std::vector< size_t >::reverse_iterator"""
        return _uhd_swig.uhd_size_vector_t_rend(self)

    def clear(self) -> "void":
        r"""clear(uhd_size_vector_t self)"""
        return _uhd_swig.uhd_size_vector_t_clear(self)

    def get_allocator(self) -> "std::vector< size_t >::allocator_type":
        r"""get_allocator(uhd_size_vector_t self) -> std::vector< size_t >::allocator_type"""
        return _uhd_swig.uhd_size_vector_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(uhd_size_vector_t self)"""
        return _uhd_swig.uhd_size_vector_t_pop_back(self)

    def erase(self, *args) -> "std::vector< size_t >::iterator":
        r"""
        erase(uhd_size_vector_t self, std::vector< size_t >::iterator pos) -> std::vector< size_t >::iterator
        erase(uhd_size_vector_t self, std::vector< size_t >::iterator first, std::vector< size_t >::iterator last) -> std::vector< size_t >::iterator
        """
        return _uhd_swig.uhd_size_vector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(uhd_size_vector_t self) -> uhd_size_vector_t
        __init__(uhd_size_vector_t self, gr_vsize_t other) -> uhd_size_vector_t
        __init__(uhd_size_vector_t self, std::vector< size_t >::size_type size) -> uhd_size_vector_t
        __init__(uhd_size_vector_t self, std::vector< size_t >::size_type size, std::vector< size_t >::value_type const & value) -> uhd_size_vector_t
        """
        _uhd_swig.uhd_size_vector_t_swiginit(self, _uhd_swig.new_uhd_size_vector_t(*args))

    def push_back(self, x: "std::vector< size_t >::value_type const &") -> "void":
        r"""push_back(uhd_size_vector_t self, std::vector< size_t >::value_type const & x)"""
        return _uhd_swig.uhd_size_vector_t_push_back(self, x)

    def front(self) -> "std::vector< size_t >::value_type const &":
        r"""front(uhd_size_vector_t self) -> std::vector< size_t >::value_type const &"""
        return _uhd_swig.uhd_size_vector_t_front(self)

    def back(self) -> "std::vector< size_t >::value_type const &":
        r"""back(uhd_size_vector_t self) -> std::vector< size_t >::value_type const &"""
        return _uhd_swig.uhd_size_vector_t_back(self)

    def assign(self, n: "std::vector< size_t >::size_type", x: "std::vector< size_t >::value_type const &") -> "void":
        r"""assign(uhd_size_vector_t self, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)"""
        return _uhd_swig.uhd_size_vector_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(uhd_size_vector_t self, std::vector< size_t >::size_type new_size)
        resize(uhd_size_vector_t self, std::vector< size_t >::size_type new_size, std::vector< size_t >::value_type const & x)
        """
        return _uhd_swig.uhd_size_vector_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(uhd_size_vector_t self, std::vector< size_t >::iterator pos, std::vector< size_t >::value_type const & x) -> std::vector< size_t >::iterator
        insert(uhd_size_vector_t self, std::vector< size_t >::iterator pos, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)
        """
        return _uhd_swig.uhd_size_vector_t_insert(self, *args)

    def reserve(self, n: "std::vector< size_t >::size_type") -> "void":
        r"""reserve(uhd_size_vector_t self, std::vector< size_t >::size_type n)"""
        return _uhd_swig.uhd_size_vector_t_reserve(self, n)

    def capacity(self) -> "std::vector< size_t >::size_type":
        r"""capacity(uhd_size_vector_t self) -> std::vector< size_t >::size_type"""
        return _uhd_swig.uhd_size_vector_t_capacity(self)
    __swig_destroy__ = _uhd_swig.delete_uhd_size_vector_t

# Register uhd_size_vector_t in _uhd_swig:
_uhd_swig.uhd_size_vector_t_swigregister(uhd_size_vector_t)

class string_string_dict_t(object):
    r"""Proxy of C++ uhd::dict< std::string,std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(string_string_dict_t self) -> string_string_dict_t"""
        _uhd_swig.string_string_dict_t_swiginit(self, _uhd_swig.new_string_string_dict_t())

    def size(self) -> "std::size_t":
        r"""size(string_string_dict_t self) -> std::size_t"""
        return _uhd_swig.string_string_dict_t_size(self)

    def keys(self) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""keys(string_string_dict_t self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.string_string_dict_t_keys(self)

    def vals(self) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""vals(string_string_dict_t self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.string_string_dict_t_vals(self)

    def has_key(self, key: "std::string const &") -> "bool":
        r"""has_key(string_string_dict_t self, std::string const & key) -> bool"""
        return _uhd_swig.string_string_dict_t_has_key(self, key)

    def get(self, *args) -> "std::string const &":
        r"""
        get(string_string_dict_t self, std::string const & key, std::string const & other) -> std::string const
        get(string_string_dict_t self, std::string const & key) -> std::string const &
        """
        return _uhd_swig.string_string_dict_t_get(self, *args)

    def set(self, key: "std::string const &", val: "std::string const &") -> "void":
        r"""set(string_string_dict_t self, std::string const & key, std::string const & val)"""
        return _uhd_swig.string_string_dict_t_set(self, key, val)

    def __eq__(self, other: "string_string_dict_t") -> "bool":
        r"""__eq__(string_string_dict_t self, string_string_dict_t other) -> bool"""
        return _uhd_swig.string_string_dict_t___eq__(self, other)

    def __ne__(self, other: "string_string_dict_t") -> "bool":
        r"""__ne__(string_string_dict_t self, string_string_dict_t other) -> bool"""
        return _uhd_swig.string_string_dict_t___ne__(self, other)

    def pop(self, key: "std::string const &") -> "std::string":
        r"""pop(string_string_dict_t self, std::string const & key) -> std::string"""
        return _uhd_swig.string_string_dict_t_pop(self, key)

    def update(self, new_dict: "string_string_dict_t", fail_on_conflict: "bool"=True) -> "void":
        r"""update(string_string_dict_t self, string_string_dict_t new_dict, bool fail_on_conflict=True)"""
        return _uhd_swig.string_string_dict_t_update(self, new_dict, fail_on_conflict)

    def __getitem__(self, key: "std::string") -> "std::string":
        r"""__getitem__(string_string_dict_t self, std::string key) -> std::string"""
        return _uhd_swig.string_string_dict_t___getitem__(self, key)

    def __setitem__(self, key: "std::string", val: "std::string") -> "void":
        r"""__setitem__(string_string_dict_t self, std::string key, std::string val)"""
        return _uhd_swig.string_string_dict_t___setitem__(self, key, val)
    __swig_destroy__ = _uhd_swig.delete_string_string_dict_t

# Register string_string_dict_t in _uhd_swig:
_uhd_swig.string_string_dict_t_swigregister(string_string_dict_t)

class device_addr_t(string_string_dict_t):
    r"""Proxy of C++ uhd::device_addr_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(device_addr_t self, std::string const & args="") -> device_addr_t
        __init__(device_addr_t self, std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > const & info) -> device_addr_t
        """
        _uhd_swig.device_addr_t_swiginit(self, _uhd_swig.new_device_addr_t(*args))

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(device_addr_t self) -> std::string"""
        return _uhd_swig.device_addr_t_to_pp_string(self)

    def to_string(self) -> "std::string":
        r"""to_string(device_addr_t self) -> std::string"""
        return _uhd_swig.device_addr_t_to_string(self)
    __swig_destroy__ = _uhd_swig.delete_device_addr_t

# Register device_addr_t in _uhd_swig:
_uhd_swig.device_addr_t_swigregister(device_addr_t)


def separate_device_addr(dev_addr: "device_addr_t") -> "uhd::device_addrs_t":
    r"""separate_device_addr(device_addr_t dev_addr) -> device_addr_vector_t"""
    return _uhd_swig.separate_device_addr(dev_addr)

def combine_device_addrs(dev_addrs: "device_addr_vector_t") -> "uhd::device_addr_t":
    r"""combine_device_addrs(device_addr_vector_t dev_addrs) -> device_addr_t"""
    return _uhd_swig.combine_device_addrs(dev_addrs)
class range_vector_t(object):
    r"""Proxy of C++ std::vector< uhd::range_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(range_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.range_vector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(range_vector_t self) -> bool"""
        return _uhd_swig.range_vector_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(range_vector_t self) -> bool"""
        return _uhd_swig.range_vector_t___bool__(self)

    def __len__(self) -> "std::vector< uhd::range_t >::size_type":
        r"""__len__(range_vector_t self) -> std::vector< uhd::range_t >::size_type"""
        return _uhd_swig.range_vector_t___len__(self)

    def __getslice__(self, i: "std::vector< uhd::range_t >::difference_type", j: "std::vector< uhd::range_t >::difference_type") -> "std::vector< uhd::range_t,std::allocator< uhd::range_t > > *":
        r"""__getslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j) -> range_vector_t"""
        return _uhd_swig.range_vector_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j)
        __setslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j, range_vector_t v)
        """
        return _uhd_swig.range_vector_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< uhd::range_t >::difference_type", j: "std::vector< uhd::range_t >::difference_type") -> "void":
        r"""__delslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j)"""
        return _uhd_swig.range_vector_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(range_vector_t self, std::vector< uhd::range_t >::difference_type i)
        __delitem__(range_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.range_vector_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< uhd::range_t >::value_type const &":
        r"""
        __getitem__(range_vector_t self, PySliceObject * slice) -> range_vector_t
        __getitem__(range_vector_t self, std::vector< uhd::range_t >::difference_type i) -> range_t
        """
        return _uhd_swig.range_vector_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(range_vector_t self, PySliceObject * slice, range_vector_t v)
        __setitem__(range_vector_t self, PySliceObject * slice)
        __setitem__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, range_t x)
        """
        return _uhd_swig.range_vector_t___setitem__(self, *args)

    def pop(self) -> "std::vector< uhd::range_t >::value_type":
        r"""pop(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_pop(self)

    def append(self, x: "range_t") -> "void":
        r"""append(range_vector_t self, range_t x)"""
        return _uhd_swig.range_vector_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(range_vector_t self) -> bool"""
        return _uhd_swig.range_vector_t_empty(self)

    def size(self) -> "std::vector< uhd::range_t >::size_type":
        r"""size(range_vector_t self) -> std::vector< uhd::range_t >::size_type"""
        return _uhd_swig.range_vector_t_size(self)

    def swap(self, v: "range_vector_t") -> "void":
        r"""swap(range_vector_t self, range_vector_t v)"""
        return _uhd_swig.range_vector_t_swap(self, v)

    def begin(self) -> "std::vector< uhd::range_t >::iterator":
        r"""begin(range_vector_t self) -> std::vector< uhd::range_t >::iterator"""
        return _uhd_swig.range_vector_t_begin(self)

    def end(self) -> "std::vector< uhd::range_t >::iterator":
        r"""end(range_vector_t self) -> std::vector< uhd::range_t >::iterator"""
        return _uhd_swig.range_vector_t_end(self)

    def rbegin(self) -> "std::vector< uhd::range_t >::reverse_iterator":
        r"""rbegin(range_vector_t self) -> std::vector< uhd::range_t >::reverse_iterator"""
        return _uhd_swig.range_vector_t_rbegin(self)

    def rend(self) -> "std::vector< uhd::range_t >::reverse_iterator":
        r"""rend(range_vector_t self) -> std::vector< uhd::range_t >::reverse_iterator"""
        return _uhd_swig.range_vector_t_rend(self)

    def clear(self) -> "void":
        r"""clear(range_vector_t self)"""
        return _uhd_swig.range_vector_t_clear(self)

    def get_allocator(self) -> "std::vector< uhd::range_t >::allocator_type":
        r"""get_allocator(range_vector_t self) -> std::vector< uhd::range_t >::allocator_type"""
        return _uhd_swig.range_vector_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(range_vector_t self)"""
        return _uhd_swig.range_vector_t_pop_back(self)

    def erase(self, *args) -> "std::vector< uhd::range_t >::iterator":
        r"""
        erase(range_vector_t self, std::vector< uhd::range_t >::iterator pos) -> std::vector< uhd::range_t >::iterator
        erase(range_vector_t self, std::vector< uhd::range_t >::iterator first, std::vector< uhd::range_t >::iterator last) -> std::vector< uhd::range_t >::iterator
        """
        return _uhd_swig.range_vector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(range_vector_t self) -> range_vector_t
        __init__(range_vector_t self, range_vector_t other) -> range_vector_t
        __init__(range_vector_t self, std::vector< uhd::range_t >::size_type size) -> range_vector_t
        __init__(range_vector_t self, std::vector< uhd::range_t >::size_type size, range_t value) -> range_vector_t
        """
        _uhd_swig.range_vector_t_swiginit(self, _uhd_swig.new_range_vector_t(*args))

    def push_back(self, x: "range_t") -> "void":
        r"""push_back(range_vector_t self, range_t x)"""
        return _uhd_swig.range_vector_t_push_back(self, x)

    def front(self) -> "std::vector< uhd::range_t >::value_type const &":
        r"""front(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_front(self)

    def back(self) -> "std::vector< uhd::range_t >::value_type const &":
        r"""back(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_back(self)

    def assign(self, n: "std::vector< uhd::range_t >::size_type", x: "range_t") -> "void":
        r"""assign(range_vector_t self, std::vector< uhd::range_t >::size_type n, range_t x)"""
        return _uhd_swig.range_vector_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(range_vector_t self, std::vector< uhd::range_t >::size_type new_size)
        resize(range_vector_t self, std::vector< uhd::range_t >::size_type new_size, range_t x)
        """
        return _uhd_swig.range_vector_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(range_vector_t self, std::vector< uhd::range_t >::iterator pos, range_t x) -> std::vector< uhd::range_t >::iterator
        insert(range_vector_t self, std::vector< uhd::range_t >::iterator pos, std::vector< uhd::range_t >::size_type n, range_t x)
        """
        return _uhd_swig.range_vector_t_insert(self, *args)

    def reserve(self, n: "std::vector< uhd::range_t >::size_type") -> "void":
        r"""reserve(range_vector_t self, std::vector< uhd::range_t >::size_type n)"""
        return _uhd_swig.range_vector_t_reserve(self, n)

    def capacity(self) -> "std::vector< uhd::range_t >::size_type":
        r"""capacity(range_vector_t self) -> std::vector< uhd::range_t >::size_type"""
        return _uhd_swig.range_vector_t_capacity(self)
    __swig_destroy__ = _uhd_swig.delete_range_vector_t

# Register range_vector_t in _uhd_swig:
_uhd_swig.range_vector_t_swigregister(range_vector_t)

class range_t(object):
    r"""Proxy of C++ uhd::range_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(range_t self, double value=0) -> range_t
        __init__(range_t self, double start, double stop, double step=0) -> range_t
        """
        _uhd_swig.range_t_swiginit(self, _uhd_swig.new_range_t(*args))

    def start(self) -> "double":
        r"""start(range_t self) -> double"""
        return _uhd_swig.range_t_start(self)

    def stop(self) -> "double":
        r"""stop(range_t self) -> double"""
        return _uhd_swig.range_t_stop(self)

    def step(self) -> "double":
        r"""step(range_t self) -> double"""
        return _uhd_swig.range_t_step(self)

    def to_pp_string(self) -> "std::string const":
        r"""to_pp_string(range_t self) -> std::string const"""
        return _uhd_swig.range_t_to_pp_string(self)

    def __eq__(self, other: "range_t") -> "bool":
        r"""__eq__(range_t self, range_t other) -> bool"""
        return _uhd_swig.range_t___eq__(self, other)

    def __ne__(self, other: "range_t") -> "bool":
        r"""__ne__(range_t self, range_t other) -> bool"""
        return _uhd_swig.range_t___ne__(self, other)
    __swig_destroy__ = _uhd_swig.delete_range_t

# Register range_t in _uhd_swig:
_uhd_swig.range_t_swigregister(range_t)

class meta_range_t(range_vector_t):
    r"""Proxy of C++ uhd::meta_range_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(meta_range_t self) -> meta_range_t
        __init__(meta_range_t self, double start, double stop, double step=0) -> meta_range_t
        """
        _uhd_swig.meta_range_t_swiginit(self, _uhd_swig.new_meta_range_t(*args))

    def start(self) -> "double":
        r"""start(meta_range_t self) -> double"""
        return _uhd_swig.meta_range_t_start(self)

    def stop(self) -> "double":
        r"""stop(meta_range_t self) -> double"""
        return _uhd_swig.meta_range_t_stop(self)

    def step(self) -> "double":
        r"""step(meta_range_t self) -> double"""
        return _uhd_swig.meta_range_t_step(self)

    def clip(self, value: "double", clip_step: "bool"=False) -> "double":
        r"""clip(meta_range_t self, double value, bool clip_step=False) -> double"""
        return _uhd_swig.meta_range_t_clip(self, value, clip_step)

    def to_pp_string(self) -> "std::string const":
        r"""to_pp_string(meta_range_t self) -> std::string const"""
        return _uhd_swig.meta_range_t_to_pp_string(self)
    __swig_destroy__ = _uhd_swig.delete_meta_range_t

# Register meta_range_t in _uhd_swig:
_uhd_swig.meta_range_t_swigregister(meta_range_t)

class tune_request_t(object):
    r"""Proxy of C++ uhd::tune_request_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(tune_request_t self, double target_freq=0) -> tune_request_t
        __init__(tune_request_t self, double target_freq, double lo_off) -> tune_request_t
        """
        _uhd_swig.tune_request_t_swiginit(self, _uhd_swig.new_tune_request_t(*args))
    POLICY_NONE = _uhd_swig.tune_request_t_POLICY_NONE
    
    POLICY_AUTO = _uhd_swig.tune_request_t_POLICY_AUTO
    
    POLICY_MANUAL = _uhd_swig.tune_request_t_POLICY_MANUAL
    
    target_freq = property(_uhd_swig.tune_request_t_target_freq_get, _uhd_swig.tune_request_t_target_freq_set, doc=r"""target_freq : double""")
    rf_freq_policy = property(_uhd_swig.tune_request_t_rf_freq_policy_get, _uhd_swig.tune_request_t_rf_freq_policy_set, doc=r"""rf_freq_policy : uhd::tune_request_t::policy_t""")
    rf_freq = property(_uhd_swig.tune_request_t_rf_freq_get, _uhd_swig.tune_request_t_rf_freq_set, doc=r"""rf_freq : double""")
    dsp_freq_policy = property(_uhd_swig.tune_request_t_dsp_freq_policy_get, _uhd_swig.tune_request_t_dsp_freq_policy_set, doc=r"""dsp_freq_policy : uhd::tune_request_t::policy_t""")
    dsp_freq = property(_uhd_swig.tune_request_t_dsp_freq_get, _uhd_swig.tune_request_t_dsp_freq_set, doc=r"""dsp_freq : double""")
    args = property(_uhd_swig.tune_request_t_args_get, _uhd_swig.tune_request_t_args_set, doc=r"""args : uhd::device_addr_t""")
    __swig_destroy__ = _uhd_swig.delete_tune_request_t

# Register tune_request_t in _uhd_swig:
_uhd_swig.tune_request_t_swigregister(tune_request_t)

class tune_result_t(object):
    r"""Proxy of C++ uhd::tune_result_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    clipped_rf_freq = property(_uhd_swig.tune_result_t_clipped_rf_freq_get, _uhd_swig.tune_result_t_clipped_rf_freq_set, doc=r"""clipped_rf_freq : double""")
    target_rf_freq = property(_uhd_swig.tune_result_t_target_rf_freq_get, _uhd_swig.tune_result_t_target_rf_freq_set, doc=r"""target_rf_freq : double""")
    actual_rf_freq = property(_uhd_swig.tune_result_t_actual_rf_freq_get, _uhd_swig.tune_result_t_actual_rf_freq_set, doc=r"""actual_rf_freq : double""")
    target_dsp_freq = property(_uhd_swig.tune_result_t_target_dsp_freq_get, _uhd_swig.tune_result_t_target_dsp_freq_set, doc=r"""target_dsp_freq : double""")
    actual_dsp_freq = property(_uhd_swig.tune_result_t_actual_dsp_freq_get, _uhd_swig.tune_result_t_actual_dsp_freq_set, doc=r"""actual_dsp_freq : double""")

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(tune_result_t self) -> std::string"""
        return _uhd_swig.tune_result_t_to_pp_string(self)

    def __init__(self):
        r"""__init__(tune_result_t self) -> tune_result_t"""
        _uhd_swig.tune_result_t_swiginit(self, _uhd_swig.new_tune_result_t())
    __swig_destroy__ = _uhd_swig.delete_tune_result_t

# Register tune_result_t in _uhd_swig:
_uhd_swig.tune_result_t_swigregister(tune_result_t)

class time_spec_t(object):
    r"""Proxy of C++ uhd::time_spec_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(time_spec_t self, double secs=0) -> time_spec_t
        __init__(time_spec_t self, int64_t full_secs, double frac_secs=0) -> time_spec_t
        __init__(time_spec_t self, int64_t full_secs, long tick_count, double tick_rate) -> time_spec_t
        """
        _uhd_swig.time_spec_t_swiginit(self, _uhd_swig.new_time_spec_t(*args))

    @staticmethod
    def from_ticks(ticks: "long long", tick_rate: "double") -> "uhd::time_spec_t":
        r"""from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
        return _uhd_swig.time_spec_t_from_ticks(ticks, tick_rate)

    def get_tick_count(self, tick_rate: "double") -> "long":
        r"""get_tick_count(time_spec_t self, double tick_rate) -> long"""
        return _uhd_swig.time_spec_t_get_tick_count(self, tick_rate)

    def to_ticks(self, tick_rate: "double const") -> "long long":
        r"""to_ticks(time_spec_t self, double const tick_rate) -> long long"""
        return _uhd_swig.time_spec_t_to_ticks(self, tick_rate)

    def get_real_secs(self) -> "double":
        r"""get_real_secs(time_spec_t self) -> double"""
        return _uhd_swig.time_spec_t_get_real_secs(self)

    def get_full_secs(self) -> "int64_t":
        r"""get_full_secs(time_spec_t self) -> int64_t"""
        return _uhd_swig.time_spec_t_get_full_secs(self)

    def get_frac_secs(self) -> "double":
        r"""get_frac_secs(time_spec_t self) -> double"""
        return _uhd_swig.time_spec_t_get_frac_secs(self)

    def __iadd__(self, *args) -> "uhd::time_spec_t &":
        r"""
        __iadd__(time_spec_t self, time_spec_t arg2) -> time_spec_t
        __iadd__(time_spec_t self, double & arg2) -> time_spec_t
        """
        return _uhd_swig.time_spec_t___iadd__(self, *args)

    def __isub__(self, *args) -> "uhd::time_spec_t &":
        r"""
        __isub__(time_spec_t self, time_spec_t arg2) -> time_spec_t
        __isub__(time_spec_t self, double & arg2) -> time_spec_t
        """
        return _uhd_swig.time_spec_t___isub__(self, *args)

    def __add__(self, what: "time_spec_t") -> "uhd::time_spec_t":
        r"""__add__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _uhd_swig.time_spec_t___add__(self, what)

    def __sub__(self, what: "time_spec_t") -> "uhd::time_spec_t":
        r"""__sub__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _uhd_swig.time_spec_t___sub__(self, what)

    def __eq__(self, what: "time_spec_t") -> "bool":
        r"""__eq__(time_spec_t self, time_spec_t what) -> bool"""
        return _uhd_swig.time_spec_t___eq__(self, what)
    __swig_destroy__ = _uhd_swig.delete_time_spec_t

# Register time_spec_t in _uhd_swig:
_uhd_swig.time_spec_t_swigregister(time_spec_t)

def time_spec_t_from_ticks(ticks: "long long", tick_rate: "double") -> "uhd::time_spec_t":
    r"""time_spec_t_from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
    return _uhd_swig.time_spec_t_from_ticks(ticks, tick_rate)


def __eq__(arg1: "time_spec_t", arg2: "time_spec_t") -> "bool":
    r"""__eq__(time_spec_t arg1, time_spec_t arg2) -> bool"""
    return _uhd_swig.__eq__(arg1, arg2)

def __lt__(arg1: "time_spec_t", arg2: "time_spec_t") -> "bool":
    r"""__lt__(time_spec_t arg1, time_spec_t arg2) -> bool"""
    return _uhd_swig.__lt__(arg1, arg2)
class stream_cmd_t(object):
    r"""Proxy of C++ uhd::stream_cmd_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    STREAM_MODE_START_CONTINUOUS = _uhd_swig.stream_cmd_t_STREAM_MODE_START_CONTINUOUS
    
    STREAM_MODE_STOP_CONTINUOUS = _uhd_swig.stream_cmd_t_STREAM_MODE_STOP_CONTINUOUS
    
    STREAM_MODE_NUM_SAMPS_AND_DONE = _uhd_swig.stream_cmd_t_STREAM_MODE_NUM_SAMPS_AND_DONE
    
    STREAM_MODE_NUM_SAMPS_AND_MORE = _uhd_swig.stream_cmd_t_STREAM_MODE_NUM_SAMPS_AND_MORE
    
    stream_mode = property(_uhd_swig.stream_cmd_t_stream_mode_get, _uhd_swig.stream_cmd_t_stream_mode_set, doc=r"""stream_mode : enum uhd::stream_cmd_t::stream_mode_t""")
    num_samps = property(_uhd_swig.stream_cmd_t_num_samps_get, _uhd_swig.stream_cmd_t_num_samps_set, doc=r"""num_samps : size_t""")
    stream_now = property(_uhd_swig.stream_cmd_t_stream_now_get, _uhd_swig.stream_cmd_t_stream_now_set, doc=r"""stream_now : bool""")
    time_spec = property(_uhd_swig.stream_cmd_t_time_spec_get, _uhd_swig.stream_cmd_t_time_spec_set, doc=r"""time_spec : uhd::time_spec_t""")

    def __init__(self, stream_mode: "uhd::stream_cmd_t::stream_mode_t const &"):
        r"""__init__(stream_cmd_t self, uhd::stream_cmd_t::stream_mode_t const & stream_mode) -> stream_cmd_t"""
        _uhd_swig.stream_cmd_t_swiginit(self, _uhd_swig.new_stream_cmd_t(stream_mode))
    __swig_destroy__ = _uhd_swig.delete_stream_cmd_t

# Register stream_cmd_t in _uhd_swig:
_uhd_swig.stream_cmd_t_swigregister(stream_cmd_t)

class rx_metadata_t(object):
    r"""Proxy of C++ uhd::rx_metadata_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(rx_metadata_t self) -> rx_metadata_t"""
        _uhd_swig.rx_metadata_t_swiginit(self, _uhd_swig.new_rx_metadata_t())

    def reset(self) -> "void":
        r"""reset(rx_metadata_t self)"""
        return _uhd_swig.rx_metadata_t_reset(self)
    has_time_spec = property(_uhd_swig.rx_metadata_t_has_time_spec_get, _uhd_swig.rx_metadata_t_has_time_spec_set, doc=r"""has_time_spec : bool""")
    time_spec = property(_uhd_swig.rx_metadata_t_time_spec_get, _uhd_swig.rx_metadata_t_time_spec_set, doc=r"""time_spec : uhd::time_spec_t""")
    more_fragments = property(_uhd_swig.rx_metadata_t_more_fragments_get, _uhd_swig.rx_metadata_t_more_fragments_set, doc=r"""more_fragments : bool""")
    fragment_offset = property(_uhd_swig.rx_metadata_t_fragment_offset_get, _uhd_swig.rx_metadata_t_fragment_offset_set, doc=r"""fragment_offset : size_t""")
    start_of_burst = property(_uhd_swig.rx_metadata_t_start_of_burst_get, _uhd_swig.rx_metadata_t_start_of_burst_set, doc=r"""start_of_burst : bool""")
    end_of_burst = property(_uhd_swig.rx_metadata_t_end_of_burst_get, _uhd_swig.rx_metadata_t_end_of_burst_set, doc=r"""end_of_burst : bool""")
    ERROR_CODE_NONE = _uhd_swig.rx_metadata_t_ERROR_CODE_NONE
    
    ERROR_CODE_TIMEOUT = _uhd_swig.rx_metadata_t_ERROR_CODE_TIMEOUT
    
    ERROR_CODE_LATE_COMMAND = _uhd_swig.rx_metadata_t_ERROR_CODE_LATE_COMMAND
    
    ERROR_CODE_BROKEN_CHAIN = _uhd_swig.rx_metadata_t_ERROR_CODE_BROKEN_CHAIN
    
    ERROR_CODE_OVERFLOW = _uhd_swig.rx_metadata_t_ERROR_CODE_OVERFLOW
    
    ERROR_CODE_ALIGNMENT = _uhd_swig.rx_metadata_t_ERROR_CODE_ALIGNMENT
    
    ERROR_CODE_BAD_PACKET = _uhd_swig.rx_metadata_t_ERROR_CODE_BAD_PACKET
    
    error_code = property(_uhd_swig.rx_metadata_t_error_code_get, _uhd_swig.rx_metadata_t_error_code_set, doc=r"""error_code : enum uhd::rx_metadata_t::error_code_t""")
    out_of_sequence = property(_uhd_swig.rx_metadata_t_out_of_sequence_get, _uhd_swig.rx_metadata_t_out_of_sequence_set, doc=r"""out_of_sequence : bool""")

    def to_pp_string(self, compact: "bool"=True) -> "std::string":
        r"""to_pp_string(rx_metadata_t self, bool compact=True) -> std::string"""
        return _uhd_swig.rx_metadata_t_to_pp_string(self, compact)

    def strerror(self) -> "std::string":
        r"""strerror(rx_metadata_t self) -> std::string"""
        return _uhd_swig.rx_metadata_t_strerror(self)
    __swig_destroy__ = _uhd_swig.delete_rx_metadata_t

# Register rx_metadata_t in _uhd_swig:
_uhd_swig.rx_metadata_t_swigregister(rx_metadata_t)

class tx_metadata_t(object):
    r"""Proxy of C++ uhd::tx_metadata_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    has_time_spec = property(_uhd_swig.tx_metadata_t_has_time_spec_get, _uhd_swig.tx_metadata_t_has_time_spec_set, doc=r"""has_time_spec : bool""")
    time_spec = property(_uhd_swig.tx_metadata_t_time_spec_get, _uhd_swig.tx_metadata_t_time_spec_set, doc=r"""time_spec : uhd::time_spec_t""")
    start_of_burst = property(_uhd_swig.tx_metadata_t_start_of_burst_get, _uhd_swig.tx_metadata_t_start_of_burst_set, doc=r"""start_of_burst : bool""")
    end_of_burst = property(_uhd_swig.tx_metadata_t_end_of_burst_get, _uhd_swig.tx_metadata_t_end_of_burst_set, doc=r"""end_of_burst : bool""")

    def __init__(self):
        r"""__init__(tx_metadata_t self) -> tx_metadata_t"""
        _uhd_swig.tx_metadata_t_swiginit(self, _uhd_swig.new_tx_metadata_t())
    __swig_destroy__ = _uhd_swig.delete_tx_metadata_t

# Register tx_metadata_t in _uhd_swig:
_uhd_swig.tx_metadata_t_swigregister(tx_metadata_t)

class async_metadata_t(object):
    r"""Proxy of C++ uhd::async_metadata_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    channel = property(_uhd_swig.async_metadata_t_channel_get, _uhd_swig.async_metadata_t_channel_set, doc=r"""channel : size_t""")
    has_time_spec = property(_uhd_swig.async_metadata_t_has_time_spec_get, _uhd_swig.async_metadata_t_has_time_spec_set, doc=r"""has_time_spec : bool""")
    time_spec = property(_uhd_swig.async_metadata_t_time_spec_get, _uhd_swig.async_metadata_t_time_spec_set, doc=r"""time_spec : uhd::time_spec_t""")
    EVENT_CODE_BURST_ACK = _uhd_swig.async_metadata_t_EVENT_CODE_BURST_ACK
    
    EVENT_CODE_UNDERFLOW = _uhd_swig.async_metadata_t_EVENT_CODE_UNDERFLOW
    
    EVENT_CODE_SEQ_ERROR = _uhd_swig.async_metadata_t_EVENT_CODE_SEQ_ERROR
    
    EVENT_CODE_TIME_ERROR = _uhd_swig.async_metadata_t_EVENT_CODE_TIME_ERROR
    
    EVENT_CODE_UNDERFLOW_IN_PACKET = _uhd_swig.async_metadata_t_EVENT_CODE_UNDERFLOW_IN_PACKET
    
    EVENT_CODE_SEQ_ERROR_IN_BURST = _uhd_swig.async_metadata_t_EVENT_CODE_SEQ_ERROR_IN_BURST
    
    EVENT_CODE_USER_PAYLOAD = _uhd_swig.async_metadata_t_EVENT_CODE_USER_PAYLOAD
    
    event_code = property(_uhd_swig.async_metadata_t_event_code_get, _uhd_swig.async_metadata_t_event_code_set, doc=r"""event_code : enum uhd::async_metadata_t::event_code_t""")
    user_payload = property(_uhd_swig.async_metadata_t_user_payload_get, _uhd_swig.async_metadata_t_user_payload_set, doc=r"""user_payload : a(4).uint32_t""")

    def __init__(self):
        r"""__init__(async_metadata_t self) -> async_metadata_t"""
        _uhd_swig.async_metadata_t_swiginit(self, _uhd_swig.new_async_metadata_t())
    __swig_destroy__ = _uhd_swig.delete_async_metadata_t

# Register async_metadata_t in _uhd_swig:
_uhd_swig.async_metadata_t_swigregister(async_metadata_t)

class device_addr_vector_t(object):
    r"""Proxy of C++ std::vector< uhd::device_addr_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(device_addr_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.device_addr_vector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(device_addr_vector_t self) -> bool"""
        return _uhd_swig.device_addr_vector_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(device_addr_vector_t self) -> bool"""
        return _uhd_swig.device_addr_vector_t___bool__(self)

    def __len__(self) -> "std::vector< uhd::device_addr_t >::size_type":
        r"""__len__(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::size_type"""
        return _uhd_swig.device_addr_vector_t___len__(self)

    def __getslice__(self, i: "std::vector< uhd::device_addr_t >::difference_type", j: "std::vector< uhd::device_addr_t >::difference_type") -> "std::vector< uhd::device_addr_t,std::allocator< uhd::device_addr_t > > *":
        r"""__getslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j) -> device_addr_vector_t"""
        return _uhd_swig.device_addr_vector_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j)
        __setslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j, device_addr_vector_t v)
        """
        return _uhd_swig.device_addr_vector_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< uhd::device_addr_t >::difference_type", j: "std::vector< uhd::device_addr_t >::difference_type") -> "void":
        r"""__delslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j)"""
        return _uhd_swig.device_addr_vector_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i)
        __delitem__(device_addr_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.device_addr_vector_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< uhd::device_addr_t >::value_type const &":
        r"""
        __getitem__(device_addr_vector_t self, PySliceObject * slice) -> device_addr_vector_t
        __getitem__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i) -> device_addr_t
        """
        return _uhd_swig.device_addr_vector_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(device_addr_vector_t self, PySliceObject * slice, device_addr_vector_t v)
        __setitem__(device_addr_vector_t self, PySliceObject * slice)
        __setitem__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, device_addr_t x)
        """
        return _uhd_swig.device_addr_vector_t___setitem__(self, *args)

    def pop(self) -> "std::vector< uhd::device_addr_t >::value_type":
        r"""pop(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_pop(self)

    def append(self, x: "device_addr_t") -> "void":
        r"""append(device_addr_vector_t self, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(device_addr_vector_t self) -> bool"""
        return _uhd_swig.device_addr_vector_t_empty(self)

    def size(self) -> "std::vector< uhd::device_addr_t >::size_type":
        r"""size(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::size_type"""
        return _uhd_swig.device_addr_vector_t_size(self)

    def swap(self, v: "device_addr_vector_t") -> "void":
        r"""swap(device_addr_vector_t self, device_addr_vector_t v)"""
        return _uhd_swig.device_addr_vector_t_swap(self, v)

    def begin(self) -> "std::vector< uhd::device_addr_t >::iterator":
        r"""begin(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::iterator"""
        return _uhd_swig.device_addr_vector_t_begin(self)

    def end(self) -> "std::vector< uhd::device_addr_t >::iterator":
        r"""end(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::iterator"""
        return _uhd_swig.device_addr_vector_t_end(self)

    def rbegin(self) -> "std::vector< uhd::device_addr_t >::reverse_iterator":
        r"""rbegin(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::reverse_iterator"""
        return _uhd_swig.device_addr_vector_t_rbegin(self)

    def rend(self) -> "std::vector< uhd::device_addr_t >::reverse_iterator":
        r"""rend(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::reverse_iterator"""
        return _uhd_swig.device_addr_vector_t_rend(self)

    def clear(self) -> "void":
        r"""clear(device_addr_vector_t self)"""
        return _uhd_swig.device_addr_vector_t_clear(self)

    def get_allocator(self) -> "std::vector< uhd::device_addr_t >::allocator_type":
        r"""get_allocator(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::allocator_type"""
        return _uhd_swig.device_addr_vector_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(device_addr_vector_t self)"""
        return _uhd_swig.device_addr_vector_t_pop_back(self)

    def erase(self, *args) -> "std::vector< uhd::device_addr_t >::iterator":
        r"""
        erase(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator pos) -> std::vector< uhd::device_addr_t >::iterator
        erase(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator first, std::vector< uhd::device_addr_t >::iterator last) -> std::vector< uhd::device_addr_t >::iterator
        """
        return _uhd_swig.device_addr_vector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(device_addr_vector_t self) -> device_addr_vector_t
        __init__(device_addr_vector_t self, device_addr_vector_t other) -> device_addr_vector_t
        __init__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type size) -> device_addr_vector_t
        __init__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type size, device_addr_t value) -> device_addr_vector_t
        """
        _uhd_swig.device_addr_vector_t_swiginit(self, _uhd_swig.new_device_addr_vector_t(*args))

    def push_back(self, x: "device_addr_t") -> "void":
        r"""push_back(device_addr_vector_t self, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_push_back(self, x)

    def front(self) -> "std::vector< uhd::device_addr_t >::value_type const &":
        r"""front(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_front(self)

    def back(self) -> "std::vector< uhd::device_addr_t >::value_type const &":
        r"""back(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_back(self)

    def assign(self, n: "std::vector< uhd::device_addr_t >::size_type", x: "device_addr_t") -> "void":
        r"""assign(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type n, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type new_size)
        resize(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type new_size, device_addr_t x)
        """
        return _uhd_swig.device_addr_vector_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator pos, device_addr_t x) -> std::vector< uhd::device_addr_t >::iterator
        insert(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator pos, std::vector< uhd::device_addr_t >::size_type n, device_addr_t x)
        """
        return _uhd_swig.device_addr_vector_t_insert(self, *args)

    def reserve(self, n: "std::vector< uhd::device_addr_t >::size_type") -> "void":
        r"""reserve(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type n)"""
        return _uhd_swig.device_addr_vector_t_reserve(self, n)

    def capacity(self) -> "std::vector< uhd::device_addr_t >::size_type":
        r"""capacity(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::size_type"""
        return _uhd_swig.device_addr_vector_t_capacity(self)
    __swig_destroy__ = _uhd_swig.delete_device_addr_vector_t

# Register device_addr_vector_t in _uhd_swig:
_uhd_swig.device_addr_vector_t_swigregister(device_addr_vector_t)

class sensor_value_t(object):
    r"""Proxy of C++ uhd::sensor_value_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sensor_value_t self, std::string const & name, bool value, std::string const & utrue, std::string const & ufalse) -> sensor_value_t
        __init__(sensor_value_t self, std::string const & name, int value, std::string const & unit, std::string const & formatter="%d") -> sensor_value_t
        __init__(sensor_value_t self, std::string const & name, double value, std::string const & unit, std::string const & formatter="%f") -> sensor_value_t
        __init__(sensor_value_t self, std::string const & name, std::string const & value, std::string const & unit) -> sensor_value_t
        __init__(sensor_value_t self, std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > const & sensor_dict) -> sensor_value_t
        __init__(sensor_value_t self, sensor_value_t source) -> sensor_value_t
        """
        _uhd_swig.sensor_value_t_swiginit(self, _uhd_swig.new_sensor_value_t(*args))

    def to_bool(self) -> "bool":
        r"""to_bool(sensor_value_t self) -> bool"""
        return _uhd_swig.sensor_value_t_to_bool(self)

    def to_int(self) -> "int":
        r"""to_int(sensor_value_t self) -> int"""
        return _uhd_swig.sensor_value_t_to_int(self)

    def to_real(self) -> "double":
        r"""to_real(sensor_value_t self) -> double"""
        return _uhd_swig.sensor_value_t_to_real(self)

    def to_map(self) -> "uhd::sensor_value_t::sensor_map_t":
        r"""to_map(sensor_value_t self) -> uhd::sensor_value_t::sensor_map_t"""
        return _uhd_swig.sensor_value_t_to_map(self)
    name = property(_uhd_swig.sensor_value_t_name_get, _uhd_swig.sensor_value_t_name_set, doc=r"""name : std::string""")
    value = property(_uhd_swig.sensor_value_t_value_get, _uhd_swig.sensor_value_t_value_set, doc=r"""value : std::string""")
    unit = property(_uhd_swig.sensor_value_t_unit_get, _uhd_swig.sensor_value_t_unit_set, doc=r"""unit : std::string""")
    BOOLEAN = _uhd_swig.sensor_value_t_BOOLEAN
    
    INTEGER = _uhd_swig.sensor_value_t_INTEGER
    
    REALNUM = _uhd_swig.sensor_value_t_REALNUM
    
    STRING = _uhd_swig.sensor_value_t_STRING
    
    type = property(_uhd_swig.sensor_value_t_type_get, _uhd_swig.sensor_value_t_type_set, doc=r"""type : uhd::sensor_value_t::data_type_t""")

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(sensor_value_t self) -> std::string"""
        return _uhd_swig.sensor_value_t_to_pp_string(self)
    __swig_destroy__ = _uhd_swig.delete_sensor_value_t

# Register sensor_value_t in _uhd_swig:
_uhd_swig.sensor_value_t_swigregister(sensor_value_t)

class stream_args_t(object):
    r"""Proxy of C++ uhd::stream_args_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        r"""__init__(stream_args_t self, std::string const & cpu="", std::string const & otw="") -> stream_args_t"""
        _uhd_swig.stream_args_t_swiginit(self, _uhd_swig.new_stream_args_t(*args, **kwargs))
    cpu_format = property(_uhd_swig.stream_args_t_cpu_format_get, _uhd_swig.stream_args_t_cpu_format_set, doc=r"""cpu_format : std::string""")
    otw_format = property(_uhd_swig.stream_args_t_otw_format_get, _uhd_swig.stream_args_t_otw_format_set, doc=r"""otw_format : std::string""")
    args = property(_uhd_swig.stream_args_t_args_get, _uhd_swig.stream_args_t_args_set, doc=r"""args : uhd::device_addr_t""")
    channels = property(_uhd_swig.stream_args_t_channels_get, _uhd_swig.stream_args_t_channels_set, doc=r"""channels : std::vector<(size_t,std::allocator<(size_t)>)>""")
    __swig_destroy__ = _uhd_swig.delete_stream_args_t

# Register stream_args_t in _uhd_swig:
_uhd_swig.stream_args_t_swigregister(stream_args_t)

class rx_streamer(object):
    r"""Proxy of C++ uhd::rx_streamer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_rx_streamer

    def get_num_channels(self) -> "size_t":
        r"""get_num_channels(rx_streamer self) -> size_t"""
        return _uhd_swig.rx_streamer_get_num_channels(self)

    def get_max_num_samps(self) -> "size_t":
        r"""get_max_num_samps(rx_streamer self) -> size_t"""
        return _uhd_swig.rx_streamer_get_max_num_samps(self)

    def recv(self, buffs: "uhd::rx_streamer::buffs_type const &", nsamps_per_buff: "size_t const", metadata: "rx_metadata_t", timeout: "double const"=0.1, one_packet: "bool const"=False) -> "size_t":
        r"""recv(rx_streamer self, uhd::rx_streamer::buffs_type const & buffs, size_t const nsamps_per_buff, rx_metadata_t metadata, double const timeout=0.1, bool const one_packet=False) -> size_t"""
        return _uhd_swig.rx_streamer_recv(self, buffs, nsamps_per_buff, metadata, timeout, one_packet)

    def issue_stream_cmd(self, stream_cmd: "stream_cmd_t") -> "void":
        r"""issue_stream_cmd(rx_streamer self, stream_cmd_t stream_cmd)"""
        return _uhd_swig.rx_streamer_issue_stream_cmd(self, stream_cmd)

# Register rx_streamer in _uhd_swig:
_uhd_swig.rx_streamer_swigregister(rx_streamer)

class tx_streamer(object):
    r"""Proxy of C++ uhd::tx_streamer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_tx_streamer

    def get_num_channels(self) -> "size_t":
        r"""get_num_channels(tx_streamer self) -> size_t"""
        return _uhd_swig.tx_streamer_get_num_channels(self)

    def get_max_num_samps(self) -> "size_t":
        r"""get_max_num_samps(tx_streamer self) -> size_t"""
        return _uhd_swig.tx_streamer_get_max_num_samps(self)

    def send(self, buffs: "uhd::tx_streamer::buffs_type const &", nsamps_per_buff: "size_t const", metadata: "tx_metadata_t", timeout: "double const"=0.1) -> "size_t":
        r"""send(tx_streamer self, uhd::tx_streamer::buffs_type const & buffs, size_t const nsamps_per_buff, tx_metadata_t metadata, double const timeout=0.1) -> size_t"""
        return _uhd_swig.tx_streamer_send(self, buffs, nsamps_per_buff, metadata, timeout)

    def recv_async_msg(self, async_metadata: "async_metadata_t", timeout: "double"=0.1) -> "bool":
        r"""recv_async_msg(tx_streamer self, async_metadata_t async_metadata, double timeout=0.1) -> bool"""
        return _uhd_swig.tx_streamer_recv_async_msg(self, async_metadata, timeout)

# Register tx_streamer in _uhd_swig:
_uhd_swig.tx_streamer_swigregister(tx_streamer)

class filter_info_base(object):
    r"""Proxy of C++ uhd::filter_info_base class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ANALOG_LOW_PASS = _uhd_swig.filter_info_base_ANALOG_LOW_PASS
    
    ANALOG_BAND_PASS = _uhd_swig.filter_info_base_ANALOG_BAND_PASS
    
    DIGITAL_I16 = _uhd_swig.filter_info_base_DIGITAL_I16
    
    DIGITAL_FIR_I16 = _uhd_swig.filter_info_base_DIGITAL_FIR_I16
    

    def __init__(self, type: "uhd::filter_info_base::filter_type", bypass: "bool", position_index: "size_t"):
        r"""__init__(filter_info_base self, uhd::filter_info_base::filter_type type, bool bypass, size_t position_index) -> filter_info_base"""
        _uhd_swig.filter_info_base_swiginit(self, _uhd_swig.new_filter_info_base(type, bypass, position_index))

    def is_bypassed(self) -> "bool":
        r"""is_bypassed(filter_info_base self) -> bool"""
        return _uhd_swig.filter_info_base_is_bypassed(self)

    def get_type(self) -> "uhd::filter_info_base::filter_type":
        r"""get_type(filter_info_base self) -> uhd::filter_info_base::filter_type"""
        return _uhd_swig.filter_info_base_get_type(self)
    __swig_destroy__ = _uhd_swig.delete_filter_info_base

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(filter_info_base self) -> std::string"""
        return _uhd_swig.filter_info_base_to_pp_string(self)

    def to_analog_info_base(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_base >":
        r"""to_analog_info_base(filter_info_base self, filter_info_base_sptr ptr) -> analog_filter_base_stpr"""
        return _uhd_swig.filter_info_base_to_analog_info_base(self, ptr)

    def to_analog_filter_lp(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_lp >":
        r"""to_analog_filter_lp(filter_info_base self, filter_info_base_sptr ptr) -> analog_filter_lp_stpr"""
        return _uhd_swig.filter_info_base_to_analog_filter_lp(self, ptr)

    def to_digital_filter_base_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_base< int16_t > >":
        r"""to_digital_filter_base_int16(filter_info_base self, filter_info_base_sptr ptr) -> digital_filter_base_int16_t_sptr"""
        return _uhd_swig.filter_info_base_to_digital_filter_base_int16(self, ptr)

    def to_digital_filter_fir_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_fir< int16_t > >":
        r"""to_digital_filter_fir_int16(filter_info_base self, filter_info_base_sptr ptr) -> digital_filter_fir_int16_t_sptr"""
        return _uhd_swig.filter_info_base_to_digital_filter_fir_int16(self, ptr)

# Register filter_info_base in _uhd_swig:
_uhd_swig.filter_info_base_swigregister(filter_info_base)


def __lshift__(os: "std::ostream &", f: "filter_info_base") -> "std::ostream &":
    r"""__lshift__(std::ostream & os, filter_info_base f) -> std::ostream &"""
    return _uhd_swig.__lshift__(os, f)
class analog_filter_base(filter_info_base):
    r"""Proxy of C++ uhd::analog_filter_base class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type: "uhd::filter_info_base::filter_type", bypass: "bool", position_index: "size_t", analog_type: "std::string const &"):
        r"""__init__(analog_filter_base self, uhd::filter_info_base::filter_type type, bool bypass, size_t position_index, std::string const & analog_type) -> analog_filter_base"""
        _uhd_swig.analog_filter_base_swiginit(self, _uhd_swig.new_analog_filter_base(type, bypass, position_index, analog_type))

    def get_analog_type(self) -> "std::string const &":
        r"""get_analog_type(analog_filter_base self) -> std::string const &"""
        return _uhd_swig.analog_filter_base_get_analog_type(self)
    __swig_destroy__ = _uhd_swig.delete_analog_filter_base

# Register analog_filter_base in _uhd_swig:
_uhd_swig.analog_filter_base_swigregister(analog_filter_base)

class analog_filter_lp(analog_filter_base):
    r"""Proxy of C++ uhd::analog_filter_lp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type: "uhd::filter_info_base::filter_type", bypass: "bool", position_index: "size_t", analog_type: "std::string const &", cutoff: "double", rolloff: "double"):
        r"""__init__(analog_filter_lp self, uhd::filter_info_base::filter_type type, bool bypass, size_t position_index, std::string const & analog_type, double cutoff, double rolloff) -> analog_filter_lp"""
        _uhd_swig.analog_filter_lp_swiginit(self, _uhd_swig.new_analog_filter_lp(type, bypass, position_index, analog_type, cutoff, rolloff))

    def get_cutoff(self) -> "double":
        r"""get_cutoff(analog_filter_lp self) -> double"""
        return _uhd_swig.analog_filter_lp_get_cutoff(self)

    def get_rolloff(self) -> "double":
        r"""get_rolloff(analog_filter_lp self) -> double"""
        return _uhd_swig.analog_filter_lp_get_rolloff(self)

    def set_cutoff(self, cutoff: "double const") -> "void":
        r"""set_cutoff(analog_filter_lp self, double const cutoff)"""
        return _uhd_swig.analog_filter_lp_set_cutoff(self, cutoff)
    __swig_destroy__ = _uhd_swig.delete_analog_filter_lp

# Register analog_filter_lp in _uhd_swig:
_uhd_swig.analog_filter_lp_swigregister(analog_filter_lp)

class uhd_vector_int16_t(object):
    r"""Proxy of C++ std::vector< int16_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(uhd_vector_int16_t self) -> SwigPyIterator"""
        return _uhd_swig.uhd_vector_int16_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(uhd_vector_int16_t self) -> bool"""
        return _uhd_swig.uhd_vector_int16_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(uhd_vector_int16_t self) -> bool"""
        return _uhd_swig.uhd_vector_int16_t___bool__(self)

    def __len__(self) -> "std::vector< short >::size_type":
        r"""__len__(uhd_vector_int16_t self) -> std::vector< short >::size_type"""
        return _uhd_swig.uhd_vector_int16_t___len__(self)

    def __getslice__(self, i: "std::vector< short >::difference_type", j: "std::vector< short >::difference_type") -> "std::vector< short,std::allocator< short > > *":
        r"""__getslice__(uhd_vector_int16_t self, std::vector< short >::difference_type i, std::vector< short >::difference_type j) -> std::vector< short,std::allocator< short > > *"""
        return _uhd_swig.uhd_vector_int16_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(uhd_vector_int16_t self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)
        __setslice__(uhd_vector_int16_t self, std::vector< short >::difference_type i, std::vector< short >::difference_type j, std::vector< short,std::allocator< short > > const & v)
        """
        return _uhd_swig.uhd_vector_int16_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< short >::difference_type", j: "std::vector< short >::difference_type") -> "void":
        r"""__delslice__(uhd_vector_int16_t self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)"""
        return _uhd_swig.uhd_vector_int16_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(uhd_vector_int16_t self, std::vector< short >::difference_type i)
        __delitem__(uhd_vector_int16_t self, PySliceObject * slice)
        """
        return _uhd_swig.uhd_vector_int16_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< short >::value_type const &":
        r"""
        __getitem__(uhd_vector_int16_t self, PySliceObject * slice) -> std::vector< short,std::allocator< short > >
        __getitem__(uhd_vector_int16_t self, std::vector< short >::difference_type i) -> std::vector< short >::value_type const &
        """
        return _uhd_swig.uhd_vector_int16_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(uhd_vector_int16_t self, PySliceObject * slice, std::vector< short,std::allocator< short > > const & v)
        __setitem__(uhd_vector_int16_t self, PySliceObject * slice)
        __setitem__(uhd_vector_int16_t self, std::vector< short >::difference_type i, std::vector< short >::value_type const & x)
        """
        return _uhd_swig.uhd_vector_int16_t___setitem__(self, *args)

    def pop(self) -> "std::vector< short >::value_type":
        r"""pop(uhd_vector_int16_t self) -> std::vector< short >::value_type"""
        return _uhd_swig.uhd_vector_int16_t_pop(self)

    def append(self, x: "std::vector< short >::value_type const &") -> "void":
        r"""append(uhd_vector_int16_t self, std::vector< short >::value_type const & x)"""
        return _uhd_swig.uhd_vector_int16_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(uhd_vector_int16_t self) -> bool"""
        return _uhd_swig.uhd_vector_int16_t_empty(self)

    def size(self) -> "std::vector< short >::size_type":
        r"""size(uhd_vector_int16_t self) -> std::vector< short >::size_type"""
        return _uhd_swig.uhd_vector_int16_t_size(self)

    def swap(self, v: "std::vector< int16_t > &") -> "void":
        r"""swap(uhd_vector_int16_t self, std::vector< int16_t > & v)"""
        return _uhd_swig.uhd_vector_int16_t_swap(self, v)

    def begin(self) -> "std::vector< short >::iterator":
        r"""begin(uhd_vector_int16_t self) -> std::vector< short >::iterator"""
        return _uhd_swig.uhd_vector_int16_t_begin(self)

    def end(self) -> "std::vector< short >::iterator":
        r"""end(uhd_vector_int16_t self) -> std::vector< short >::iterator"""
        return _uhd_swig.uhd_vector_int16_t_end(self)

    def rbegin(self) -> "std::vector< short >::reverse_iterator":
        r"""rbegin(uhd_vector_int16_t self) -> std::vector< short >::reverse_iterator"""
        return _uhd_swig.uhd_vector_int16_t_rbegin(self)

    def rend(self) -> "std::vector< short >::reverse_iterator":
        r"""rend(uhd_vector_int16_t self) -> std::vector< short >::reverse_iterator"""
        return _uhd_swig.uhd_vector_int16_t_rend(self)

    def clear(self) -> "void":
        r"""clear(uhd_vector_int16_t self)"""
        return _uhd_swig.uhd_vector_int16_t_clear(self)

    def get_allocator(self) -> "std::vector< short >::allocator_type":
        r"""get_allocator(uhd_vector_int16_t self) -> std::vector< short >::allocator_type"""
        return _uhd_swig.uhd_vector_int16_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(uhd_vector_int16_t self)"""
        return _uhd_swig.uhd_vector_int16_t_pop_back(self)

    def erase(self, *args) -> "std::vector< short >::iterator":
        r"""
        erase(uhd_vector_int16_t self, std::vector< short >::iterator pos) -> std::vector< short >::iterator
        erase(uhd_vector_int16_t self, std::vector< short >::iterator first, std::vector< short >::iterator last) -> std::vector< short >::iterator
        """
        return _uhd_swig.uhd_vector_int16_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(uhd_vector_int16_t self) -> uhd_vector_int16_t
        __init__(uhd_vector_int16_t self, std::vector< int16_t > const & other) -> uhd_vector_int16_t
        __init__(uhd_vector_int16_t self, std::vector< short >::size_type size) -> uhd_vector_int16_t
        __init__(uhd_vector_int16_t self, std::vector< short >::size_type size, std::vector< short >::value_type const & value) -> uhd_vector_int16_t
        """
        _uhd_swig.uhd_vector_int16_t_swiginit(self, _uhd_swig.new_uhd_vector_int16_t(*args))

    def push_back(self, x: "std::vector< short >::value_type const &") -> "void":
        r"""push_back(uhd_vector_int16_t self, std::vector< short >::value_type const & x)"""
        return _uhd_swig.uhd_vector_int16_t_push_back(self, x)

    def front(self) -> "std::vector< short >::value_type const &":
        r"""front(uhd_vector_int16_t self) -> std::vector< short >::value_type const &"""
        return _uhd_swig.uhd_vector_int16_t_front(self)

    def back(self) -> "std::vector< short >::value_type const &":
        r"""back(uhd_vector_int16_t self) -> std::vector< short >::value_type const &"""
        return _uhd_swig.uhd_vector_int16_t_back(self)

    def assign(self, n: "std::vector< short >::size_type", x: "std::vector< short >::value_type const &") -> "void":
        r"""assign(uhd_vector_int16_t self, std::vector< short >::size_type n, std::vector< short >::value_type const & x)"""
        return _uhd_swig.uhd_vector_int16_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(uhd_vector_int16_t self, std::vector< short >::size_type new_size)
        resize(uhd_vector_int16_t self, std::vector< short >::size_type new_size, std::vector< short >::value_type const & x)
        """
        return _uhd_swig.uhd_vector_int16_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(uhd_vector_int16_t self, std::vector< short >::iterator pos, std::vector< short >::value_type const & x) -> std::vector< short >::iterator
        insert(uhd_vector_int16_t self, std::vector< short >::iterator pos, std::vector< short >::size_type n, std::vector< short >::value_type const & x)
        """
        return _uhd_swig.uhd_vector_int16_t_insert(self, *args)

    def reserve(self, n: "std::vector< short >::size_type") -> "void":
        r"""reserve(uhd_vector_int16_t self, std::vector< short >::size_type n)"""
        return _uhd_swig.uhd_vector_int16_t_reserve(self, n)

    def capacity(self) -> "std::vector< short >::size_type":
        r"""capacity(uhd_vector_int16_t self) -> std::vector< short >::size_type"""
        return _uhd_swig.uhd_vector_int16_t_capacity(self)
    __swig_destroy__ = _uhd_swig.delete_uhd_vector_int16_t

# Register uhd_vector_int16_t in _uhd_swig:
_uhd_swig.uhd_vector_int16_t_swigregister(uhd_vector_int16_t)

class i2c_iface(object):
    r"""Proxy of C++ uhd::i2c_iface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_i2c_iface

    def eeprom16(self) -> "uhd::i2c_iface::sptr":
        r"""eeprom16(i2c_iface self) -> uhd::i2c_iface::sptr"""
        return _uhd_swig.i2c_iface_eeprom16(self)

    def write_i2c(self, addr: "uint16_t", buf: "uhd::byte_vector_t const &") -> "void":
        r"""write_i2c(i2c_iface self, uint16_t addr, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.i2c_iface_write_i2c(self, addr, buf)

    def read_i2c(self, addr: "uint16_t", num_bytes: "size_t") -> "uhd::byte_vector_t":
        r"""read_i2c(i2c_iface self, uint16_t addr, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.i2c_iface_read_i2c(self, addr, num_bytes)

    def write_eeprom(self, addr: "uint16_t", offset: "uint16_t", buf: "uhd::byte_vector_t const &") -> "void":
        r"""write_eeprom(i2c_iface self, uint16_t addr, uint16_t offset, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.i2c_iface_write_eeprom(self, addr, offset, buf)

    def read_eeprom(self, addr: "uint16_t", offset: "uint16_t", num_bytes: "size_t") -> "uhd::byte_vector_t":
        r"""read_eeprom(i2c_iface self, uint16_t addr, uint16_t offset, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.i2c_iface_read_eeprom(self, addr, offset, num_bytes)

# Register i2c_iface in _uhd_swig:
_uhd_swig.i2c_iface_swigregister(i2c_iface)

class spi_config_t(object):
    r"""Proxy of C++ uhd::spi_config_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    EDGE_RISE = _uhd_swig.spi_config_t_EDGE_RISE
    
    EDGE_FALL = _uhd_swig.spi_config_t_EDGE_FALL
    
    mosi_edge = property(_uhd_swig.spi_config_t_mosi_edge_get, _uhd_swig.spi_config_t_mosi_edge_set, doc=r"""mosi_edge : uhd::spi_config_t::edge_t""")
    miso_edge = property(_uhd_swig.spi_config_t_miso_edge_get, _uhd_swig.spi_config_t_miso_edge_set, doc=r"""miso_edge : uhd::spi_config_t::edge_t""")
    use_custom_divider = property(_uhd_swig.spi_config_t_use_custom_divider_get, _uhd_swig.spi_config_t_use_custom_divider_set, doc=r"""use_custom_divider : bool""")
    divider = property(_uhd_swig.spi_config_t_divider_get, _uhd_swig.spi_config_t_divider_set, doc=r"""divider : size_t""")

    def __init__(self, *args, **kwargs):
        r"""__init__(spi_config_t self, uhd::spi_config_t::edge_t edge=EDGE_RISE) -> spi_config_t"""
        _uhd_swig.spi_config_t_swiginit(self, _uhd_swig.new_spi_config_t(*args, **kwargs))
    __swig_destroy__ = _uhd_swig.delete_spi_config_t

# Register spi_config_t in _uhd_swig:
_uhd_swig.spi_config_t_swigregister(spi_config_t)

class spi_iface(object):
    r"""Proxy of C++ uhd::spi_iface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_spi_iface

    def transact_spi(self, which_slave: "int", config: "spi_config_t", data: "uint32_t", num_bits: "size_t", readback: "bool") -> "uint32_t":
        r"""transact_spi(spi_iface self, int which_slave, spi_config_t config, uint32_t data, size_t num_bits, bool readback) -> uint32_t"""
        return _uhd_swig.spi_iface_transact_spi(self, which_slave, config, data, num_bits, readback)

    def read_spi(self, which_slave: "int", config: "spi_config_t", data: "uint32_t", num_bits: "size_t") -> "uint32_t":
        r"""read_spi(spi_iface self, int which_slave, spi_config_t config, uint32_t data, size_t num_bits) -> uint32_t"""
        return _uhd_swig.spi_iface_read_spi(self, which_slave, config, data, num_bits)

    def write_spi(self, which_slave: "int", config: "spi_config_t", data: "uint32_t", num_bits: "size_t") -> "void":
        r"""write_spi(spi_iface self, int which_slave, spi_config_t config, uint32_t data, size_t num_bits)"""
        return _uhd_swig.spi_iface_write_spi(self, which_slave, config, data, num_bits)

# Register spi_iface in _uhd_swig:
_uhd_swig.spi_iface_swigregister(spi_iface)

class uart_iface(object):
    r"""Proxy of C++ uhd::uart_iface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_uart_iface

    def write_uart(self, buf: "std::string const &") -> "void":
        r"""write_uart(uart_iface self, std::string const & buf)"""
        return _uhd_swig.uart_iface_write_uart(self, buf)

    def read_uart(self, timeout: "double") -> "std::string":
        r"""read_uart(uart_iface self, double timeout) -> std::string"""
        return _uhd_swig.uart_iface_read_uart(self, timeout)

# Register uart_iface in _uhd_swig:
_uhd_swig.uart_iface_swigregister(uart_iface)

class dboard_iface_special_props_t(object):
    r"""Proxy of C++ uhd::usrp::dboard_iface_special_props_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    soft_clock_divider = property(_uhd_swig.dboard_iface_special_props_t_soft_clock_divider_get, _uhd_swig.dboard_iface_special_props_t_soft_clock_divider_set, doc=r"""soft_clock_divider : bool""")
    mangle_i2c_addrs = property(_uhd_swig.dboard_iface_special_props_t_mangle_i2c_addrs_get, _uhd_swig.dboard_iface_special_props_t_mangle_i2c_addrs_set, doc=r"""mangle_i2c_addrs : bool""")

    def __init__(self):
        r"""__init__(dboard_iface_special_props_t self) -> dboard_iface_special_props_t"""
        _uhd_swig.dboard_iface_special_props_t_swiginit(self, _uhd_swig.new_dboard_iface_special_props_t())
    __swig_destroy__ = _uhd_swig.delete_dboard_iface_special_props_t

# Register dboard_iface_special_props_t in _uhd_swig:
_uhd_swig.dboard_iface_special_props_t_swigregister(dboard_iface_special_props_t)

class dboard_iface(i2c_iface):
    r"""Proxy of C++ uhd::usrp::dboard_iface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    UNIT_RX = _uhd_swig.dboard_iface_UNIT_RX
    
    UNIT_TX = _uhd_swig.dboard_iface_UNIT_TX
    
    UNIT_BOTH = _uhd_swig.dboard_iface_UNIT_BOTH
    
    AUX_DAC_A = _uhd_swig.dboard_iface_AUX_DAC_A
    
    AUX_DAC_B = _uhd_swig.dboard_iface_AUX_DAC_B
    
    AUX_DAC_C = _uhd_swig.dboard_iface_AUX_DAC_C
    
    AUX_DAC_D = _uhd_swig.dboard_iface_AUX_DAC_D
    
    AUX_ADC_A = _uhd_swig.dboard_iface_AUX_ADC_A
    
    AUX_ADC_B = _uhd_swig.dboard_iface_AUX_ADC_B
    
    __swig_destroy__ = _uhd_swig.delete_dboard_iface

    def get_special_props(self) -> "uhd::usrp::dboard_iface::special_props_t":
        r"""get_special_props(dboard_iface self) -> dboard_iface_special_props_t"""
        return _uhd_swig.dboard_iface_get_special_props(self)

    def write_aux_dac(self, unit: "uhd::usrp::dboard_iface::unit_t", which_dac: "uhd::usrp::dboard_iface::aux_dac_t", value: "double") -> "void":
        r"""write_aux_dac(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_dac_t which_dac, double value)"""
        return _uhd_swig.dboard_iface_write_aux_dac(self, unit, which_dac, value)

    def read_aux_adc(self, unit: "uhd::usrp::dboard_iface::unit_t", which_adc: "uhd::usrp::dboard_iface::aux_adc_t") -> "double":
        r"""read_aux_adc(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_adc_t which_adc) -> double"""
        return _uhd_swig.dboard_iface_read_aux_adc(self, unit, which_adc)

    def set_pin_ctrl(self, unit: "uhd::usrp::dboard_iface::unit_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_pin_ctrl(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_set_pin_ctrl(self, unit, value, mask)

    def get_pin_ctrl(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""get_pin_ctrl(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_pin_ctrl(self, unit)

    def set_atr_reg(self, unit: "uhd::usrp::dboard_iface::unit_t", reg: "uhd::usrp::dboard_iface::atr_reg_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_atr_reg(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_set_atr_reg(self, unit, reg, value, mask)

    def get_atr_reg(self, unit: "uhd::usrp::dboard_iface::unit_t", reg: "uhd::usrp::dboard_iface::atr_reg_t") -> "uint32_t":
        r"""get_atr_reg(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_atr_reg(self, unit, reg)

    def set_gpio_ddr(self, unit: "uhd::usrp::dboard_iface::unit_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_gpio_ddr(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_set_gpio_ddr(self, unit, value, mask)

    def get_gpio_ddr(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""get_gpio_ddr(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_gpio_ddr(self, unit)

    def set_gpio_out(self, unit: "uhd::usrp::dboard_iface::unit_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_gpio_out(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_set_gpio_out(self, unit, value, mask)

    def get_gpio_out(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""get_gpio_out(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_gpio_out(self, unit)

    def read_gpio(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""read_gpio(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_read_gpio(self, unit)

    def write_spi(self, unit: "uhd::usrp::dboard_iface::unit_t", config: "spi_config_t", data: "uint32_t", num_bits: "size_t") -> "void":
        r"""write_spi(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits)"""
        return _uhd_swig.dboard_iface_write_spi(self, unit, config, data, num_bits)

    def read_write_spi(self, unit: "uhd::usrp::dboard_iface::unit_t", config: "spi_config_t", data: "uint32_t", num_bits: "size_t") -> "uint32_t":
        r"""read_write_spi(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits) -> uint32_t"""
        return _uhd_swig.dboard_iface_read_write_spi(self, unit, config, data, num_bits)

    def set_clock_rate(self, unit: "uhd::usrp::dboard_iface::unit_t", rate: "double") -> "void":
        r"""set_clock_rate(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, double rate)"""
        return _uhd_swig.dboard_iface_set_clock_rate(self, unit, rate)

    def get_clock_rate(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "double":
        r"""get_clock_rate(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_get_clock_rate(self, unit)

    def get_clock_rates(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "std::vector< double,std::allocator< double > >":
        r"""get_clock_rates(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> pmt_vector_double"""
        return _uhd_swig.dboard_iface_get_clock_rates(self, unit)

    def set_clock_enabled(self, unit: "uhd::usrp::dboard_iface::unit_t", enb: "bool") -> "void":
        r"""set_clock_enabled(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, bool enb)"""
        return _uhd_swig.dboard_iface_set_clock_enabled(self, unit, enb)

    def get_codec_rate(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "double":
        r"""get_codec_rate(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_get_codec_rate(self, unit)

    def set_fe_connection(self, unit: "uhd::usrp::dboard_iface::unit_t", fe_name: "std::string const &", fe_conn: "uhd::usrp::fe_connection_t const &") -> "void":
        r"""set_fe_connection(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, std::string const & fe_name, uhd::usrp::fe_connection_t const & fe_conn)"""
        return _uhd_swig.dboard_iface_set_fe_connection(self, unit, fe_name, fe_conn)

    def has_set_fe_connection(self, arg2: "uhd::usrp::dboard_iface::unit_t const") -> "bool":
        r"""has_set_fe_connection(dboard_iface self, uhd::usrp::dboard_iface::unit_t const arg2) -> bool"""
        return _uhd_swig.dboard_iface_has_set_fe_connection(self, arg2)

    def get_command_time(self) -> "uhd::time_spec_t":
        r"""get_command_time(dboard_iface self) -> time_spec_t"""
        return _uhd_swig.dboard_iface_get_command_time(self)

    def set_command_time(self, t: "time_spec_t") -> "void":
        r"""set_command_time(dboard_iface self, time_spec_t t)"""
        return _uhd_swig.dboard_iface_set_command_time(self, t)

    def sleep(self, time: "boost::chrono::nanoseconds const &") -> "void":
        r"""sleep(dboard_iface self, boost::chrono::nanoseconds const & time)"""
        return _uhd_swig.dboard_iface_sleep(self, time)

# Register dboard_iface in _uhd_swig:
_uhd_swig.dboard_iface_swigregister(dboard_iface)

class filter_info_base_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< uhd::filter_info_base > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(filter_info_base_sptr self) -> filter_info_base_sptr
        __init__(filter_info_base_sptr self, filter_info_base p) -> filter_info_base_sptr
        """
        _uhd_swig.filter_info_base_sptr_swiginit(self, _uhd_swig.new_filter_info_base_sptr(*args))

    def __deref__(self) -> "uhd::filter_info_base *":
        r"""__deref__(filter_info_base_sptr self) -> filter_info_base"""
        return _uhd_swig.filter_info_base_sptr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_filter_info_base_sptr

    def is_bypassed(self) -> "bool":
        r"""is_bypassed(filter_info_base_sptr self) -> bool"""
        return _uhd_swig.filter_info_base_sptr_is_bypassed(self)

    def get_type(self) -> "uhd::filter_info_base::filter_type":
        r"""get_type(filter_info_base_sptr self) -> uhd::filter_info_base::filter_type"""
        return _uhd_swig.filter_info_base_sptr_get_type(self)

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(filter_info_base_sptr self) -> std::string"""
        return _uhd_swig.filter_info_base_sptr_to_pp_string(self)

    def to_analog_info_base(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_base >":
        r"""to_analog_info_base(filter_info_base_sptr self, filter_info_base_sptr ptr) -> analog_filter_base_stpr"""
        return _uhd_swig.filter_info_base_sptr_to_analog_info_base(self, ptr)

    def to_analog_filter_lp(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_lp >":
        r"""to_analog_filter_lp(filter_info_base_sptr self, filter_info_base_sptr ptr) -> analog_filter_lp_stpr"""
        return _uhd_swig.filter_info_base_sptr_to_analog_filter_lp(self, ptr)

    def to_digital_filter_base_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_base< int16_t > >":
        r"""to_digital_filter_base_int16(filter_info_base_sptr self, filter_info_base_sptr ptr) -> digital_filter_base_int16_t_sptr"""
        return _uhd_swig.filter_info_base_sptr_to_digital_filter_base_int16(self, ptr)

    def to_digital_filter_fir_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_fir< int16_t > >":
        r"""to_digital_filter_fir_int16(filter_info_base_sptr self, filter_info_base_sptr ptr) -> digital_filter_fir_int16_t_sptr"""
        return _uhd_swig.filter_info_base_sptr_to_digital_filter_fir_int16(self, ptr)

# Register filter_info_base_sptr in _uhd_swig:
_uhd_swig.filter_info_base_sptr_swigregister(filter_info_base_sptr)

class analog_filter_base_stpr(object):
    r"""Proxy of C++ boost::shared_ptr< uhd::analog_filter_base > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(analog_filter_base_stpr self) -> analog_filter_base_stpr
        __init__(analog_filter_base_stpr self, analog_filter_base p) -> analog_filter_base_stpr
        """
        _uhd_swig.analog_filter_base_stpr_swiginit(self, _uhd_swig.new_analog_filter_base_stpr(*args))

    def __deref__(self) -> "uhd::analog_filter_base *":
        r"""__deref__(analog_filter_base_stpr self) -> analog_filter_base"""
        return _uhd_swig.analog_filter_base_stpr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_analog_filter_base_stpr

    def get_analog_type(self) -> "std::string const &":
        r"""get_analog_type(analog_filter_base_stpr self) -> std::string const &"""
        return _uhd_swig.analog_filter_base_stpr_get_analog_type(self)

    def is_bypassed(self) -> "bool":
        r"""is_bypassed(analog_filter_base_stpr self) -> bool"""
        return _uhd_swig.analog_filter_base_stpr_is_bypassed(self)

    def get_type(self) -> "uhd::filter_info_base::filter_type":
        r"""get_type(analog_filter_base_stpr self) -> uhd::filter_info_base::filter_type"""
        return _uhd_swig.analog_filter_base_stpr_get_type(self)

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(analog_filter_base_stpr self) -> std::string"""
        return _uhd_swig.analog_filter_base_stpr_to_pp_string(self)

    def to_analog_info_base(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_base >":
        r"""to_analog_info_base(analog_filter_base_stpr self, filter_info_base_sptr ptr) -> analog_filter_base_stpr"""
        return _uhd_swig.analog_filter_base_stpr_to_analog_info_base(self, ptr)

    def to_analog_filter_lp(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_lp >":
        r"""to_analog_filter_lp(analog_filter_base_stpr self, filter_info_base_sptr ptr) -> analog_filter_lp_stpr"""
        return _uhd_swig.analog_filter_base_stpr_to_analog_filter_lp(self, ptr)

    def to_digital_filter_base_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_base< int16_t > >":
        r"""to_digital_filter_base_int16(analog_filter_base_stpr self, filter_info_base_sptr ptr) -> digital_filter_base_int16_t_sptr"""
        return _uhd_swig.analog_filter_base_stpr_to_digital_filter_base_int16(self, ptr)

    def to_digital_filter_fir_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_fir< int16_t > >":
        r"""to_digital_filter_fir_int16(analog_filter_base_stpr self, filter_info_base_sptr ptr) -> digital_filter_fir_int16_t_sptr"""
        return _uhd_swig.analog_filter_base_stpr_to_digital_filter_fir_int16(self, ptr)

# Register analog_filter_base_stpr in _uhd_swig:
_uhd_swig.analog_filter_base_stpr_swigregister(analog_filter_base_stpr)

class analog_filter_lp_stpr(object):
    r"""Proxy of C++ boost::shared_ptr< uhd::analog_filter_lp > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(analog_filter_lp_stpr self) -> analog_filter_lp_stpr
        __init__(analog_filter_lp_stpr self, analog_filter_lp p) -> analog_filter_lp_stpr
        """
        _uhd_swig.analog_filter_lp_stpr_swiginit(self, _uhd_swig.new_analog_filter_lp_stpr(*args))

    def __deref__(self) -> "uhd::analog_filter_lp *":
        r"""__deref__(analog_filter_lp_stpr self) -> analog_filter_lp"""
        return _uhd_swig.analog_filter_lp_stpr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_analog_filter_lp_stpr

    def get_cutoff(self) -> "double":
        r"""get_cutoff(analog_filter_lp_stpr self) -> double"""
        return _uhd_swig.analog_filter_lp_stpr_get_cutoff(self)

    def get_rolloff(self) -> "double":
        r"""get_rolloff(analog_filter_lp_stpr self) -> double"""
        return _uhd_swig.analog_filter_lp_stpr_get_rolloff(self)

    def set_cutoff(self, cutoff: "double const") -> "void":
        r"""set_cutoff(analog_filter_lp_stpr self, double const cutoff)"""
        return _uhd_swig.analog_filter_lp_stpr_set_cutoff(self, cutoff)

    def get_analog_type(self) -> "std::string const &":
        r"""get_analog_type(analog_filter_lp_stpr self) -> std::string const &"""
        return _uhd_swig.analog_filter_lp_stpr_get_analog_type(self)

    def is_bypassed(self) -> "bool":
        r"""is_bypassed(analog_filter_lp_stpr self) -> bool"""
        return _uhd_swig.analog_filter_lp_stpr_is_bypassed(self)

    def get_type(self) -> "uhd::filter_info_base::filter_type":
        r"""get_type(analog_filter_lp_stpr self) -> uhd::filter_info_base::filter_type"""
        return _uhd_swig.analog_filter_lp_stpr_get_type(self)

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(analog_filter_lp_stpr self) -> std::string"""
        return _uhd_swig.analog_filter_lp_stpr_to_pp_string(self)

    def to_analog_info_base(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_base >":
        r"""to_analog_info_base(analog_filter_lp_stpr self, filter_info_base_sptr ptr) -> analog_filter_base_stpr"""
        return _uhd_swig.analog_filter_lp_stpr_to_analog_info_base(self, ptr)

    def to_analog_filter_lp(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::analog_filter_lp >":
        r"""to_analog_filter_lp(analog_filter_lp_stpr self, filter_info_base_sptr ptr) -> analog_filter_lp_stpr"""
        return _uhd_swig.analog_filter_lp_stpr_to_analog_filter_lp(self, ptr)

    def to_digital_filter_base_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_base< int16_t > >":
        r"""to_digital_filter_base_int16(analog_filter_lp_stpr self, filter_info_base_sptr ptr) -> digital_filter_base_int16_t_sptr"""
        return _uhd_swig.analog_filter_lp_stpr_to_digital_filter_base_int16(self, ptr)

    def to_digital_filter_fir_int16(self, ptr: "filter_info_base_sptr") -> "boost::shared_ptr< uhd::digital_filter_fir< int16_t > >":
        r"""to_digital_filter_fir_int16(analog_filter_lp_stpr self, filter_info_base_sptr ptr) -> digital_filter_fir_int16_t_sptr"""
        return _uhd_swig.analog_filter_lp_stpr_to_digital_filter_fir_int16(self, ptr)

# Register analog_filter_lp_stpr in _uhd_swig:
_uhd_swig.analog_filter_lp_stpr_swigregister(analog_filter_lp_stpr)

class digital_filter_base_int16_t_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< uhd::digital_filter_base< int16_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(digital_filter_base_int16_t_sptr self) -> digital_filter_base_int16_t_sptr
        __init__(digital_filter_base_int16_t_sptr self, uhd::digital_filter_base< short > * p) -> digital_filter_base_int16_t_sptr
        """
        _uhd_swig.digital_filter_base_int16_t_sptr_swiginit(self, _uhd_swig.new_digital_filter_base_int16_t_sptr(*args))

    def __deref__(self) -> "uhd::digital_filter_base< short > *":
        r"""__deref__(digital_filter_base_int16_t_sptr self) -> uhd::digital_filter_base< short > *"""
        return _uhd_swig.digital_filter_base_int16_t_sptr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_digital_filter_base_int16_t_sptr

# Register digital_filter_base_int16_t_sptr in _uhd_swig:
_uhd_swig.digital_filter_base_int16_t_sptr_swigregister(digital_filter_base_int16_t_sptr)

class digital_filter_fir_int16_t_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< uhd::digital_filter_fir< int16_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(digital_filter_fir_int16_t_sptr self) -> digital_filter_fir_int16_t_sptr
        __init__(digital_filter_fir_int16_t_sptr self, uhd::digital_filter_fir< short > * p) -> digital_filter_fir_int16_t_sptr
        """
        _uhd_swig.digital_filter_fir_int16_t_sptr_swiginit(self, _uhd_swig.new_digital_filter_fir_int16_t_sptr(*args))

    def __deref__(self) -> "uhd::digital_filter_fir< short > *":
        r"""__deref__(digital_filter_fir_int16_t_sptr self) -> uhd::digital_filter_fir< short > *"""
        return _uhd_swig.digital_filter_fir_int16_t_sptr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_digital_filter_fir_int16_t_sptr

# Register digital_filter_fir_int16_t_sptr in _uhd_swig:
_uhd_swig.digital_filter_fir_int16_t_sptr_swigregister(digital_filter_fir_int16_t_sptr)

class dboard_iface_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< uhd::usrp::dboard_iface > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(dboard_iface_sptr self) -> dboard_iface_sptr
        __init__(dboard_iface_sptr self, dboard_iface p) -> dboard_iface_sptr
        """
        _uhd_swig.dboard_iface_sptr_swiginit(self, _uhd_swig.new_dboard_iface_sptr(*args))

    def __deref__(self) -> "uhd::usrp::dboard_iface *":
        r"""__deref__(dboard_iface_sptr self) -> dboard_iface"""
        return _uhd_swig.dboard_iface_sptr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_dboard_iface_sptr

    def get_special_props(self) -> "uhd::usrp::dboard_iface::special_props_t":
        r"""get_special_props(dboard_iface_sptr self) -> dboard_iface_special_props_t"""
        return _uhd_swig.dboard_iface_sptr_get_special_props(self)

    def write_aux_dac(self, unit: "uhd::usrp::dboard_iface::unit_t", which_dac: "uhd::usrp::dboard_iface::aux_dac_t", value: "double") -> "void":
        r"""write_aux_dac(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_dac_t which_dac, double value)"""
        return _uhd_swig.dboard_iface_sptr_write_aux_dac(self, unit, which_dac, value)

    def read_aux_adc(self, unit: "uhd::usrp::dboard_iface::unit_t", which_adc: "uhd::usrp::dboard_iface::aux_adc_t") -> "double":
        r"""read_aux_adc(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_adc_t which_adc) -> double"""
        return _uhd_swig.dboard_iface_sptr_read_aux_adc(self, unit, which_adc)

    def set_pin_ctrl(self, unit: "uhd::usrp::dboard_iface::unit_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_pin_ctrl(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_sptr_set_pin_ctrl(self, unit, value, mask)

    def get_pin_ctrl(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""get_pin_ctrl(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_pin_ctrl(self, unit)

    def set_atr_reg(self, unit: "uhd::usrp::dboard_iface::unit_t", reg: "uhd::usrp::dboard_iface::atr_reg_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_atr_reg(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_sptr_set_atr_reg(self, unit, reg, value, mask)

    def get_atr_reg(self, unit: "uhd::usrp::dboard_iface::unit_t", reg: "uhd::usrp::dboard_iface::atr_reg_t") -> "uint32_t":
        r"""get_atr_reg(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_atr_reg(self, unit, reg)

    def set_gpio_ddr(self, unit: "uhd::usrp::dboard_iface::unit_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_gpio_ddr(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_sptr_set_gpio_ddr(self, unit, value, mask)

    def get_gpio_ddr(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""get_gpio_ddr(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_gpio_ddr(self, unit)

    def set_gpio_out(self, unit: "uhd::usrp::dboard_iface::unit_t", value: "uint32_t", mask: "uint32_t"=0xffff) -> "void":
        r"""set_gpio_out(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask=0xffff)"""
        return _uhd_swig.dboard_iface_sptr_set_gpio_out(self, unit, value, mask)

    def get_gpio_out(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""get_gpio_out(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_gpio_out(self, unit)

    def read_gpio(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "uint32_t":
        r"""read_gpio(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_read_gpio(self, unit)

    def write_spi(self, unit: "uhd::usrp::dboard_iface::unit_t", config: "spi_config_t", data: "uint32_t", num_bits: "size_t") -> "void":
        r"""write_spi(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits)"""
        return _uhd_swig.dboard_iface_sptr_write_spi(self, unit, config, data, num_bits)

    def read_write_spi(self, unit: "uhd::usrp::dboard_iface::unit_t", config: "spi_config_t", data: "uint32_t", num_bits: "size_t") -> "uint32_t":
        r"""read_write_spi(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_read_write_spi(self, unit, config, data, num_bits)

    def set_clock_rate(self, unit: "uhd::usrp::dboard_iface::unit_t", rate: "double") -> "void":
        r"""set_clock_rate(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, double rate)"""
        return _uhd_swig.dboard_iface_sptr_set_clock_rate(self, unit, rate)

    def get_clock_rate(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "double":
        r"""get_clock_rate(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_sptr_get_clock_rate(self, unit)

    def get_clock_rates(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "std::vector< double,std::allocator< double > >":
        r"""get_clock_rates(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> pmt_vector_double"""
        return _uhd_swig.dboard_iface_sptr_get_clock_rates(self, unit)

    def set_clock_enabled(self, unit: "uhd::usrp::dboard_iface::unit_t", enb: "bool") -> "void":
        r"""set_clock_enabled(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, bool enb)"""
        return _uhd_swig.dboard_iface_sptr_set_clock_enabled(self, unit, enb)

    def get_codec_rate(self, unit: "uhd::usrp::dboard_iface::unit_t") -> "double":
        r"""get_codec_rate(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_sptr_get_codec_rate(self, unit)

    def set_fe_connection(self, unit: "uhd::usrp::dboard_iface::unit_t", fe_name: "std::string const &", fe_conn: "uhd::usrp::fe_connection_t const &") -> "void":
        r"""set_fe_connection(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, std::string const & fe_name, uhd::usrp::fe_connection_t const & fe_conn)"""
        return _uhd_swig.dboard_iface_sptr_set_fe_connection(self, unit, fe_name, fe_conn)

    def has_set_fe_connection(self, arg2: "uhd::usrp::dboard_iface::unit_t const") -> "bool":
        r"""has_set_fe_connection(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t const arg2) -> bool"""
        return _uhd_swig.dboard_iface_sptr_has_set_fe_connection(self, arg2)

    def get_command_time(self) -> "uhd::time_spec_t":
        r"""get_command_time(dboard_iface_sptr self) -> time_spec_t"""
        return _uhd_swig.dboard_iface_sptr_get_command_time(self)

    def set_command_time(self, t: "time_spec_t") -> "void":
        r"""set_command_time(dboard_iface_sptr self, time_spec_t t)"""
        return _uhd_swig.dboard_iface_sptr_set_command_time(self, t)

    def sleep(self, time: "boost::chrono::nanoseconds const &") -> "void":
        r"""sleep(dboard_iface_sptr self, boost::chrono::nanoseconds const & time)"""
        return _uhd_swig.dboard_iface_sptr_sleep(self, time)

    def eeprom16(self) -> "uhd::i2c_iface::sptr":
        r"""eeprom16(dboard_iface_sptr self) -> uhd::i2c_iface::sptr"""
        return _uhd_swig.dboard_iface_sptr_eeprom16(self)

    def write_i2c(self, addr: "uint16_t", buf: "uhd::byte_vector_t const &") -> "void":
        r"""write_i2c(dboard_iface_sptr self, uint16_t addr, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.dboard_iface_sptr_write_i2c(self, addr, buf)

    def read_i2c(self, addr: "uint16_t", num_bytes: "size_t") -> "uhd::byte_vector_t":
        r"""read_i2c(dboard_iface_sptr self, uint16_t addr, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.dboard_iface_sptr_read_i2c(self, addr, num_bytes)

    def write_eeprom(self, addr: "uint16_t", offset: "uint16_t", buf: "uhd::byte_vector_t const &") -> "void":
        r"""write_eeprom(dboard_iface_sptr self, uint16_t addr, uint16_t offset, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.dboard_iface_sptr_write_eeprom(self, addr, offset, buf)

    def read_eeprom(self, addr: "uint16_t", offset: "uint16_t", num_bytes: "size_t") -> "uhd::byte_vector_t":
        r"""read_eeprom(dboard_iface_sptr self, uint16_t addr, uint16_t offset, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.dboard_iface_sptr_read_eeprom(self, addr, offset, num_bytes)

# Register dboard_iface_sptr in _uhd_swig:
_uhd_swig.dboard_iface_sptr_swigregister(dboard_iface_sptr)

class usrp_source(usrp_block):
    r"""Proxy of C++ gr::uhd::usrp_source class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(device_addr: "device_addr_t", stream_args: "stream_args_t", issue_stream_cmd_on_start: "bool const"=True) -> "gr::uhd::usrp_source::sptr":
        r"""make(device_addr_t device_addr, stream_args_t stream_args, bool const issue_stream_cmd_on_start=True) -> usrp_source_sptr"""
        return _uhd_swig.usrp_source_make(device_addr, stream_args, issue_stream_cmd_on_start)

    def set_start_time(self, time: "time_spec_t") -> "void":
        r"""set_start_time(usrp_source self, time_spec_t time)"""
        return _uhd_swig.usrp_source_set_start_time(self, time)

    def issue_stream_cmd(self, cmd: "stream_cmd_t") -> "void":
        r"""issue_stream_cmd(usrp_source self, stream_cmd_t cmd)"""
        return _uhd_swig.usrp_source_issue_stream_cmd(self, cmd)

    def set_recv_timeout(self, timeout: "double const", one_packet: "bool const"=True) -> "void":
        r"""set_recv_timeout(usrp_source self, double const timeout, bool const one_packet=True)"""
        return _uhd_swig.usrp_source_set_recv_timeout(self, timeout, one_packet)

    def get_usrp_info(self, chan: "size_t"=0) -> "::uhd::dict< std::string,std::string >":
        r"""get_usrp_info(usrp_source self, size_t chan=0) -> string_string_dict_t"""
        return _uhd_swig.usrp_source_get_usrp_info(self, chan)

    def get_lo_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_names(usrp_source self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_get_lo_names(self, chan)

    def set_lo_source(self, src: "std::string const &", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_source(usrp_source self, std::string const & src, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_lo_source(self, src, name, chan)

    def get_lo_source(self, name: "std::string const &", chan: "size_t"=0) -> "std::string const":
        r"""get_lo_source(usrp_source self, std::string const & name, size_t chan=0) -> std::string const"""
        return _uhd_swig.usrp_source_get_lo_source(self, name, chan)

    def get_lo_sources(self, name: "std::string const &", chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_sources(usrp_source self, std::string const & name, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_get_lo_sources(self, name, chan)

    def set_lo_export_enabled(self, enabled: "bool", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_export_enabled(usrp_source self, bool enabled, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_lo_export_enabled(self, enabled, name, chan)

    def get_lo_export_enabled(self, name: "std::string const &", chan: "size_t"=0) -> "bool":
        r"""get_lo_export_enabled(usrp_source self, std::string const & name, size_t chan=0) -> bool"""
        return _uhd_swig.usrp_source_get_lo_export_enabled(self, name, chan)

    def set_lo_freq(self, freq: "double", name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""set_lo_freq(usrp_source self, double freq, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_source_set_lo_freq(self, freq, name, chan)

    def get_lo_freq(self, name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""get_lo_freq(usrp_source self, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_source_get_lo_freq(self, name, chan)

    def get_lo_freq_range(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_lo_freq_range(usrp_source self, std::string const & name, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_source_get_lo_freq_range(self, name, chan)

    def set_auto_dc_offset(self, enb: "bool const", chan: "size_t"=0) -> "void":
        r"""set_auto_dc_offset(usrp_source self, bool const enb, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_auto_dc_offset(self, enb, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(usrp_source self, std::complex< double > const & offset, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_dc_offset(self, offset, chan)

    def set_auto_iq_balance(self, enb: "bool const", chan: "size_t"=0) -> "void":
        r"""set_auto_iq_balance(usrp_source self, bool const enb, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_auto_iq_balance(self, enb, chan)

    def set_iq_balance(self, correction: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(usrp_source self, std::complex< double > const & correction, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_iq_balance(self, correction, chan)

    def set_rx_agc(self, enable: "bool const", chan: "size_t"=0) -> "void":
        r"""set_rx_agc(usrp_source self, bool const enable, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_rx_agc(self, enable, chan)

    def finite_acquisition(self, nsamps: "size_t const") -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""finite_acquisition(usrp_source self, size_t const nsamps) -> pmt_vector_cfloat"""
        return _uhd_swig.usrp_source_finite_acquisition(self, nsamps)

    def finite_acquisition_v(self, nsamps: "size_t const") -> "std::vector< std::vector< std::complex< float >,std::allocator< std::complex< float > > >,std::allocator< std::vector< std::complex< float >,std::allocator< std::complex< float > > > > >":
        r"""finite_acquisition_v(usrp_source self, size_t const nsamps) -> gr_vector_vector_complexf"""
        return _uhd_swig.usrp_source_finite_acquisition_v(self, nsamps)
    __swig_destroy__ = _uhd_swig.delete_usrp_source

# Register usrp_source in _uhd_swig:
_uhd_swig.usrp_source_swigregister(usrp_source)

def usrp_source_make(device_addr: "device_addr_t", stream_args: "stream_args_t", issue_stream_cmd_on_start: "bool const"=True) -> "gr::uhd::usrp_source::sptr":
    r"""usrp_source_make(device_addr_t device_addr, stream_args_t stream_args, bool const issue_stream_cmd_on_start=True) -> usrp_source_sptr"""
    return _uhd_swig.usrp_source_make(device_addr, stream_args, issue_stream_cmd_on_start)

class usrp_sink(usrp_block):
    r"""Proxy of C++ gr::uhd::usrp_sink class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::uhd::usrp_sink::sptr":
        r"""make(device_addr_t device_addr, stream_args_t stream_args, std::string const & tsb_tag_name="") -> usrp_sink_sptr"""
        return _uhd_swig.usrp_sink_make(*args, **kwargs)

    def set_start_time(self, time: "time_spec_t") -> "void":
        r"""set_start_time(usrp_sink self, time_spec_t time)"""
        return _uhd_swig.usrp_sink_set_start_time(self, time)

    def get_usrp_info(self, chan: "size_t"=0) -> "::uhd::dict< std::string,std::string >":
        r"""get_usrp_info(usrp_sink self, size_t chan=0) -> string_string_dict_t"""
        return _uhd_swig.usrp_sink_get_usrp_info(self, chan)

    def get_lo_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_names(usrp_sink self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_get_lo_names(self, chan)

    def set_lo_source(self, src: "std::string const &", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_source(usrp_sink self, std::string const & src, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_sink_set_lo_source(self, src, name, chan)

    def get_lo_source(self, name: "std::string const &", chan: "size_t"=0) -> "std::string const":
        r"""get_lo_source(usrp_sink self, std::string const & name, size_t chan=0) -> std::string const"""
        return _uhd_swig.usrp_sink_get_lo_source(self, name, chan)

    def get_lo_sources(self, name: "std::string const &", chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_sources(usrp_sink self, std::string const & name, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_get_lo_sources(self, name, chan)

    def set_lo_export_enabled(self, enabled: "bool", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_export_enabled(usrp_sink self, bool enabled, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_sink_set_lo_export_enabled(self, enabled, name, chan)

    def get_lo_export_enabled(self, name: "std::string const &", chan: "size_t"=0) -> "bool":
        r"""get_lo_export_enabled(usrp_sink self, std::string const & name, size_t chan=0) -> bool"""
        return _uhd_swig.usrp_sink_get_lo_export_enabled(self, name, chan)

    def set_lo_freq(self, freq: "double", name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""set_lo_freq(usrp_sink self, double freq, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_sink_set_lo_freq(self, freq, name, chan)

    def get_lo_freq(self, name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""get_lo_freq(usrp_sink self, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_sink_get_lo_freq(self, name, chan)

    def get_lo_freq_range(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_lo_freq_range(usrp_sink self, std::string const & name, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_sink_get_lo_freq_range(self, name, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(usrp_sink self, std::complex< double > const & offset, size_t chan=0)"""
        return _uhd_swig.usrp_sink_set_dc_offset(self, offset, chan)

    def set_iq_balance(self, correction: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(usrp_sink self, std::complex< double > const & correction, size_t chan=0)"""
        return _uhd_swig.usrp_sink_set_iq_balance(self, correction, chan)
    __swig_destroy__ = _uhd_swig.delete_usrp_sink

# Register usrp_sink in _uhd_swig:
_uhd_swig.usrp_sink_swigregister(usrp_sink)

def usrp_sink_make(*args, **kwargs) -> "gr::uhd::usrp_sink::sptr":
    r"""usrp_sink_make(device_addr_t device_addr, stream_args_t stream_args, std::string const & tsb_tag_name="") -> usrp_sink_sptr"""
    return _uhd_swig.usrp_sink_make(*args, **kwargs)

class amsg_source(object):
    r"""Proxy of C++ gr::uhd::amsg_source class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_amsg_source

    @staticmethod
    def make(device_addr: "device_addr_t", msgq: "msg_queue_sptr") -> "gr::uhd::amsg_source::sptr":
        r"""make(device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
        return _uhd_swig.amsg_source_make(device_addr, msgq)

    @staticmethod
    def msg_to_async_metadata_t(msg: "message_sptr") -> "::uhd::async_metadata_t":
        r"""msg_to_async_metadata_t(message_sptr msg) -> async_metadata_t"""
        return _uhd_swig.amsg_source_msg_to_async_metadata_t(msg)

    def __init__(self):
        r"""__init__(amsg_source self) -> amsg_source"""
        _uhd_swig.amsg_source_swiginit(self, _uhd_swig.new_amsg_source())

# Register amsg_source in _uhd_swig:
_uhd_swig.amsg_source_swigregister(amsg_source)

def amsg_source_make(device_addr: "device_addr_t", msgq: "msg_queue_sptr") -> "gr::uhd::amsg_source::sptr":
    r"""amsg_source_make(device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
    return _uhd_swig.amsg_source_make(device_addr, msgq)

def amsg_source_msg_to_async_metadata_t(msg: "message_sptr") -> "::uhd::async_metadata_t":
    r"""amsg_source_msg_to_async_metadata_t(message_sptr msg) -> async_metadata_t"""
    return _uhd_swig.amsg_source_msg_to_async_metadata_t(msg)

class usrp_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::uhd::usrp_source > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(usrp_source_sptr self) -> usrp_source_sptr
        __init__(usrp_source_sptr self, usrp_source p) -> usrp_source_sptr
        """
        _uhd_swig.usrp_source_sptr_swiginit(self, _uhd_swig.new_usrp_source_sptr(*args))

    def __deref__(self) -> "gr::uhd::usrp_source *":
        r"""__deref__(usrp_source_sptr self) -> usrp_source"""
        return _uhd_swig.usrp_source_sptr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_usrp_source_sptr

    def make(self, device_addr: "device_addr_t", stream_args: "stream_args_t", issue_stream_cmd_on_start: "bool const"=True) -> "gr::uhd::usrp_source::sptr":
        r"""make(usrp_source_sptr self, device_addr_t device_addr, stream_args_t stream_args, bool const issue_stream_cmd_on_start=True) -> usrp_source_sptr"""
        return _uhd_swig.usrp_source_sptr_make(self, device_addr, stream_args, issue_stream_cmd_on_start)

    def set_start_time(self, time: "time_spec_t") -> "void":
        r"""set_start_time(usrp_source_sptr self, time_spec_t time)"""
        return _uhd_swig.usrp_source_sptr_set_start_time(self, time)

    def issue_stream_cmd(self, cmd: "stream_cmd_t") -> "void":
        r"""issue_stream_cmd(usrp_source_sptr self, stream_cmd_t cmd)"""
        return _uhd_swig.usrp_source_sptr_issue_stream_cmd(self, cmd)

    def set_recv_timeout(self, timeout: "double const", one_packet: "bool const"=True) -> "void":
        r"""set_recv_timeout(usrp_source_sptr self, double const timeout, bool const one_packet=True)"""
        return _uhd_swig.usrp_source_sptr_set_recv_timeout(self, timeout, one_packet)

    def get_usrp_info(self, chan: "size_t"=0) -> "::uhd::dict< std::string,std::string >":
        r"""get_usrp_info(usrp_source_sptr self, size_t chan=0) -> string_string_dict_t"""
        return _uhd_swig.usrp_source_sptr_get_usrp_info(self, chan)

    def get_lo_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_names(usrp_source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_lo_names(self, chan)

    def set_lo_source(self, src: "std::string const &", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_source(usrp_source_sptr self, std::string const & src, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_lo_source(self, src, name, chan)

    def get_lo_source(self, name: "std::string const &", chan: "size_t"=0) -> "std::string const":
        r"""get_lo_source(usrp_source_sptr self, std::string const & name, size_t chan=0) -> std::string const"""
        return _uhd_swig.usrp_source_sptr_get_lo_source(self, name, chan)

    def get_lo_sources(self, name: "std::string const &", chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_sources(usrp_source_sptr self, std::string const & name, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_lo_sources(self, name, chan)

    def set_lo_export_enabled(self, enabled: "bool", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_export_enabled(usrp_source_sptr self, bool enabled, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_lo_export_enabled(self, enabled, name, chan)

    def get_lo_export_enabled(self, name: "std::string const &", chan: "size_t"=0) -> "bool":
        r"""get_lo_export_enabled(usrp_source_sptr self, std::string const & name, size_t chan=0) -> bool"""
        return _uhd_swig.usrp_source_sptr_get_lo_export_enabled(self, name, chan)

    def set_lo_freq(self, freq: "double", name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""set_lo_freq(usrp_source_sptr self, double freq, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_source_sptr_set_lo_freq(self, freq, name, chan)

    def get_lo_freq(self, name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""get_lo_freq(usrp_source_sptr self, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_source_sptr_get_lo_freq(self, name, chan)

    def get_lo_freq_range(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_lo_freq_range(usrp_source_sptr self, std::string const & name, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_lo_freq_range(self, name, chan)

    def set_auto_dc_offset(self, enb: "bool const", chan: "size_t"=0) -> "void":
        r"""set_auto_dc_offset(usrp_source_sptr self, bool const enb, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_auto_dc_offset(self, enb, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(usrp_source_sptr self, std::complex< double > const & offset, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_dc_offset(self, offset, chan)

    def set_auto_iq_balance(self, enb: "bool const", chan: "size_t"=0) -> "void":
        r"""set_auto_iq_balance(usrp_source_sptr self, bool const enb, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_auto_iq_balance(self, enb, chan)

    def set_iq_balance(self, correction: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(usrp_source_sptr self, std::complex< double > const & correction, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_iq_balance(self, correction, chan)

    def set_rx_agc(self, enable: "bool const", chan: "size_t"=0) -> "void":
        r"""set_rx_agc(usrp_source_sptr self, bool const enable, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_rx_agc(self, enable, chan)

    def finite_acquisition(self, nsamps: "size_t const") -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
        r"""finite_acquisition(usrp_source_sptr self, size_t const nsamps) -> pmt_vector_cfloat"""
        return _uhd_swig.usrp_source_sptr_finite_acquisition(self, nsamps)

    def finite_acquisition_v(self, nsamps: "size_t const") -> "std::vector< std::vector< std::complex< float >,std::allocator< std::complex< float > > >,std::allocator< std::vector< std::complex< float >,std::allocator< std::complex< float > > > > >":
        r"""finite_acquisition_v(usrp_source_sptr self, size_t const nsamps) -> gr_vector_vector_complexf"""
        return _uhd_swig.usrp_source_sptr_finite_acquisition_v(self, nsamps)

    def set_subdev_spec(self, spec: "std::string const &", mboard: "size_t"=0) -> "void":
        r"""set_subdev_spec(usrp_source_sptr self, std::string const & spec, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_subdev_spec(self, spec, mboard)

    def get_subdev_spec(self, mboard: "size_t"=0) -> "std::string":
        r"""get_subdev_spec(usrp_source_sptr self, size_t mboard=0) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_subdev_spec(self, mboard)

    def get_num_mboards(self) -> "size_t":
        r"""get_num_mboards(usrp_source_sptr self) -> size_t"""
        return _uhd_swig.usrp_source_sptr_get_num_mboards(self)

    def set_samp_rate(self, rate: "double") -> "void":
        r"""set_samp_rate(usrp_source_sptr self, double rate)"""
        return _uhd_swig.usrp_source_sptr_set_samp_rate(self, rate)

    def get_samp_rate(self) -> "double":
        r"""get_samp_rate(usrp_source_sptr self) -> double"""
        return _uhd_swig.usrp_source_sptr_get_samp_rate(self)

    def get_samp_rates(self) -> "::uhd::meta_range_t":
        r"""get_samp_rates(usrp_source_sptr self) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_samp_rates(self)

    def set_center_freq(self, *args) -> "::uhd::tune_result_t":
        r"""
        set_center_freq(usrp_source_sptr self, tune_request_t tune_request, size_t chan=0) -> tune_result_t
        set_center_freq(usrp_source_sptr self, double freq, size_t chan=0) -> tune_result_t
        """
        return _uhd_swig.usrp_source_sptr_set_center_freq(self, *args)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""get_center_freq(usrp_source_sptr self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_source_sptr_get_center_freq(self, chan)

    def get_freq_range(self, chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_freq_range(usrp_source_sptr self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_freq_range(self, chan)

    def set_gain(self, *args) -> "void":
        r"""
        set_gain(usrp_source_sptr self, double gain, size_t chan=0)
        set_gain(usrp_source_sptr self, double gain, std::string const & name, size_t chan=0)
        """
        return _uhd_swig.usrp_source_sptr_set_gain(self, *args)

    def set_normalized_gain(self, norm_gain: "double", chan: "size_t"=0) -> "void":
        r"""set_normalized_gain(usrp_source_sptr self, double norm_gain, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_normalized_gain(self, norm_gain, chan)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(usrp_source_sptr self, size_t chan=0) -> double
        get_gain(usrp_source_sptr self, std::string const & name, size_t chan=0) -> double
        """
        return _uhd_swig.usrp_source_sptr_get_gain(self, *args)

    def get_normalized_gain(self, chan: "size_t"=0) -> "double":
        r"""get_normalized_gain(usrp_source_sptr self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_source_sptr_get_normalized_gain(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gain_names(usrp_source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "::uhd::gain_range_t":
        r"""
        get_gain_range(usrp_source_sptr self, size_t chan=0) -> meta_range_t
        get_gain_range(usrp_source_sptr self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _uhd_swig.usrp_source_sptr_get_gain_range(self, *args)

    def set_antenna(self, ant: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_antenna(usrp_source_sptr self, std::string const & ant, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_antenna(self, ant, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""get_antenna(usrp_source_sptr self, size_t chan=0) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_antenna(self, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_antennas(usrp_source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_antennas(self, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "void":
        r"""set_bandwidth(usrp_source_sptr self, double bandwidth, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""get_bandwidth(usrp_source_sptr self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_source_sptr_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_bandwidth_range(usrp_source_sptr self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_bandwidth_range(self, chan)

    def get_sensor(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_sensor(usrp_source_sptr self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_source_sptr_get_sensor(self, name, chan)

    def get_sensor_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_sensor_names(usrp_source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_sensor_names(self, chan)

    def get_dboard_sensor(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_dboard_sensor(usrp_source_sptr self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_source_sptr_get_dboard_sensor(self, name, chan)

    def get_dboard_sensor_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_dboard_sensor_names(usrp_source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_dboard_sensor_names(self, chan)

    def get_mboard_sensor(self, name: "std::string const &", mboard: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_mboard_sensor(usrp_source_sptr self, std::string const & name, size_t mboard=0) -> sensor_value_t"""
        return _uhd_swig.usrp_source_sptr_get_mboard_sensor(self, name, mboard)

    def get_mboard_sensor_names(self, mboard: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_mboard_sensor_names(usrp_source_sptr self, size_t mboard=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_mboard_sensor_names(self, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""get_time_source(usrp_source_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_time_sources(usrp_source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_clock_source(usrp_source_sptr self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""get_clock_source(usrp_source_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_clock_sources(usrp_source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""get_clock_rate(usrp_source_sptr self, size_t mboard=0) -> double"""
        return _uhd_swig.usrp_source_sptr_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""set_clock_rate(usrp_source_sptr self, double rate, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::uhd::time_spec_t":
        r"""get_time_now(usrp_source_sptr self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_source_sptr_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::uhd::time_spec_t":
        r"""get_time_last_pps(usrp_source_sptr self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_source_sptr_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_time_now(usrp_source_sptr self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_next_pps(usrp_source_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_source_sptr_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_unknown_pps(usrp_source_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_source_sptr_set_time_unknown_pps(self, time_spec)

    def set_command_time(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_command_time(usrp_source_sptr self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_command_time(self, time_spec, mboard)

    def clear_command_time(self, mboard: "size_t"=0) -> "void":
        r"""clear_command_time(usrp_source_sptr self, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_clear_command_time(self, mboard)

    def get_dboard_iface(self, chan: "size_t"=0) -> "::uhd::usrp::dboard_iface::sptr":
        r"""get_dboard_iface(usrp_source_sptr self, size_t chan=0) -> dboard_iface_sptr"""
        return _uhd_swig.usrp_source_sptr_get_dboard_iface(self, chan)

    def get_device(self) -> "::uhd::usrp::multi_usrp::sptr":
        r"""get_device(usrp_source_sptr self) -> ::uhd::usrp::multi_usrp::sptr"""
        return _uhd_swig.usrp_source_sptr_get_device(self)

    def set_user_register(self, addr: "uint8_t const", data: "uint32_t const", mboard: "size_t"=0) -> "void":
        r"""set_user_register(usrp_source_sptr self, uint8_t const addr, uint32_t const data, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_user_register(self, addr, data, mboard)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_time_source(usrp_source_sptr self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_time_source(self, source, mboard)

    def set_stream_args(self, stream_args: "stream_args_t") -> "void":
        r"""set_stream_args(usrp_source_sptr self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_source_sptr_set_stream_args(self, stream_args)

    def get_gpio_banks(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gpio_banks(usrp_source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_gpio_banks(self, mboard)

    def set_gpio_attr(self, *args, **kwargs) -> "void":
        r"""set_gpio_attr(usrp_source_sptr self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask=0xffffffff, size_t const mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_gpio_attr(self, *args, **kwargs)

    def get_gpio_attr(self, bank: "std::string const &", attr: "std::string const &", mboard: "size_t const"=0) -> "boost::uint32_t":
        r"""get_gpio_attr(usrp_source_sptr self, std::string const & bank, std::string const & attr, size_t const mboard=0) -> boost::uint32_t"""
        return _uhd_swig.usrp_source_sptr_get_gpio_attr(self, bank, attr, mboard)

    def get_filter_names(self, *args, **kwargs) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_filter_names(usrp_source_sptr self, std::string const & search_mask="") -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_filter_names(self, *args, **kwargs)

    def set_filter(self, path: "std::string const &", filter: "filter_info_base_sptr") -> "void":
        r"""set_filter(usrp_source_sptr self, std::string const & path, filter_info_base_sptr filter)"""
        return _uhd_swig.usrp_source_sptr_set_filter(self, path, filter)

    def get_filter(self, path: "std::string const &") -> "::uhd::filter_info_base::sptr":
        r"""get_filter(usrp_source_sptr self, std::string const & path) -> filter_info_base_sptr"""
        return _uhd_swig.usrp_source_sptr_get_filter(self, path)

    def history(self) -> "unsigned int":
        r"""history(usrp_source_sptr self) -> unsigned int"""
        return _uhd_swig.usrp_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(usrp_source_sptr self, int which, int delay)
        declare_sample_delay(usrp_source_sptr self, unsigned int delay)
        """
        return _uhd_swig.usrp_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(usrp_source_sptr self, int which) -> unsigned int"""
        return _uhd_swig.usrp_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(usrp_source_sptr self, int multiple)"""
        return _uhd_swig.usrp_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(usrp_source_sptr self) -> double"""
        return _uhd_swig.usrp_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(usrp_source_sptr self) -> uint64_t"""
        return _uhd_swig.usrp_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(usrp_source_sptr self) -> uint64_t"""
        return _uhd_swig.usrp_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(usrp_source_sptr self) -> bool"""
        return _uhd_swig.usrp_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(usrp_source_sptr self) -> bool"""
        return _uhd_swig.usrp_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(usrp_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _uhd_swig.usrp_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(usrp_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _uhd_swig.usrp_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(usrp_source_sptr self, std::string level)"""
        return _uhd_swig.usrp_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(usrp_source_sptr self) -> std::string"""
        return _uhd_swig.usrp_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(usrp_source_sptr self, int m)"""
        return _uhd_swig.usrp_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(usrp_source_sptr self)"""
        return _uhd_swig.usrp_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(usrp_source_sptr self) -> bool"""
        return _uhd_swig.usrp_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(usrp_source_sptr self, int m)"""
        return _uhd_swig.usrp_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(usrp_source_sptr self, int i) -> long"""
        return _uhd_swig.usrp_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(usrp_source_sptr self, long max_output_buffer)
        set_max_output_buffer(usrp_source_sptr self, int port, long max_output_buffer)
        """
        return _uhd_swig.usrp_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(usrp_source_sptr self, int i) -> long"""
        return _uhd_swig.usrp_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(usrp_source_sptr self, long min_output_buffer)
        set_min_output_buffer(usrp_source_sptr self, int port, long min_output_buffer)
        """
        return _uhd_swig.usrp_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(usrp_source_sptr self, int which) -> float
        pc_input_buffers_full(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(usrp_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(usrp_source_sptr self, int which) -> float
        pc_input_buffers_full_var(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(usrp_source_sptr self, int which) -> float
        pc_output_buffers_full(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(usrp_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(usrp_source_sptr self, int which) -> float
        pc_output_buffers_full_var(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(usrp_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _uhd_swig.usrp_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(usrp_source_sptr self)"""
        return _uhd_swig.usrp_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(usrp_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _uhd_swig.usrp_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(usrp_source_sptr self, int priority) -> int"""
        return _uhd_swig.usrp_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(usrp_source_sptr self) -> std::string"""
        return _uhd_swig.usrp_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(usrp_source_sptr self) -> std::string"""
        return _uhd_swig.usrp_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(usrp_source_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(usrp_source_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(usrp_source_sptr self) -> long"""
        return _uhd_swig.usrp_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(usrp_source_sptr self) -> basic_block_sptr"""
        return _uhd_swig.usrp_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(usrp_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _uhd_swig.usrp_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(usrp_source_sptr self) -> std::string"""
        return _uhd_swig.usrp_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(usrp_source_sptr self, std::string name)"""
        return _uhd_swig.usrp_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(usrp_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _uhd_swig.usrp_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(usrp_source_sptr self) -> swig_pmt_ptr"""
        return _uhd_swig.usrp_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(usrp_source_sptr self) -> swig_pmt_ptr"""
        return _uhd_swig.usrp_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(usrp_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _uhd_swig.usrp_source_sptr_message_subscribers(self, which_port)

# Register usrp_source_sptr in _uhd_swig:
_uhd_swig.usrp_source_sptr_swigregister(usrp_source_sptr)


usrp_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
usrp_source = usrp_source.make;

class usrp_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::uhd::usrp_sink > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(usrp_sink_sptr self) -> usrp_sink_sptr
        __init__(usrp_sink_sptr self, usrp_sink p) -> usrp_sink_sptr
        """
        _uhd_swig.usrp_sink_sptr_swiginit(self, _uhd_swig.new_usrp_sink_sptr(*args))

    def __deref__(self) -> "gr::uhd::usrp_sink *":
        r"""__deref__(usrp_sink_sptr self) -> usrp_sink"""
        return _uhd_swig.usrp_sink_sptr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_usrp_sink_sptr

    def make(self, *args, **kwargs) -> "gr::uhd::usrp_sink::sptr":
        r"""make(usrp_sink_sptr self, device_addr_t device_addr, stream_args_t stream_args, std::string const & tsb_tag_name="") -> usrp_sink_sptr"""
        return _uhd_swig.usrp_sink_sptr_make(self, *args, **kwargs)

    def set_start_time(self, time: "time_spec_t") -> "void":
        r"""set_start_time(usrp_sink_sptr self, time_spec_t time)"""
        return _uhd_swig.usrp_sink_sptr_set_start_time(self, time)

    def get_usrp_info(self, chan: "size_t"=0) -> "::uhd::dict< std::string,std::string >":
        r"""get_usrp_info(usrp_sink_sptr self, size_t chan=0) -> string_string_dict_t"""
        return _uhd_swig.usrp_sink_sptr_get_usrp_info(self, chan)

    def get_lo_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_names(usrp_sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_lo_names(self, chan)

    def set_lo_source(self, src: "std::string const &", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_source(usrp_sink_sptr self, std::string const & src, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_lo_source(self, src, name, chan)

    def get_lo_source(self, name: "std::string const &", chan: "size_t"=0) -> "std::string const":
        r"""get_lo_source(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> std::string const"""
        return _uhd_swig.usrp_sink_sptr_get_lo_source(self, name, chan)

    def get_lo_sources(self, name: "std::string const &", chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_lo_sources(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_lo_sources(self, name, chan)

    def set_lo_export_enabled(self, enabled: "bool", name: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_lo_export_enabled(usrp_sink_sptr self, bool enabled, std::string const & name, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_lo_export_enabled(self, enabled, name, chan)

    def get_lo_export_enabled(self, name: "std::string const &", chan: "size_t"=0) -> "bool":
        r"""get_lo_export_enabled(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> bool"""
        return _uhd_swig.usrp_sink_sptr_get_lo_export_enabled(self, name, chan)

    def set_lo_freq(self, freq: "double", name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""set_lo_freq(usrp_sink_sptr self, double freq, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_sink_sptr_set_lo_freq(self, freq, name, chan)

    def get_lo_freq(self, name: "std::string const &", chan: "size_t"=0) -> "double":
        r"""get_lo_freq(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_lo_freq(self, name, chan)

    def get_lo_freq_range(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_lo_freq_range(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_sink_sptr_get_lo_freq_range(self, name, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(usrp_sink_sptr self, std::complex< double > const & offset, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_dc_offset(self, offset, chan)

    def set_iq_balance(self, correction: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(usrp_sink_sptr self, std::complex< double > const & correction, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_iq_balance(self, correction, chan)

    def set_subdev_spec(self, spec: "std::string const &", mboard: "size_t"=0) -> "void":
        r"""set_subdev_spec(usrp_sink_sptr self, std::string const & spec, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_subdev_spec(self, spec, mboard)

    def get_subdev_spec(self, mboard: "size_t"=0) -> "std::string":
        r"""get_subdev_spec(usrp_sink_sptr self, size_t mboard=0) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_subdev_spec(self, mboard)

    def get_num_mboards(self) -> "size_t":
        r"""get_num_mboards(usrp_sink_sptr self) -> size_t"""
        return _uhd_swig.usrp_sink_sptr_get_num_mboards(self)

    def set_samp_rate(self, rate: "double") -> "void":
        r"""set_samp_rate(usrp_sink_sptr self, double rate)"""
        return _uhd_swig.usrp_sink_sptr_set_samp_rate(self, rate)

    def get_samp_rate(self) -> "double":
        r"""get_samp_rate(usrp_sink_sptr self) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_samp_rate(self)

    def get_samp_rates(self) -> "::uhd::meta_range_t":
        r"""get_samp_rates(usrp_sink_sptr self) -> meta_range_t"""
        return _uhd_swig.usrp_sink_sptr_get_samp_rates(self)

    def set_center_freq(self, *args) -> "::uhd::tune_result_t":
        r"""
        set_center_freq(usrp_sink_sptr self, tune_request_t tune_request, size_t chan=0) -> tune_result_t
        set_center_freq(usrp_sink_sptr self, double freq, size_t chan=0) -> tune_result_t
        """
        return _uhd_swig.usrp_sink_sptr_set_center_freq(self, *args)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""get_center_freq(usrp_sink_sptr self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_center_freq(self, chan)

    def get_freq_range(self, chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_freq_range(usrp_sink_sptr self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_sink_sptr_get_freq_range(self, chan)

    def set_gain(self, *args) -> "void":
        r"""
        set_gain(usrp_sink_sptr self, double gain, size_t chan=0)
        set_gain(usrp_sink_sptr self, double gain, std::string const & name, size_t chan=0)
        """
        return _uhd_swig.usrp_sink_sptr_set_gain(self, *args)

    def set_normalized_gain(self, norm_gain: "double", chan: "size_t"=0) -> "void":
        r"""set_normalized_gain(usrp_sink_sptr self, double norm_gain, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_normalized_gain(self, norm_gain, chan)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(usrp_sink_sptr self, size_t chan=0) -> double
        get_gain(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> double
        """
        return _uhd_swig.usrp_sink_sptr_get_gain(self, *args)

    def get_normalized_gain(self, chan: "size_t"=0) -> "double":
        r"""get_normalized_gain(usrp_sink_sptr self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_normalized_gain(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gain_names(usrp_sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "::uhd::gain_range_t":
        r"""
        get_gain_range(usrp_sink_sptr self, size_t chan=0) -> meta_range_t
        get_gain_range(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _uhd_swig.usrp_sink_sptr_get_gain_range(self, *args)

    def set_antenna(self, ant: "std::string const &", chan: "size_t"=0) -> "void":
        r"""set_antenna(usrp_sink_sptr self, std::string const & ant, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_antenna(self, ant, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""get_antenna(usrp_sink_sptr self, size_t chan=0) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_antenna(self, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_antennas(usrp_sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_antennas(self, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "void":
        r"""set_bandwidth(usrp_sink_sptr self, double bandwidth, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""get_bandwidth(usrp_sink_sptr self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "::uhd::freq_range_t":
        r"""get_bandwidth_range(usrp_sink_sptr self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_sink_sptr_get_bandwidth_range(self, chan)

    def get_sensor(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_sensor(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_sink_sptr_get_sensor(self, name, chan)

    def get_sensor_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_sensor_names(usrp_sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_sensor_names(self, chan)

    def get_dboard_sensor(self, name: "std::string const &", chan: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_dboard_sensor(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_sink_sptr_get_dboard_sensor(self, name, chan)

    def get_dboard_sensor_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_dboard_sensor_names(usrp_sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_dboard_sensor_names(self, chan)

    def get_mboard_sensor(self, name: "std::string const &", mboard: "size_t"=0) -> "::uhd::sensor_value_t":
        r"""get_mboard_sensor(usrp_sink_sptr self, std::string const & name, size_t mboard=0) -> sensor_value_t"""
        return _uhd_swig.usrp_sink_sptr_get_mboard_sensor(self, name, mboard)

    def get_mboard_sensor_names(self, mboard: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_mboard_sensor_names(usrp_sink_sptr self, size_t mboard=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_mboard_sensor_names(self, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""get_time_source(usrp_sink_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_time_sources(usrp_sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_clock_source(usrp_sink_sptr self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""get_clock_source(usrp_sink_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_clock_sources(usrp_sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""get_clock_rate(usrp_sink_sptr self, size_t mboard=0) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""set_clock_rate(usrp_sink_sptr self, double rate, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::uhd::time_spec_t":
        r"""get_time_now(usrp_sink_sptr self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_sink_sptr_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::uhd::time_spec_t":
        r"""get_time_last_pps(usrp_sink_sptr self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_sink_sptr_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_time_now(usrp_sink_sptr self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_next_pps(usrp_sink_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_sink_sptr_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_unknown_pps(usrp_sink_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_sink_sptr_set_time_unknown_pps(self, time_spec)

    def set_command_time(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_command_time(usrp_sink_sptr self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_command_time(self, time_spec, mboard)

    def clear_command_time(self, mboard: "size_t"=0) -> "void":
        r"""clear_command_time(usrp_sink_sptr self, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_clear_command_time(self, mboard)

    def get_dboard_iface(self, chan: "size_t"=0) -> "::uhd::usrp::dboard_iface::sptr":
        r"""get_dboard_iface(usrp_sink_sptr self, size_t chan=0) -> dboard_iface_sptr"""
        return _uhd_swig.usrp_sink_sptr_get_dboard_iface(self, chan)

    def get_device(self) -> "::uhd::usrp::multi_usrp::sptr":
        r"""get_device(usrp_sink_sptr self) -> ::uhd::usrp::multi_usrp::sptr"""
        return _uhd_swig.usrp_sink_sptr_get_device(self)

    def set_user_register(self, addr: "uint8_t const", data: "uint32_t const", mboard: "size_t"=0) -> "void":
        r"""set_user_register(usrp_sink_sptr self, uint8_t const addr, uint32_t const data, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_user_register(self, addr, data, mboard)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_time_source(usrp_sink_sptr self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_time_source(self, source, mboard)

    def set_stream_args(self, stream_args: "stream_args_t") -> "void":
        r"""set_stream_args(usrp_sink_sptr self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_sink_sptr_set_stream_args(self, stream_args)

    def get_gpio_banks(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gpio_banks(usrp_sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_gpio_banks(self, mboard)

    def set_gpio_attr(self, *args, **kwargs) -> "void":
        r"""set_gpio_attr(usrp_sink_sptr self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask=0xffffffff, size_t const mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_gpio_attr(self, *args, **kwargs)

    def get_gpio_attr(self, bank: "std::string const &", attr: "std::string const &", mboard: "size_t const"=0) -> "boost::uint32_t":
        r"""get_gpio_attr(usrp_sink_sptr self, std::string const & bank, std::string const & attr, size_t const mboard=0) -> boost::uint32_t"""
        return _uhd_swig.usrp_sink_sptr_get_gpio_attr(self, bank, attr, mboard)

    def get_filter_names(self, *args, **kwargs) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_filter_names(usrp_sink_sptr self, std::string const & search_mask="") -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_filter_names(self, *args, **kwargs)

    def set_filter(self, path: "std::string const &", filter: "filter_info_base_sptr") -> "void":
        r"""set_filter(usrp_sink_sptr self, std::string const & path, filter_info_base_sptr filter)"""
        return _uhd_swig.usrp_sink_sptr_set_filter(self, path, filter)

    def get_filter(self, path: "std::string const &") -> "::uhd::filter_info_base::sptr":
        r"""get_filter(usrp_sink_sptr self, std::string const & path) -> filter_info_base_sptr"""
        return _uhd_swig.usrp_sink_sptr_get_filter(self, path)

    def history(self) -> "unsigned int":
        r"""history(usrp_sink_sptr self) -> unsigned int"""
        return _uhd_swig.usrp_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(usrp_sink_sptr self, int which, int delay)
        declare_sample_delay(usrp_sink_sptr self, unsigned int delay)
        """
        return _uhd_swig.usrp_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(usrp_sink_sptr self, int which) -> unsigned int"""
        return _uhd_swig.usrp_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(usrp_sink_sptr self, int multiple)"""
        return _uhd_swig.usrp_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(usrp_sink_sptr self) -> double"""
        return _uhd_swig.usrp_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(usrp_sink_sptr self) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(usrp_sink_sptr self) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(usrp_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(usrp_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(usrp_sink_sptr self, std::string level)"""
        return _uhd_swig.usrp_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(usrp_sink_sptr self, int m)"""
        return _uhd_swig.usrp_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(usrp_sink_sptr self)"""
        return _uhd_swig.usrp_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(usrp_sink_sptr self, int m)"""
        return _uhd_swig.usrp_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(usrp_sink_sptr self, int i) -> long"""
        return _uhd_swig.usrp_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(usrp_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(usrp_sink_sptr self, int port, long max_output_buffer)
        """
        return _uhd_swig.usrp_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(usrp_sink_sptr self, int i) -> long"""
        return _uhd_swig.usrp_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(usrp_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(usrp_sink_sptr self, int port, long min_output_buffer)
        """
        return _uhd_swig.usrp_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(usrp_sink_sptr self, int which) -> float
        pc_input_buffers_full(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(usrp_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(usrp_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(usrp_sink_sptr self, int which) -> float
        pc_output_buffers_full(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(usrp_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(usrp_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(usrp_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _uhd_swig.usrp_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(usrp_sink_sptr self)"""
        return _uhd_swig.usrp_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(usrp_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _uhd_swig.usrp_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(usrp_sink_sptr self, int priority) -> int"""
        return _uhd_swig.usrp_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(usrp_sink_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(usrp_sink_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(usrp_sink_sptr self) -> long"""
        return _uhd_swig.usrp_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(usrp_sink_sptr self) -> basic_block_sptr"""
        return _uhd_swig.usrp_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(usrp_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _uhd_swig.usrp_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(usrp_sink_sptr self, std::string name)"""
        return _uhd_swig.usrp_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(usrp_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _uhd_swig.usrp_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(usrp_sink_sptr self) -> swig_pmt_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(usrp_sink_sptr self) -> swig_pmt_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(usrp_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_subscribers(self, which_port)

# Register usrp_sink_sptr in _uhd_swig:
_uhd_swig.usrp_sink_sptr_swigregister(usrp_sink_sptr)


usrp_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
usrp_sink = usrp_sink.make;

class amsg_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::uhd::amsg_source > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(amsg_source_sptr self) -> amsg_source_sptr
        __init__(amsg_source_sptr self, amsg_source p) -> amsg_source_sptr
        """
        _uhd_swig.amsg_source_sptr_swiginit(self, _uhd_swig.new_amsg_source_sptr(*args))

    def __deref__(self) -> "gr::uhd::amsg_source *":
        r"""__deref__(amsg_source_sptr self) -> amsg_source"""
        return _uhd_swig.amsg_source_sptr___deref__(self)
    __swig_destroy__ = _uhd_swig.delete_amsg_source_sptr

    def make(self, device_addr: "device_addr_t", msgq: "msg_queue_sptr") -> "gr::uhd::amsg_source::sptr":
        r"""make(amsg_source_sptr self, device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
        return _uhd_swig.amsg_source_sptr_make(self, device_addr, msgq)

    def msg_to_async_metadata_t(self, msg: "message_sptr") -> "::uhd::async_metadata_t":
        r"""msg_to_async_metadata_t(amsg_source_sptr self, message_sptr msg) -> async_metadata_t"""
        return _uhd_swig.amsg_source_sptr_msg_to_async_metadata_t(self, msg)

# Register amsg_source_sptr in _uhd_swig:
_uhd_swig.amsg_source_sptr_swigregister(amsg_source_sptr)


amsg_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
amsg_source = amsg_source.make;


def find_devices_raw(*args, **kwargs) -> "uhd::device_addrs_t":
    r"""find_devices_raw(device_addr_t dev_addr=uhd::device_addr_t()) -> device_addr_vector_t"""
    return _uhd_swig.find_devices_raw(*args, **kwargs)

def get_version_string() -> "std::string":
    r"""get_version_string() -> std::string"""
    return _uhd_swig.get_version_string()

cvar = _uhd_swig.cvar
ALL_MBOARDS = cvar.ALL_MBOARDS
ALL_CHANS = cvar.ALL_CHANS
ALL_GAINS = cvar.ALL_GAINS
ALL_LOS = cvar.ALL_LOS

