# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.12
#
# 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
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_uhd_swig', [dirname(__file__)])
        except ImportError:
            import _uhd_swig
            return _uhd_swig
        if fp is not None:
            try:
                _mod = imp.load_module('_uhd_swig', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _uhd_swig = swig_import_helper()
    del swig_import_helper
else:
    import _uhd_swig
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class SwigPyIterator(object):
    thisown = _swig_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
    __del__ = lambda self : None;
    def value(self): return _uhd_swig.SwigPyIterator_value(self)
    def incr(self, n=1): return _uhd_swig.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _uhd_swig.SwigPyIterator_decr(self, n)
    def distance(self, *args, **kwargs): return _uhd_swig.SwigPyIterator_distance(self, *args, **kwargs)
    def equal(self, *args, **kwargs): return _uhd_swig.SwigPyIterator_equal(self, *args, **kwargs)
    def copy(self): return _uhd_swig.SwigPyIterator_copy(self)
    def next(self): return _uhd_swig.SwigPyIterator_next(self)
    def __next__(self): return _uhd_swig.SwigPyIterator___next__(self)
    def previous(self): return _uhd_swig.SwigPyIterator_previous(self)
    def advance(self, *args, **kwargs): return _uhd_swig.SwigPyIterator_advance(self, *args, **kwargs)
    def __eq__(self, *args, **kwargs): return _uhd_swig.SwigPyIterator___eq__(self, *args, **kwargs)
    def __ne__(self, *args, **kwargs): return _uhd_swig.SwigPyIterator___ne__(self, *args, **kwargs)
    def __iadd__(self, *args, **kwargs): return _uhd_swig.SwigPyIterator___iadd__(self, *args, **kwargs)
    def __isub__(self, *args, **kwargs): return _uhd_swig.SwigPyIterator___isub__(self, *args, **kwargs)
    def __add__(self, *args, **kwargs): return _uhd_swig.SwigPyIterator___add__(self, *args, **kwargs)
    def __sub__(self, *args): return _uhd_swig.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _uhd_swig.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

CLOCK_THREAD_CPUTIME_ID = _uhd_swig.CLOCK_THREAD_CPUTIME_ID

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

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

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

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

def cmd_chan_key():
  """cmd_chan_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_chan_key()

def cmd_gain_key():
  """cmd_gain_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_gain_key()

def cmd_freq_key():
  """cmd_freq_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_freq_key()

def cmd_lo_offset_key():
  """cmd_lo_offset_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_lo_offset_key()

def cmd_tune_key():
  """cmd_tune_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_tune_key()

def cmd_lo_freq_key():
  """cmd_lo_freq_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_lo_freq_key()

def cmd_dsp_freq_key():
  """cmd_dsp_freq_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_dsp_freq_key()

def cmd_rate_key():
  """cmd_rate_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_rate_key()

def cmd_bandwidth_key():
  """cmd_bandwidth_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_bandwidth_key()

def cmd_time_key():
  """cmd_time_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_time_key()

def cmd_mboard_key():
  """cmd_mboard_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_mboard_key()

def cmd_antenna_key():
  """cmd_antenna_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_antenna_key()

def cmd_direction_key():
  """cmd_direction_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_direction_key()

def cmd_tag_key():
  """cmd_tag_key() -> swig_int_ptr"""
  return _uhd_swig.cmd_tag_key()

def ant_direction_rx():
  """ant_direction_rx() -> swig_int_ptr"""
  return _uhd_swig.ant_direction_rx()

def ant_direction_tx():
  """ant_direction_tx() -> swig_int_ptr"""
  return _uhd_swig.ant_direction_tx()
class usrp_block(object):
    """Proxy of C++ gr::uhd::usrp_block class"""
    thisown = _swig_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, *args, **kwargs):
        """set_subdev_spec(usrp_block self, std::string const & spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_subdev_spec(self, *args, **kwargs)

    def get_subdev_spec(self, mboard=0):
        """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):
        """get_num_mboards(usrp_block self) -> size_t"""
        return _uhd_swig.usrp_block_get_num_mboards(self)

    def set_samp_rate(self, *args, **kwargs):
        """set_samp_rate(usrp_block self, double rate)"""
        return _uhd_swig.usrp_block_set_samp_rate(self, *args, **kwargs)

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

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

    def set_center_freq(self, *args):
        """
        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=0):
        """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=0):
        """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):
        """
        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, *args, **kwargs):
        """set_normalized_gain(usrp_block self, double norm_gain, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_normalized_gain(self, *args, **kwargs)

    def get_gain(self, *args):
        """
        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=0):
        """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=0):
        """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):
        """
        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, *args, **kwargs):
        """set_antenna(usrp_block self, std::string const & ant, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_antenna(self, *args, **kwargs)

    def get_antenna(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """set_bandwidth(usrp_block self, double bandwidth, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_bandwidth(self, *args, **kwargs)

    def get_bandwidth(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """get_sensor(usrp_block self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_block_get_sensor(self, *args, **kwargs)

    def get_sensor_names(self, chan=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_dboard_sensor_names(self, chan=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_mboard_sensor_names(self, mboard=0):
        """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, *args, **kwargs):
        """get_time_source(usrp_block self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_block_get_time_source(self, *args, **kwargs)

    def get_time_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_source(self, *args, **kwargs):
        """set_clock_source(usrp_block self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_source(self, *args, **kwargs)

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

    def get_clock_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_clock_rate(self, mboard=0):
        """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, *args, **kwargs):
        """set_clock_rate(usrp_block self, double rate, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_rate(self, *args, **kwargs)

    def get_time_now(self, mboard=0):
        """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=0):
        """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, *args, **kwargs):
        """set_time_now(usrp_block self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_time_now(self, *args, **kwargs)

    def set_time_next_pps(self, *args, **kwargs):
        """set_time_next_pps(usrp_block self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_block_set_time_next_pps(self, *args, **kwargs)

    def set_time_unknown_pps(self, *args, **kwargs):
        """set_time_unknown_pps(usrp_block self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_block_set_time_unknown_pps(self, *args, **kwargs)

    def set_command_time(self, *args, **kwargs):
        """set_command_time(usrp_block self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_command_time(self, *args, **kwargs)

    def clear_command_time(self, mboard=0):
        """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=0):
        """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):
        """get_device(usrp_block self) -> ::uhd::usrp::multi_usrp::sptr"""
        return _uhd_swig.usrp_block_get_device(self)

    def set_user_register(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_config(self, *args, **kwargs):
        """set_clock_config(usrp_block self, clock_config_t clock_config, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_config(self, *args, **kwargs)

    def set_time_source(self, *args, **kwargs):
        """set_time_source(usrp_block self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_block_set_time_source(self, *args, **kwargs)

    def set_stream_args(self, *args, **kwargs):
        """set_stream_args(usrp_block self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_block_set_stream_args(self, *args, **kwargs)

    def get_gpio_banks(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_gpio_attr(self, *args, **kwargs):
        """
        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, *args, **kwargs):
        """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, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_usrp_block
    __del__ = lambda self : None;
usrp_block_swigregister = _uhd_swig.usrp_block_swigregister
usrp_block_swigregister(usrp_block)

class uhd_string_vector_t(object):
    """Proxy of C++ std::vector<(std::string)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """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):
        """__nonzero__(uhd_string_vector_t self) -> bool"""
        return _uhd_swig.uhd_string_vector_t___nonzero__(self)

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

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

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

    def __getslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __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=std::vector< std::string,std::allocator< std::string > >())
        """
        return _uhd_swig.uhd_string_vector_t___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __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):
        """
        __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):
        """
        __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 append(self, *args, **kwargs):
        """append(uhd_string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _uhd_swig.uhd_string_vector_t_append(self, *args, **kwargs)

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

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

    def clear(self):
        """clear(uhd_string_vector_t self)"""
        return _uhd_swig.uhd_string_vector_t_clear(self)

    def swap(self, *args, **kwargs):
        """swap(uhd_string_vector_t self, std::vector< std::string > & v)"""
        return _uhd_swig.uhd_string_vector_t_swap(self, *args, **kwargs)

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

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

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

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

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

    def pop_back(self):
        """pop_back(uhd_string_vector_t self)"""
        return _uhd_swig.uhd_string_vector_t_pop_back(self)

    def erase(self, *args):
        """
        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): 
        """
        __init__(std::vector<(std::string)> self) -> uhd_string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string > const & arg2) -> uhd_string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> uhd_string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> uhd_string_vector_t
        """
        this = _uhd_swig.new_uhd_string_vector_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """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, *args, **kwargs)

    def front(self):
        """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):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def resize(self, *args):
        """
        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):
        """
        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, *args, **kwargs):
        """reserve(uhd_string_vector_t self, std::vector< std::string >::size_type n)"""
        return _uhd_swig.uhd_string_vector_t_reserve(self, *args, **kwargs)

    def capacity(self):
        """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
    __del__ = lambda self : None;
uhd_string_vector_t_swigregister = _uhd_swig.uhd_string_vector_t_swigregister
uhd_string_vector_t_swigregister(uhd_string_vector_t)

class uhd_size_vector_t(object):
    """Proxy of C++ std::vector<(size_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """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):
        """__nonzero__(uhd_size_vector_t self) -> bool"""
        return _uhd_swig.uhd_size_vector_t___nonzero__(self)

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

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

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

    def __getslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

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

    def __delslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __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):
        """
        __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):
        """
        __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 append(self, *args, **kwargs):
        """append(uhd_size_vector_t self, std::vector< size_t >::value_type const & x)"""
        return _uhd_swig.uhd_size_vector_t_append(self, *args, **kwargs)

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

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

    def clear(self):
        """clear(uhd_size_vector_t self)"""
        return _uhd_swig.uhd_size_vector_t_clear(self)

    def swap(self, *args, **kwargs):
        """swap(uhd_size_vector_t self, gr_vsize_t v)"""
        return _uhd_swig.uhd_size_vector_t_swap(self, *args, **kwargs)

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

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

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

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

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

    def pop_back(self):
        """pop_back(uhd_size_vector_t self)"""
        return _uhd_swig.uhd_size_vector_t_pop_back(self)

    def erase(self, *args):
        """
        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): 
        """
        __init__(std::vector<(size_t)> self) -> uhd_size_vector_t
        __init__(std::vector<(size_t)> self, gr_vsize_t arg2) -> uhd_size_vector_t
        __init__(std::vector<(size_t)> self, std::vector< size_t >::size_type size) -> uhd_size_vector_t
        __init__(std::vector<(size_t)> self, std::vector< size_t >::size_type size, std::vector< size_t >::value_type const & value) -> uhd_size_vector_t
        """
        this = _uhd_swig.new_uhd_size_vector_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """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, *args, **kwargs)

    def front(self):
        """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):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def resize(self, *args):
        """
        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):
        """
        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, *args, **kwargs):
        """reserve(uhd_size_vector_t self, std::vector< size_t >::size_type n)"""
        return _uhd_swig.uhd_size_vector_t_reserve(self, *args, **kwargs)

    def capacity(self):
        """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
    __del__ = lambda self : None;
uhd_size_vector_t_swigregister = _uhd_swig.uhd_size_vector_t_swigregister
uhd_size_vector_t_swigregister(uhd_size_vector_t)

class string_string_dict_t(object):
    """Proxy of C++ uhd::dict<(std::string,std::string)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(uhd::dict<(std::string,std::string)> self) -> string_string_dict_t"""
        this = _uhd_swig.new_string_string_dict_t()
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(string_string_dict_t self) -> std::size_t"""
        return _uhd_swig.string_string_dict_t_size(self)

    def keys(self):
        """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):
        """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, *args, **kwargs):
        """has_key(string_string_dict_t self, std::string const & key) -> bool"""
        return _uhd_swig.string_string_dict_t_has_key(self, *args, **kwargs)

    def get(self, *args):
        """
        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, *args, **kwargs):
        """set(string_string_dict_t self, std::string const & key, std::string const & val)"""
        return _uhd_swig.string_string_dict_t_set(self, *args, **kwargs)

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

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

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

    def update(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def __setitem__(self, *args, **kwargs):
        """__setitem__(string_string_dict_t self, std::string key, std::string val)"""
        return _uhd_swig.string_string_dict_t___setitem__(self, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_string_string_dict_t
    __del__ = lambda self : None;
string_string_dict_t_swigregister = _uhd_swig.string_string_dict_t_swigregister
string_string_dict_t_swigregister(string_string_dict_t)

class device_addr_t(string_string_dict_t):
    """Proxy of C++ uhd::device_addr_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(uhd::device_addr_t self, std::string const & args="") -> device_addr_t
        __init__(uhd::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
        """
        this = _uhd_swig.new_device_addr_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def to_pp_string(self):
        """to_pp_string(device_addr_t self) -> std::string"""
        return _uhd_swig.device_addr_t_to_pp_string(self)

    def to_string(self):
        """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
    __del__ = lambda self : None;
device_addr_t_swigregister = _uhd_swig.device_addr_t_swigregister
device_addr_t_swigregister(device_addr_t)


def separate_device_addr(*args, **kwargs):
  """separate_device_addr(device_addr_t dev_addr) -> device_addr_vector_t"""
  return _uhd_swig.separate_device_addr(*args, **kwargs)

def combine_device_addrs(*args, **kwargs):
  """combine_device_addrs(device_addr_vector_t dev_addrs) -> device_addr_t"""
  return _uhd_swig.combine_device_addrs(*args, **kwargs)
class io_type_t(object):
    """Proxy of C++ uhd::io_type_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CUSTOM_TYPE = _uhd_swig.io_type_t_CUSTOM_TYPE
    COMPLEX_FLOAT64 = _uhd_swig.io_type_t_COMPLEX_FLOAT64
    COMPLEX_FLOAT32 = _uhd_swig.io_type_t_COMPLEX_FLOAT32
    COMPLEX_INT16 = _uhd_swig.io_type_t_COMPLEX_INT16
    COMPLEX_INT8 = _uhd_swig.io_type_t_COMPLEX_INT8
    size = _swig_property(_uhd_swig.io_type_t_size_get)
    tid = _swig_property(_uhd_swig.io_type_t_tid_get)
    def __init__(self, *args): 
        """
        __init__(uhd::io_type_t self, uhd::io_type_t::tid_t tid) -> io_type_t
        __init__(uhd::io_type_t self, size_t size) -> io_type_t
        """
        this = _uhd_swig.new_io_type_t(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_io_type_t
    __del__ = lambda self : None;
io_type_t_swigregister = _uhd_swig.io_type_t_swigregister
io_type_t_swigregister(io_type_t)

class range_vector_t(object):
    """Proxy of C++ std::vector<(uhd::range_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(range_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.range_vector_t_iterator(self)

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

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

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

    def pop(self):
        """pop(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __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=std::vector< uhd::range_t,std::allocator< uhd::range_t > >())
        """
        return _uhd_swig.range_vector_t___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __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):
        """
        __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):
        """
        __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 append(self, *args, **kwargs):
        """append(range_vector_t self, range_t x)"""
        return _uhd_swig.range_vector_t_append(self, *args, **kwargs)

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

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

    def clear(self):
        """clear(range_vector_t self)"""
        return _uhd_swig.range_vector_t_clear(self)

    def swap(self, *args, **kwargs):
        """swap(range_vector_t self, range_vector_t v)"""
        return _uhd_swig.range_vector_t_swap(self, *args, **kwargs)

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

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

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

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

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

    def pop_back(self):
        """pop_back(range_vector_t self)"""
        return _uhd_swig.range_vector_t_pop_back(self)

    def erase(self, *args):
        """
        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): 
        """
        __init__(std::vector<(uhd::range_t)> self) -> range_vector_t
        __init__(std::vector<(uhd::range_t)> self, range_vector_t arg2) -> range_vector_t
        __init__(std::vector<(uhd::range_t)> self, std::vector< uhd::range_t >::size_type size) -> range_vector_t
        __init__(std::vector<(uhd::range_t)> self, std::vector< uhd::range_t >::size_type size, range_t value) -> range_vector_t
        """
        this = _uhd_swig.new_range_vector_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(range_vector_t self, range_t x)"""
        return _uhd_swig.range_vector_t_push_back(self, *args, **kwargs)

    def front(self):
        """front(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_front(self)

    def back(self):
        """back(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_back(self)

    def assign(self, *args, **kwargs):
        """assign(range_vector_t self, std::vector< uhd::range_t >::size_type n, range_t x)"""
        return _uhd_swig.range_vector_t_assign(self, *args, **kwargs)

    def resize(self, *args):
        """
        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):
        """
        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, *args, **kwargs):
        """reserve(range_vector_t self, std::vector< uhd::range_t >::size_type n)"""
        return _uhd_swig.range_vector_t_reserve(self, *args, **kwargs)

    def capacity(self):
        """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
    __del__ = lambda self : None;
range_vector_t_swigregister = _uhd_swig.range_vector_t_swigregister
range_vector_t_swigregister(range_vector_t)

class range_t(object):
    """Proxy of C++ uhd::range_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(uhd::range_t self, double value=0) -> range_t
        __init__(uhd::range_t self, double start, double stop, double step=0) -> range_t
        """
        this = _uhd_swig.new_range_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def start(self):
        """start(range_t self) -> double"""
        return _uhd_swig.range_t_start(self)

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

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

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

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

    def __ne__(self, *args, **kwargs):
        """__ne__(range_t self, range_t other) -> bool"""
        return _uhd_swig.range_t___ne__(self, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_range_t
    __del__ = lambda self : None;
range_t_swigregister = _uhd_swig.range_t_swigregister
range_t_swigregister(range_t)

class meta_range_t(range_vector_t):
    """Proxy of C++ uhd::meta_range_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(uhd::meta_range_t self) -> meta_range_t
        __init__(uhd::meta_range_t self, double start, double stop, double step=0) -> meta_range_t
        """
        this = _uhd_swig.new_meta_range_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def start(self):
        """start(meta_range_t self) -> double"""
        return _uhd_swig.meta_range_t_start(self)

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

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

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

    def to_pp_string(self):
        """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
    __del__ = lambda self : None;
meta_range_t_swigregister = _uhd_swig.meta_range_t_swigregister
meta_range_t_swigregister(meta_range_t)

class tune_request_t(object):
    """Proxy of C++ uhd::tune_request_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(uhd::tune_request_t self, double target_freq=0) -> tune_request_t
        __init__(uhd::tune_request_t self, double target_freq, double lo_off) -> tune_request_t
        """
        this = _uhd_swig.new_tune_request_t(*args)
        try: self.this.append(this)
        except: self.this = this
    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 = _swig_property(_uhd_swig.tune_request_t_target_freq_get, _uhd_swig.tune_request_t_target_freq_set)
    rf_freq_policy = _swig_property(_uhd_swig.tune_request_t_rf_freq_policy_get, _uhd_swig.tune_request_t_rf_freq_policy_set)
    rf_freq = _swig_property(_uhd_swig.tune_request_t_rf_freq_get, _uhd_swig.tune_request_t_rf_freq_set)
    dsp_freq_policy = _swig_property(_uhd_swig.tune_request_t_dsp_freq_policy_get, _uhd_swig.tune_request_t_dsp_freq_policy_set)
    dsp_freq = _swig_property(_uhd_swig.tune_request_t_dsp_freq_get, _uhd_swig.tune_request_t_dsp_freq_set)
    args = _swig_property(_uhd_swig.tune_request_t_args_get, _uhd_swig.tune_request_t_args_set)
    __swig_destroy__ = _uhd_swig.delete_tune_request_t
    __del__ = lambda self : None;
tune_request_t_swigregister = _uhd_swig.tune_request_t_swigregister
tune_request_t_swigregister(tune_request_t)

class tune_result_t(object):
    """Proxy of C++ uhd::tune_result_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    clipped_rf_freq = _swig_property(_uhd_swig.tune_result_t_clipped_rf_freq_get, _uhd_swig.tune_result_t_clipped_rf_freq_set)
    target_rf_freq = _swig_property(_uhd_swig.tune_result_t_target_rf_freq_get, _uhd_swig.tune_result_t_target_rf_freq_set)
    actual_rf_freq = _swig_property(_uhd_swig.tune_result_t_actual_rf_freq_get, _uhd_swig.tune_result_t_actual_rf_freq_set)
    target_dsp_freq = _swig_property(_uhd_swig.tune_result_t_target_dsp_freq_get, _uhd_swig.tune_result_t_target_dsp_freq_set)
    actual_dsp_freq = _swig_property(_uhd_swig.tune_result_t_actual_dsp_freq_get, _uhd_swig.tune_result_t_actual_dsp_freq_set)
    def to_pp_string(self):
        """to_pp_string(tune_result_t self) -> std::string"""
        return _uhd_swig.tune_result_t_to_pp_string(self)

    def __init__(self): 
        """__init__(uhd::tune_result_t self) -> tune_result_t"""
        this = _uhd_swig.new_tune_result_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_tune_result_t
    __del__ = lambda self : None;
tune_result_t_swigregister = _uhd_swig.tune_result_t_swigregister
tune_result_t_swigregister(tune_result_t)

class time_spec_t(object):
    """Proxy of C++ uhd::time_spec_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(uhd::time_spec_t self, double secs=0) -> time_spec_t
        __init__(uhd::time_spec_t self, int64_t full_secs, double frac_secs=0) -> time_spec_t
        __init__(uhd::time_spec_t self, int64_t full_secs, long tick_count, double tick_rate) -> time_spec_t
        """
        this = _uhd_swig.new_time_spec_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def from_ticks(*args, **kwargs):
        """from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
        return _uhd_swig.time_spec_t_from_ticks(*args, **kwargs)

    from_ticks = staticmethod(from_ticks)
    def get_tick_count(self, *args, **kwargs):
        """get_tick_count(time_spec_t self, double tick_rate) -> long"""
        return _uhd_swig.time_spec_t_get_tick_count(self, *args, **kwargs)

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

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

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

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

    def __iadd__(self, *args):
        """
        __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):
        """
        __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, *args, **kwargs):
        """__add__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _uhd_swig.time_spec_t___add__(self, *args, **kwargs)

    def __sub__(self, *args, **kwargs):
        """__sub__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _uhd_swig.time_spec_t___sub__(self, *args, **kwargs)

    def __eq__(self, *args, **kwargs):
        """__eq__(time_spec_t self, time_spec_t what) -> bool"""
        return _uhd_swig.time_spec_t___eq__(self, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_time_spec_t
    __del__ = lambda self : None;
time_spec_t_swigregister = _uhd_swig.time_spec_t_swigregister
time_spec_t_swigregister(time_spec_t)

def time_spec_t_from_ticks(*args, **kwargs):
  """time_spec_t_from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
  return _uhd_swig.time_spec_t_from_ticks(*args, **kwargs)


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

def __lt__(*args, **kwargs):
  """__lt__(time_spec_t arg1, time_spec_t arg2) -> bool"""
  return _uhd_swig.__lt__(*args, **kwargs)
class stream_cmd_t(object):
    """Proxy of C++ uhd::stream_cmd_t class"""
    thisown = _swig_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 = _swig_property(_uhd_swig.stream_cmd_t_stream_mode_get, _uhd_swig.stream_cmd_t_stream_mode_set)
    num_samps = _swig_property(_uhd_swig.stream_cmd_t_num_samps_get, _uhd_swig.stream_cmd_t_num_samps_set)
    stream_now = _swig_property(_uhd_swig.stream_cmd_t_stream_now_get, _uhd_swig.stream_cmd_t_stream_now_set)
    time_spec = _swig_property(_uhd_swig.stream_cmd_t_time_spec_get, _uhd_swig.stream_cmd_t_time_spec_set)
    def __init__(self, *args, **kwargs): 
        """__init__(uhd::stream_cmd_t self, uhd::stream_cmd_t::stream_mode_t const & stream_mode) -> stream_cmd_t"""
        this = _uhd_swig.new_stream_cmd_t(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_stream_cmd_t
    __del__ = lambda self : None;
stream_cmd_t_swigregister = _uhd_swig.stream_cmd_t_swigregister
stream_cmd_t_swigregister(stream_cmd_t)

class clock_config_t(object):
    """Proxy of C++ uhd::clock_config_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def external():
        """external() -> clock_config_t"""
        return _uhd_swig.clock_config_t_external()

    external = staticmethod(external)
    def internal():
        """internal() -> clock_config_t"""
        return _uhd_swig.clock_config_t_internal()

    internal = staticmethod(internal)
    REF_AUTO = _uhd_swig.clock_config_t_REF_AUTO
    REF_INT = _uhd_swig.clock_config_t_REF_INT
    REF_SMA = _uhd_swig.clock_config_t_REF_SMA
    REF_MIMO = _uhd_swig.clock_config_t_REF_MIMO
    ref_source = _swig_property(_uhd_swig.clock_config_t_ref_source_get, _uhd_swig.clock_config_t_ref_source_set)
    PPS_INT = _uhd_swig.clock_config_t_PPS_INT
    PPS_SMA = _uhd_swig.clock_config_t_PPS_SMA
    PPS_MIMO = _uhd_swig.clock_config_t_PPS_MIMO
    pps_source = _swig_property(_uhd_swig.clock_config_t_pps_source_get, _uhd_swig.clock_config_t_pps_source_set)
    PPS_NEG = _uhd_swig.clock_config_t_PPS_NEG
    PPS_POS = _uhd_swig.clock_config_t_PPS_POS
    pps_polarity = _swig_property(_uhd_swig.clock_config_t_pps_polarity_get, _uhd_swig.clock_config_t_pps_polarity_set)
    def __init__(self): 
        """__init__(uhd::clock_config_t self) -> clock_config_t"""
        this = _uhd_swig.new_clock_config_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_clock_config_t
    __del__ = lambda self : None;
clock_config_t_swigregister = _uhd_swig.clock_config_t_swigregister
clock_config_t_swigregister(clock_config_t)

def clock_config_t_external():
  """clock_config_t_external() -> clock_config_t"""
  return _uhd_swig.clock_config_t_external()

def clock_config_t_internal():
  """clock_config_t_internal() -> clock_config_t"""
  return _uhd_swig.clock_config_t_internal()

class rx_metadata_t(object):
    """Proxy of C++ uhd::rx_metadata_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(uhd::rx_metadata_t self) -> rx_metadata_t"""
        this = _uhd_swig.new_rx_metadata_t()
        try: self.this.append(this)
        except: self.this = this
    def reset(self):
        """reset(rx_metadata_t self)"""
        return _uhd_swig.rx_metadata_t_reset(self)

    has_time_spec = _swig_property(_uhd_swig.rx_metadata_t_has_time_spec_get, _uhd_swig.rx_metadata_t_has_time_spec_set)
    time_spec = _swig_property(_uhd_swig.rx_metadata_t_time_spec_get, _uhd_swig.rx_metadata_t_time_spec_set)
    more_fragments = _swig_property(_uhd_swig.rx_metadata_t_more_fragments_get, _uhd_swig.rx_metadata_t_more_fragments_set)
    fragment_offset = _swig_property(_uhd_swig.rx_metadata_t_fragment_offset_get, _uhd_swig.rx_metadata_t_fragment_offset_set)
    start_of_burst = _swig_property(_uhd_swig.rx_metadata_t_start_of_burst_get, _uhd_swig.rx_metadata_t_start_of_burst_set)
    end_of_burst = _swig_property(_uhd_swig.rx_metadata_t_end_of_burst_get, _uhd_swig.rx_metadata_t_end_of_burst_set)
    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 = _swig_property(_uhd_swig.rx_metadata_t_error_code_get, _uhd_swig.rx_metadata_t_error_code_set)
    out_of_sequence = _swig_property(_uhd_swig.rx_metadata_t_out_of_sequence_get, _uhd_swig.rx_metadata_t_out_of_sequence_set)
    def to_pp_string(self, compact=True):
        """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):
        """strerror(rx_metadata_t self) -> std::string"""
        return _uhd_swig.rx_metadata_t_strerror(self)

    __swig_destroy__ = _uhd_swig.delete_rx_metadata_t
    __del__ = lambda self : None;
rx_metadata_t_swigregister = _uhd_swig.rx_metadata_t_swigregister
rx_metadata_t_swigregister(rx_metadata_t)

class tx_metadata_t(object):
    """Proxy of C++ uhd::tx_metadata_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    has_time_spec = _swig_property(_uhd_swig.tx_metadata_t_has_time_spec_get, _uhd_swig.tx_metadata_t_has_time_spec_set)
    time_spec = _swig_property(_uhd_swig.tx_metadata_t_time_spec_get, _uhd_swig.tx_metadata_t_time_spec_set)
    start_of_burst = _swig_property(_uhd_swig.tx_metadata_t_start_of_burst_get, _uhd_swig.tx_metadata_t_start_of_burst_set)
    end_of_burst = _swig_property(_uhd_swig.tx_metadata_t_end_of_burst_get, _uhd_swig.tx_metadata_t_end_of_burst_set)
    def __init__(self): 
        """__init__(uhd::tx_metadata_t self) -> tx_metadata_t"""
        this = _uhd_swig.new_tx_metadata_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_tx_metadata_t
    __del__ = lambda self : None;
tx_metadata_t_swigregister = _uhd_swig.tx_metadata_t_swigregister
tx_metadata_t_swigregister(tx_metadata_t)

class async_metadata_t(object):
    """Proxy of C++ uhd::async_metadata_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    channel = _swig_property(_uhd_swig.async_metadata_t_channel_get, _uhd_swig.async_metadata_t_channel_set)
    has_time_spec = _swig_property(_uhd_swig.async_metadata_t_has_time_spec_get, _uhd_swig.async_metadata_t_has_time_spec_set)
    time_spec = _swig_property(_uhd_swig.async_metadata_t_time_spec_get, _uhd_swig.async_metadata_t_time_spec_set)
    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 = _swig_property(_uhd_swig.async_metadata_t_event_code_get, _uhd_swig.async_metadata_t_event_code_set)
    user_payload = _swig_property(_uhd_swig.async_metadata_t_user_payload_get, _uhd_swig.async_metadata_t_user_payload_set)
    def __init__(self): 
        """__init__(uhd::async_metadata_t self) -> async_metadata_t"""
        this = _uhd_swig.new_async_metadata_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_async_metadata_t
    __del__ = lambda self : None;
async_metadata_t_swigregister = _uhd_swig.async_metadata_t_swigregister
async_metadata_t_swigregister(async_metadata_t)

class device_addr_vector_t(object):
    """Proxy of C++ std::vector<(uhd::device_addr_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """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):
        """__nonzero__(device_addr_vector_t self) -> bool"""
        return _uhd_swig.device_addr_vector_t___nonzero__(self)

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

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

    def pop(self):
        """pop(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_pop(self)

    def __getslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

    def __setslice__(self, *args, **kwargs):
        """
        __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=std::vector< uhd::device_addr_t,std::allocator< uhd::device_addr_t > >())
        """
        return _uhd_swig.device_addr_vector_t___setslice__(self, *args, **kwargs)

    def __delslice__(self, *args, **kwargs):
        """__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, *args, **kwargs)

    def __delitem__(self, *args):
        """
        __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):
        """
        __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):
        """
        __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 append(self, *args, **kwargs):
        """append(device_addr_vector_t self, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_append(self, *args, **kwargs)

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

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

    def clear(self):
        """clear(device_addr_vector_t self)"""
        return _uhd_swig.device_addr_vector_t_clear(self)

    def swap(self, *args, **kwargs):
        """swap(device_addr_vector_t self, device_addr_vector_t v)"""
        return _uhd_swig.device_addr_vector_t_swap(self, *args, **kwargs)

    def get_allocator(self):
        """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 begin(self):
        """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):
        """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):
        """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):
        """rend(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::reverse_iterator"""
        return _uhd_swig.device_addr_vector_t_rend(self)

    def pop_back(self):
        """pop_back(device_addr_vector_t self)"""
        return _uhd_swig.device_addr_vector_t_pop_back(self)

    def erase(self, *args):
        """
        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): 
        """
        __init__(std::vector<(uhd::device_addr_t)> self) -> device_addr_vector_t
        __init__(std::vector<(uhd::device_addr_t)> self, device_addr_vector_t arg2) -> device_addr_vector_t
        __init__(std::vector<(uhd::device_addr_t)> self, std::vector< uhd::device_addr_t >::size_type size) -> device_addr_vector_t
        __init__(std::vector<(uhd::device_addr_t)> self, std::vector< uhd::device_addr_t >::size_type size, device_addr_t value) -> device_addr_vector_t
        """
        this = _uhd_swig.new_device_addr_vector_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args, **kwargs):
        """push_back(device_addr_vector_t self, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_push_back(self, *args, **kwargs)

    def front(self):
        """front(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_front(self)

    def back(self):
        """back(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_back(self)

    def assign(self, *args, **kwargs):
        """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, *args, **kwargs)

    def resize(self, *args):
        """
        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):
        """
        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, *args, **kwargs):
        """reserve(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type n)"""
        return _uhd_swig.device_addr_vector_t_reserve(self, *args, **kwargs)

    def capacity(self):
        """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
    __del__ = lambda self : None;
device_addr_vector_t_swigregister = _uhd_swig.device_addr_vector_t_swigregister
device_addr_vector_t_swigregister(device_addr_vector_t)

class sensor_value_t(object):
    """Proxy of C++ uhd::sensor_value_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(uhd::sensor_value_t self, std::string const & name, bool value, std::string const & utrue, std::string const & ufalse) -> sensor_value_t
        __init__(uhd::sensor_value_t self, std::string const & name, int value, std::string const & unit, std::string const & formatter="%d") -> sensor_value_t
        __init__(uhd::sensor_value_t self, std::string const & name, double value, std::string const & unit, std::string const & formatter="%f") -> sensor_value_t
        __init__(uhd::sensor_value_t self, std::string const & name, std::string const & value, std::string const & unit) -> sensor_value_t
        __init__(uhd::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__(uhd::sensor_value_t self, sensor_value_t source) -> sensor_value_t
        """
        this = _uhd_swig.new_sensor_value_t(*args)
        try: self.this.append(this)
        except: self.this = this
    def to_bool(self):
        """to_bool(sensor_value_t self) -> bool"""
        return _uhd_swig.sensor_value_t_to_bool(self)

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

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

    def to_map(self):
        """to_map(sensor_value_t self) -> uhd::sensor_value_t::sensor_map_t"""
        return _uhd_swig.sensor_value_t_to_map(self)

    name = _swig_property(_uhd_swig.sensor_value_t_name_get, _uhd_swig.sensor_value_t_name_set)
    value = _swig_property(_uhd_swig.sensor_value_t_value_get, _uhd_swig.sensor_value_t_value_set)
    unit = _swig_property(_uhd_swig.sensor_value_t_unit_get, _uhd_swig.sensor_value_t_unit_set)
    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 = _swig_property(_uhd_swig.sensor_value_t_type_get, _uhd_swig.sensor_value_t_type_set)
    def to_pp_string(self):
        """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
    __del__ = lambda self : None;
sensor_value_t_swigregister = _uhd_swig.sensor_value_t_swigregister
sensor_value_t_swigregister(sensor_value_t)

class stream_args_t(object):
    """Proxy of C++ uhd::stream_args_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, cpu="", otw=""): 
        """__init__(uhd::stream_args_t self, std::string const & cpu="", std::string const & otw="") -> stream_args_t"""
        this = _uhd_swig.new_stream_args_t(cpu, otw)
        try: self.this.append(this)
        except: self.this = this
    cpu_format = _swig_property(_uhd_swig.stream_args_t_cpu_format_get, _uhd_swig.stream_args_t_cpu_format_set)
    otw_format = _swig_property(_uhd_swig.stream_args_t_otw_format_get, _uhd_swig.stream_args_t_otw_format_set)
    args = _swig_property(_uhd_swig.stream_args_t_args_get, _uhd_swig.stream_args_t_args_set)
    channels = _swig_property(_uhd_swig.stream_args_t_channels_get, _uhd_swig.stream_args_t_channels_set)
    __swig_destroy__ = _uhd_swig.delete_stream_args_t
    __del__ = lambda self : None;
stream_args_t_swigregister = _uhd_swig.stream_args_t_swigregister
stream_args_t_swigregister(stream_args_t)

class rx_streamer(object):
    """Proxy of C++ uhd::rx_streamer class"""
    thisown = _swig_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
    __del__ = lambda self : None;
    def get_num_channels(self):
        """get_num_channels(rx_streamer self) -> size_t"""
        return _uhd_swig.rx_streamer_get_num_channels(self)

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

    def recv(self, *args, **kwargs):
        """
        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, *args, **kwargs)

    def issue_stream_cmd(self, *args, **kwargs):
        """issue_stream_cmd(rx_streamer self, stream_cmd_t stream_cmd)"""
        return _uhd_swig.rx_streamer_issue_stream_cmd(self, *args, **kwargs)

rx_streamer_swigregister = _uhd_swig.rx_streamer_swigregister
rx_streamer_swigregister(rx_streamer)

class tx_streamer(object):
    """Proxy of C++ uhd::tx_streamer class"""
    thisown = _swig_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
    __del__ = lambda self : None;
    def get_num_channels(self):
        """get_num_channels(tx_streamer self) -> size_t"""
        return _uhd_swig.tx_streamer_get_num_channels(self)

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

    def send(self, *args, **kwargs):
        """
        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, *args, **kwargs)

    def recv_async_msg(self, *args, **kwargs):
        """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, *args, **kwargs)

tx_streamer_swigregister = _uhd_swig.tx_streamer_swigregister
tx_streamer_swigregister(tx_streamer)

class i2c_iface(object):
    """Proxy of C++ uhd::i2c_iface class"""
    thisown = _swig_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
    __del__ = lambda self : None;
    def eeprom16(self):
        """eeprom16(i2c_iface self) -> uhd::i2c_iface::sptr"""
        return _uhd_swig.i2c_iface_eeprom16(self)

    def write_i2c(self, *args, **kwargs):
        """write_i2c(i2c_iface self, uint16_t addr, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.i2c_iface_write_i2c(self, *args, **kwargs)

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

    def write_eeprom(self, *args, **kwargs):
        """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, *args, **kwargs)

    def read_eeprom(self, *args, **kwargs):
        """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, *args, **kwargs)

i2c_iface_swigregister = _uhd_swig.i2c_iface_swigregister
i2c_iface_swigregister(i2c_iface)

class spi_config_t(object):
    """Proxy of C++ uhd::spi_config_t class"""
    thisown = _swig_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 = _swig_property(_uhd_swig.spi_config_t_mosi_edge_get, _uhd_swig.spi_config_t_mosi_edge_set)
    miso_edge = _swig_property(_uhd_swig.spi_config_t_miso_edge_get, _uhd_swig.spi_config_t_miso_edge_set)
    use_custom_divider = _swig_property(_uhd_swig.spi_config_t_use_custom_divider_get, _uhd_swig.spi_config_t_use_custom_divider_set)
    divider = _swig_property(_uhd_swig.spi_config_t_divider_get, _uhd_swig.spi_config_t_divider_set)
    def __init__(self, *args, **kwargs): 
        """__init__(uhd::spi_config_t self, uhd::spi_config_t::edge_t edge=EDGE_RISE) -> spi_config_t"""
        this = _uhd_swig.new_spi_config_t(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_spi_config_t
    __del__ = lambda self : None;
spi_config_t_swigregister = _uhd_swig.spi_config_t_swigregister
spi_config_t_swigregister(spi_config_t)

class spi_iface(object):
    """Proxy of C++ uhd::spi_iface class"""
    thisown = _swig_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
    __del__ = lambda self : None;
    def transact_spi(self, *args, **kwargs):
        """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, *args, **kwargs)

    def read_spi(self, *args, **kwargs):
        """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, *args, **kwargs)

    def write_spi(self, *args, **kwargs):
        """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, *args, **kwargs)

spi_iface_swigregister = _uhd_swig.spi_iface_swigregister
spi_iface_swigregister(spi_iface)

class uart_iface(object):
    """Proxy of C++ uhd::uart_iface class"""
    thisown = _swig_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
    __del__ = lambda self : None;
    def write_uart(self, *args, **kwargs):
        """write_uart(uart_iface self, std::string const & buf)"""
        return _uhd_swig.uart_iface_write_uart(self, *args, **kwargs)

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

uart_iface_swigregister = _uhd_swig.uart_iface_swigregister
uart_iface_swigregister(uart_iface)

class dboard_iface_special_props_t(object):
    """Proxy of C++ uhd::usrp::dboard_iface_special_props_t class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    soft_clock_divider = _swig_property(_uhd_swig.dboard_iface_special_props_t_soft_clock_divider_get, _uhd_swig.dboard_iface_special_props_t_soft_clock_divider_set)
    mangle_i2c_addrs = _swig_property(_uhd_swig.dboard_iface_special_props_t_mangle_i2c_addrs_get, _uhd_swig.dboard_iface_special_props_t_mangle_i2c_addrs_set)
    def __init__(self): 
        """__init__(uhd::usrp::dboard_iface_special_props_t self) -> dboard_iface_special_props_t"""
        this = _uhd_swig.new_dboard_iface_special_props_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _uhd_swig.delete_dboard_iface_special_props_t
    __del__ = lambda self : None;
dboard_iface_special_props_t_swigregister = _uhd_swig.dboard_iface_special_props_t_swigregister
dboard_iface_special_props_t_swigregister(dboard_iface_special_props_t)

class dboard_iface(i2c_iface):
    """Proxy of C++ uhd::usrp::dboard_iface class"""
    thisown = _swig_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
    __del__ = lambda self : None;
    def get_special_props(self):
        """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, *args, **kwargs):
        """
        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, *args, **kwargs)

    def read_aux_adc(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_pin_ctrl(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def set_atr_reg(self, *args, **kwargs):
        """
        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, *args, **kwargs)

    def get_atr_reg(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_gpio_ddr(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def set_gpio_out(self, *args, **kwargs):
        """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, *args, **kwargs)

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

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

    def write_spi(self, *args, **kwargs):
        """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, *args, **kwargs)

    def read_write_spi(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_rate(self, *args, **kwargs):
        """set_clock_rate(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, double rate)"""
        return _uhd_swig.dboard_iface_set_clock_rate(self, *args, **kwargs)

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

    def get_clock_rates(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_enabled(self, *args, **kwargs):
        """set_clock_enabled(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, bool enb)"""
        return _uhd_swig.dboard_iface_set_clock_enabled(self, *args, **kwargs)

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

    def set_fe_connection(self, *args, **kwargs):
        """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, *args, **kwargs)

    def has_set_fe_connection(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def set_command_time(self, *args, **kwargs):
        """set_command_time(dboard_iface self, time_spec_t t)"""
        return _uhd_swig.dboard_iface_set_command_time(self, *args, **kwargs)

    def sleep(self, *args, **kwargs):
        """sleep(dboard_iface self, boost::chrono::nanoseconds const & time)"""
        return _uhd_swig.dboard_iface_sleep(self, *args, **kwargs)

dboard_iface_swigregister = _uhd_swig.dboard_iface_swigregister
dboard_iface_swigregister(dboard_iface)

class dboard_iface_sptr(object):
    """Proxy of C++ boost::shared_ptr<(uhd::usrp::dboard_iface)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(uhd::usrp::dboard_iface)> self) -> dboard_iface_sptr
        __init__(boost::shared_ptr<(uhd::usrp::dboard_iface)> self, dboard_iface p) -> dboard_iface_sptr
        """
        this = _uhd_swig.new_dboard_iface_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(dboard_iface_sptr self) -> dboard_iface"""
        return _uhd_swig.dboard_iface_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_dboard_iface_sptr
    __del__ = lambda self : None;
    def get_special_props(self):
        """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, *args, **kwargs):
        """
        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, *args, **kwargs)

    def read_aux_adc(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_pin_ctrl(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_pin_ctrl(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_atr_reg(self, *args, **kwargs):
        """
        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, *args, **kwargs)

    def get_atr_reg(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_gpio_ddr(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_gpio_ddr(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_gpio_out(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_gpio_out(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def write_spi(self, *args, **kwargs):
        """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, *args, **kwargs)

    def read_write_spi(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_rate(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_clock_rate(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_clock_rates(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_enabled(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_codec_rate(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_fe_connection(self, *args, **kwargs):
        """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, *args, **kwargs)

    def has_set_fe_connection(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_command_time(self):
        """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, *args, **kwargs):
        """set_command_time(dboard_iface_sptr self, time_spec_t t)"""
        return _uhd_swig.dboard_iface_sptr_set_command_time(self, *args, **kwargs)

    def sleep(self, *args, **kwargs):
        """sleep(dboard_iface_sptr self, boost::chrono::nanoseconds const & time)"""
        return _uhd_swig.dboard_iface_sptr_sleep(self, *args, **kwargs)

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

    def write_i2c(self, *args, **kwargs):
        """write_i2c(dboard_iface_sptr self, uint16_t addr, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.dboard_iface_sptr_write_i2c(self, *args, **kwargs)

    def read_i2c(self, *args, **kwargs):
        """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, *args, **kwargs)

    def write_eeprom(self, *args, **kwargs):
        """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, *args, **kwargs)

    def read_eeprom(self, *args, **kwargs):
        """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, *args, **kwargs)

dboard_iface_sptr_swigregister = _uhd_swig.dboard_iface_sptr_swigregister
dboard_iface_sptr_swigregister(dboard_iface_sptr)

class usrp_source(usrp_block):
    """Proxy of C++ gr::uhd::usrp_source class"""
    thisown = _swig_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 make(*args):
        """
        make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_source_sptr
        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(*args)

    make = staticmethod(make)
    def set_start_time(self, *args, **kwargs):
        """set_start_time(usrp_source self, time_spec_t time)"""
        return _uhd_swig.usrp_source_set_start_time(self, *args, **kwargs)

    def issue_stream_cmd(self, *args, **kwargs):
        """issue_stream_cmd(usrp_source self, stream_cmd_t cmd)"""
        return _uhd_swig.usrp_source_issue_stream_cmd(self, *args, **kwargs)

    def set_recv_timeout(self, *args, **kwargs):
        """set_recv_timeout(usrp_source self, double const timeout, bool const one_packet=True)"""
        return _uhd_swig.usrp_source_set_recv_timeout(self, *args, **kwargs)

    def get_usrp_info(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_source(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_lo_export_enabled(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_export_enabled(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_lo_freq(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def get_lo_freq_range(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_auto_dc_offset(self, *args, **kwargs):
        """set_auto_dc_offset(usrp_source self, bool const enb, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_auto_dc_offset(self, *args, **kwargs)

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

    def set_auto_iq_balance(self, *args, **kwargs):
        """set_auto_iq_balance(usrp_source self, bool const enb, size_t chan=0)"""
        return _uhd_swig.usrp_source_set_auto_iq_balance(self, *args, **kwargs)

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

    def finite_acquisition(self, *args, **kwargs):
        """finite_acquisition(usrp_source self, size_t const nsamps) -> pmt_vector_cfloat"""
        return _uhd_swig.usrp_source_finite_acquisition(self, *args, **kwargs)

    def finite_acquisition_v(self, *args, **kwargs):
        """finite_acquisition_v(usrp_source self, size_t const nsamps) -> gr_vector_vector_complexf"""
        return _uhd_swig.usrp_source_finite_acquisition_v(self, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_usrp_source
    __del__ = lambda self : None;
usrp_source_swigregister = _uhd_swig.usrp_source_swigregister
usrp_source_swigregister(usrp_source)

def usrp_source_make(*args):
  """
    make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_source_sptr
    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(*args)

class usrp_sink(usrp_block):
    """Proxy of C++ gr::uhd::usrp_sink class"""
    thisown = _swig_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 make(*args):
        """
        make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_sink_sptr
        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)

    make = staticmethod(make)
    def set_start_time(self, *args, **kwargs):
        """set_start_time(usrp_sink self, time_spec_t time)"""
        return _uhd_swig.usrp_sink_set_start_time(self, *args, **kwargs)

    def get_usrp_info(self, chan=0):
        """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 set_dc_offset(self, *args, **kwargs):
        """set_dc_offset(usrp_sink self, std::complex< double > const & offset, size_t chan=0)"""
        return _uhd_swig.usrp_sink_set_dc_offset(self, *args, **kwargs)

    def set_iq_balance(self, *args, **kwargs):
        """set_iq_balance(usrp_sink self, std::complex< double > const & correction, size_t chan=0)"""
        return _uhd_swig.usrp_sink_set_iq_balance(self, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_usrp_sink
    __del__ = lambda self : None;
usrp_sink_swigregister = _uhd_swig.usrp_sink_swigregister
usrp_sink_swigregister(usrp_sink)

def usrp_sink_make(*args):
  """
    make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_sink_sptr
    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)

class amsg_source(object):
    """Proxy of C++ gr::uhd::amsg_source class"""
    thisown = _swig_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
    __del__ = lambda self : None;
    def make(*args, **kwargs):
        """make(device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
        return _uhd_swig.amsg_source_make(*args, **kwargs)

    make = staticmethod(make)
    def msg_to_async_metadata_t(*args, **kwargs):
        """msg_to_async_metadata_t(message_sptr msg) -> async_metadata_t"""
        return _uhd_swig.amsg_source_msg_to_async_metadata_t(*args, **kwargs)

    msg_to_async_metadata_t = staticmethod(msg_to_async_metadata_t)
    def __init__(self): 
        """__init__(gr::uhd::amsg_source self) -> amsg_source"""
        this = _uhd_swig.new_amsg_source()
        try: self.this.append(this)
        except: self.this = this
amsg_source_swigregister = _uhd_swig.amsg_source_swigregister
amsg_source_swigregister(amsg_source)

def amsg_source_make(*args, **kwargs):
  """amsg_source_make(device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
  return _uhd_swig.amsg_source_make(*args, **kwargs)

def amsg_source_msg_to_async_metadata_t(*args, **kwargs):
  """amsg_source_msg_to_async_metadata_t(message_sptr msg) -> async_metadata_t"""
  return _uhd_swig.amsg_source_msg_to_async_metadata_t(*args, **kwargs)

class usrp_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::uhd::usrp_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::uhd::usrp_source)> self) -> usrp_source_sptr
        __init__(boost::shared_ptr<(gr::uhd::usrp_source)> self, usrp_source p) -> usrp_source_sptr
        """
        this = _uhd_swig.new_usrp_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(usrp_source_sptr self) -> usrp_source"""
        return _uhd_swig.usrp_source_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_usrp_source_sptr
    __del__ = lambda self : None;
    def make(self, *args):
        """
        make(usrp_source_sptr self, device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_source_sptr
        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, *args)

    def set_start_time(self, *args, **kwargs):
        """set_start_time(usrp_source_sptr self, time_spec_t time)"""
        return _uhd_swig.usrp_source_sptr_set_start_time(self, *args, **kwargs)

    def issue_stream_cmd(self, *args, **kwargs):
        """issue_stream_cmd(usrp_source_sptr self, stream_cmd_t cmd)"""
        return _uhd_swig.usrp_source_sptr_issue_stream_cmd(self, *args, **kwargs)

    def set_recv_timeout(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_usrp_info(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_source(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_lo_export_enabled(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_export_enabled(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_lo_freq(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_freq(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_lo_freq_range(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_auto_dc_offset(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_dc_offset(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_auto_iq_balance(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_iq_balance(self, *args, **kwargs):
        """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, *args, **kwargs)

    def finite_acquisition(self, *args, **kwargs):
        """finite_acquisition(usrp_source_sptr self, size_t const nsamps) -> pmt_vector_cfloat"""
        return _uhd_swig.usrp_source_sptr_finite_acquisition(self, *args, **kwargs)

    def finite_acquisition_v(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_subdev_spec(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_subdev_spec(self, mboard=0):
        """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):
        """get_num_mboards(usrp_source_sptr self) -> size_t"""
        return _uhd_swig.usrp_source_sptr_get_num_mboards(self)

    def set_samp_rate(self, *args, **kwargs):
        """set_samp_rate(usrp_source_sptr self, double rate)"""
        return _uhd_swig.usrp_source_sptr_set_samp_rate(self, *args, **kwargs)

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

    def get_samp_rates(self):
        """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):
        """
        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=0):
        """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=0):
        """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):
        """
        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, *args, **kwargs):
        """set_normalized_gain(usrp_source_sptr self, double norm_gain, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_normalized_gain(self, *args, **kwargs)

    def get_gain(self, *args):
        """
        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=0):
        """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=0):
        """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):
        """
        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, *args, **kwargs):
        """set_antenna(usrp_source_sptr self, std::string const & ant, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_antenna(self, *args, **kwargs)

    def get_antenna(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """set_bandwidth(usrp_source_sptr self, double bandwidth, size_t chan=0)"""
        return _uhd_swig.usrp_source_sptr_set_bandwidth(self, *args, **kwargs)

    def get_bandwidth(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_sensor_names(self, chan=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_dboard_sensor_names(self, chan=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_mboard_sensor_names(self, mboard=0):
        """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, *args, **kwargs):
        """get_time_source(usrp_source_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_time_source(self, *args, **kwargs)

    def get_time_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_source(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def get_clock_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_clock_rate(self, mboard=0):
        """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, *args, **kwargs):
        """set_clock_rate(usrp_source_sptr self, double rate, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_clock_rate(self, *args, **kwargs)

    def get_time_now(self, mboard=0):
        """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=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def set_time_next_pps(self, *args, **kwargs):
        """set_time_next_pps(usrp_source_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_source_sptr_set_time_next_pps(self, *args, **kwargs)

    def set_time_unknown_pps(self, *args, **kwargs):
        """set_time_unknown_pps(usrp_source_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_source_sptr_set_time_unknown_pps(self, *args, **kwargs)

    def set_command_time(self, *args, **kwargs):
        """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, *args, **kwargs)

    def clear_command_time(self, mboard=0):
        """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=0):
        """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):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_config(self, *args, **kwargs):
        """set_clock_config(usrp_source_sptr self, clock_config_t clock_config, size_t mboard=0)"""
        return _uhd_swig.usrp_source_sptr_set_clock_config(self, *args, **kwargs)

    def set_time_source(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_stream_args(self, *args, **kwargs):
        """set_stream_args(usrp_source_sptr self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_source_sptr_set_stream_args(self, *args, **kwargs)

    def get_gpio_banks(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_gpio_attr(self, *args, **kwargs):
        """
        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, *args, **kwargs):
        """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, *args, **kwargs)

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

    def declare_sample_delay(self, *args):
        """
        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, *args, **kwargs):
        """sample_delay(usrp_source_sptr self, int which) -> unsigned int"""
        return _uhd_swig.usrp_source_sptr_sample_delay(self, *args, **kwargs)

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

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

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

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

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

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

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

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(usrp_source_sptr self, int m)"""
        return _uhd_swig.usrp_source_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """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):
        """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, *args, **kwargs):
        """set_min_noutput_items(usrp_source_sptr self, int m)"""
        return _uhd_swig.usrp_source_sptr_set_min_noutput_items(self, *args, **kwargs)

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

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

    def set_max_output_buffer(self, *args):
        """
        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, *args, **kwargs):
        """min_output_buffer(usrp_source_sptr self, int i) -> long"""
        return _uhd_swig.usrp_source_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        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):
        """pc_noutput_items(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """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, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(usrp_source_sptr self)"""
        return _uhd_swig.usrp_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """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):
        """active_thread_priority(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self):
        """input_signature(usrp_source_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_source_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(usrp_source_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_source_sptr_output_signature(self)

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

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

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

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

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(usrp_source_sptr self, std::string name)"""
        return _uhd_swig.usrp_source_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(usrp_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _uhd_swig.usrp_source_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(usrp_source_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_source_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(usrp_source_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_source_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(usrp_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _uhd_swig.usrp_source_sptr_message_subscribers(self, *args, **kwargs)

usrp_source_sptr_swigregister = _uhd_swig.usrp_source_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::uhd::usrp_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::uhd::usrp_sink)> self) -> usrp_sink_sptr
        __init__(boost::shared_ptr<(gr::uhd::usrp_sink)> self, usrp_sink p) -> usrp_sink_sptr
        """
        this = _uhd_swig.new_usrp_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(usrp_sink_sptr self) -> usrp_sink"""
        return _uhd_swig.usrp_sink_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_usrp_sink_sptr
    __del__ = lambda self : None;
    def make(self, *args):
        """
        make(usrp_sink_sptr self, device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_sink_sptr
        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)

    def set_start_time(self, *args, **kwargs):
        """set_start_time(usrp_sink_sptr self, time_spec_t time)"""
        return _uhd_swig.usrp_sink_sptr_set_start_time(self, *args, **kwargs)

    def get_usrp_info(self, chan=0):
        """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 set_dc_offset(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_iq_balance(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_subdev_spec(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_subdev_spec(self, mboard=0):
        """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):
        """get_num_mboards(usrp_sink_sptr self) -> size_t"""
        return _uhd_swig.usrp_sink_sptr_get_num_mboards(self)

    def set_samp_rate(self, *args, **kwargs):
        """set_samp_rate(usrp_sink_sptr self, double rate)"""
        return _uhd_swig.usrp_sink_sptr_set_samp_rate(self, *args, **kwargs)

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

    def get_samp_rates(self):
        """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):
        """
        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=0):
        """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=0):
        """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):
        """
        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, *args, **kwargs):
        """set_normalized_gain(usrp_sink_sptr self, double norm_gain, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_normalized_gain(self, *args, **kwargs)

    def get_gain(self, *args):
        """
        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=0):
        """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=0):
        """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):
        """
        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, *args, **kwargs):
        """set_antenna(usrp_sink_sptr self, std::string const & ant, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_antenna(self, *args, **kwargs)

    def get_antenna(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """set_bandwidth(usrp_sink_sptr self, double bandwidth, size_t chan=0)"""
        return _uhd_swig.usrp_sink_sptr_set_bandwidth(self, *args, **kwargs)

    def get_bandwidth(self, chan=0):
        """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=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_sensor_names(self, chan=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_dboard_sensor_names(self, chan=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def get_mboard_sensor_names(self, mboard=0):
        """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, *args, **kwargs):
        """get_time_source(usrp_sink_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_time_source(self, *args, **kwargs)

    def get_time_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_source(self, *args, **kwargs):
        """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, *args, **kwargs)

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

    def get_clock_sources(self, *args, **kwargs):
        """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, *args, **kwargs)

    def get_clock_rate(self, mboard=0):
        """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, *args, **kwargs):
        """set_clock_rate(usrp_sink_sptr self, double rate, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_clock_rate(self, *args, **kwargs)

    def get_time_now(self, mboard=0):
        """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=0):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def set_time_next_pps(self, *args, **kwargs):
        """set_time_next_pps(usrp_sink_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_sink_sptr_set_time_next_pps(self, *args, **kwargs)

    def set_time_unknown_pps(self, *args, **kwargs):
        """set_time_unknown_pps(usrp_sink_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_sink_sptr_set_time_unknown_pps(self, *args, **kwargs)

    def set_command_time(self, *args, **kwargs):
        """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, *args, **kwargs)

    def clear_command_time(self, mboard=0):
        """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=0):
        """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):
        """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, *args, **kwargs):
        """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, *args, **kwargs)

    def set_clock_config(self, *args, **kwargs):
        """set_clock_config(usrp_sink_sptr self, clock_config_t clock_config, size_t mboard=0)"""
        return _uhd_swig.usrp_sink_sptr_set_clock_config(self, *args, **kwargs)

    def set_time_source(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_stream_args(self, *args, **kwargs):
        """set_stream_args(usrp_sink_sptr self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_sink_sptr_set_stream_args(self, *args, **kwargs)

    def get_gpio_banks(self, *args, **kwargs):
        """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, *args, **kwargs)

    def set_gpio_attr(self, *args, **kwargs):
        """
        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, *args, **kwargs):
        """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, *args, **kwargs)

    def history(self):
        """history(usrp_sink_sptr self) -> unsigned int"""
        return _uhd_swig.usrp_sink_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        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, *args, **kwargs):
        """sample_delay(usrp_sink_sptr self, int which) -> unsigned int"""
        return _uhd_swig.usrp_sink_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(usrp_sink_sptr self) -> double"""
        return _uhd_swig.usrp_sink_sptr_relative_rate(self)

    def start(self):
        """start(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_start(self)

    def stop(self):
        """stop(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(usrp_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(usrp_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(usrp_sink_sptr self, int m)"""
        return _uhd_swig.usrp_sink_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """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):
        """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, *args, **kwargs):
        """set_min_noutput_items(usrp_sink_sptr self, int m)"""
        return _uhd_swig.usrp_sink_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(usrp_sink_sptr self, int i) -> long"""
        return _uhd_swig.usrp_sink_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        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, *args, **kwargs):
        """min_output_buffer(usrp_sink_sptr self, int i) -> long"""
        return _uhd_swig.usrp_sink_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        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):
        """pc_noutput_items(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """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, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(usrp_sink_sptr self)"""
        return _uhd_swig.usrp_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """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):
        """active_thread_priority(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(usrp_sink_sptr self, int priority) -> int"""
        return _uhd_swig.usrp_sink_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_name(self)

    def symbol_name(self):
        """symbol_name(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(usrp_sink_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_sink_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(usrp_sink_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_sink_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(usrp_sink_sptr self) -> long"""
        return _uhd_swig.usrp_sink_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(usrp_sink_sptr self) -> basic_block_sptr"""
        return _uhd_swig.usrp_sink_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(usrp_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _uhd_swig.usrp_sink_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(usrp_sink_sptr self, std::string name)"""
        return _uhd_swig.usrp_sink_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(usrp_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _uhd_swig.usrp_sink_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(usrp_sink_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(usrp_sink_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(usrp_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_subscribers(self, *args, **kwargs)

usrp_sink_sptr_swigregister = _uhd_swig.usrp_sink_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::uhd::amsg_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::uhd::amsg_source)> self) -> amsg_source_sptr
        __init__(boost::shared_ptr<(gr::uhd::amsg_source)> self, amsg_source p) -> amsg_source_sptr
        """
        this = _uhd_swig.new_amsg_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(amsg_source_sptr self) -> amsg_source"""
        return _uhd_swig.amsg_source_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_amsg_source_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """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, *args, **kwargs)

    def msg_to_async_metadata_t(self, *args, **kwargs):
        """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, *args, **kwargs)

amsg_source_sptr_swigregister = _uhd_swig.amsg_source_sptr_swigregister
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):
  """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():
  """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

