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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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



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

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

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

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _osmosdr_swig.high_res_timer_epoch()
class string_vector_t(object):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(string_vector_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_vector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t___bool__(self)

    def __len__(self) -> "std::vector< std::string >::size_type":
        r"""__len__(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t___len__(self)

    def __getslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "std::vector< std::string,std::allocator< std::string > > *":
        r"""__getslice__(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 _osmosdr_swig.string_vector_t___getslice__(self, i, j)

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

    def __delslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "void":
        r"""__delslice__(string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _osmosdr_swig.string_vector_t___delslice__(self, i, j)

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

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

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

    def pop(self) -> "std::vector< std::string >::value_type":
        r"""pop(string_vector_t self) -> std::vector< std::string >::value_type"""
        return _osmosdr_swig.string_vector_t_pop(self)

    def append(self, x: "std::vector< std::string >::value_type const &") -> "void":
        r"""append(string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t_empty(self)

    def size(self) -> "std::vector< std::string >::size_type":
        r"""size(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t_size(self)

    def swap(self, v: "std::vector< std::string > &") -> "void":
        r"""swap(string_vector_t self, std::vector< std::string > & v)"""
        return _osmosdr_swig.string_vector_t_swap(self, v)

    def begin(self) -> "std::vector< std::string >::iterator":
        r"""begin(string_vector_t self) -> std::vector< std::string >::iterator"""
        return _osmosdr_swig.string_vector_t_begin(self)

    def end(self) -> "std::vector< std::string >::iterator":
        r"""end(string_vector_t self) -> std::vector< std::string >::iterator"""
        return _osmosdr_swig.string_vector_t_end(self)

    def rbegin(self) -> "std::vector< std::string >::reverse_iterator":
        r"""rbegin(string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _osmosdr_swig.string_vector_t_rbegin(self)

    def rend(self) -> "std::vector< std::string >::reverse_iterator":
        r"""rend(string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _osmosdr_swig.string_vector_t_rend(self)

    def clear(self) -> "void":
        r"""clear(string_vector_t self)"""
        return _osmosdr_swig.string_vector_t_clear(self)

    def get_allocator(self) -> "std::vector< std::string >::allocator_type":
        r"""get_allocator(string_vector_t self) -> std::vector< std::string >::allocator_type"""
        return _osmosdr_swig.string_vector_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(string_vector_t self)"""
        return _osmosdr_swig.string_vector_t_pop_back(self)

    def erase(self, *args) -> "std::vector< std::string >::iterator":
        r"""
        erase(string_vector_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(string_vector_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _osmosdr_swig.string_vector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(string_vector_t self) -> string_vector_t
        __init__(string_vector_t self, std::vector< std::string > const & other) -> string_vector_t
        __init__(string_vector_t self, std::vector< std::string >::size_type size) -> string_vector_t
        __init__(string_vector_t self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> string_vector_t
        """
        _osmosdr_swig.string_vector_t_swiginit(self, _osmosdr_swig.new_string_vector_t(*args))

    def push_back(self, x: "std::vector< std::string >::value_type const &") -> "void":
        r"""push_back(string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_push_back(self, x)

    def front(self) -> "std::vector< std::string >::value_type const &":
        r"""front(string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _osmosdr_swig.string_vector_t_front(self)

    def back(self) -> "std::vector< std::string >::value_type const &":
        r"""back(string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _osmosdr_swig.string_vector_t_back(self)

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

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

    def insert(self, *args) -> "void":
        r"""
        insert(string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(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 _osmosdr_swig.string_vector_t_insert(self, *args)

    def reserve(self, n: "std::vector< std::string >::size_type") -> "void":
        r"""reserve(string_vector_t self, std::vector< std::string >::size_type n)"""
        return _osmosdr_swig.string_vector_t_reserve(self, n)

    def capacity(self) -> "std::vector< std::string >::size_type":
        r"""capacity(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t_capacity(self)
    __swig_destroy__ = _osmosdr_swig.delete_string_vector_t

# Register string_vector_t in _osmosdr_swig:
_osmosdr_swig.string_vector_t_swigregister(string_vector_t)

class string_string_dict_t(object):
    r"""
    Apply  element-wise to the elements of list and returns a list of the results, in order.

    must be a list. The dynamic order in which  is applied to the elements of  is unspecified.
    """

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

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t___bool__(self)

    def __len__(self) -> "std::map< std::string,std::string >::size_type":
        r"""__len__(string_string_dict_t self) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::mapped_type const &":
        r"""__getitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _osmosdr_swig.string_string_dict_t___getitem__(self, key)

    def __delitem__(self, key: "std::map< std::string,std::string >::key_type const &") -> "void":
        r"""__delitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key)"""
        return _osmosdr_swig.string_string_dict_t___delitem__(self, key)

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

    def keys(self) -> "PyObject *":
        r"""keys(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_keys(self)

    def values(self) -> "PyObject *":
        r"""values(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_values(self)

    def items(self) -> "PyObject *":
        r"""items(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_items(self)

    def __contains__(self, key: "std::map< std::string,std::string >::key_type const &") -> "bool":
        r"""__contains__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _osmosdr_swig.string_string_dict_t___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        r"""key_iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        r"""value_iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _osmosdr_swig.string_string_dict_t___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        r"""asdict(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(string_string_dict_t self, std::less< std::string > const & other) -> string_string_dict_t
        __init__(string_string_dict_t self) -> string_string_dict_t
        __init__(string_string_dict_t self, string_string_dict_t other) -> string_string_dict_t
        Apply  element-wise to the elements of list and returns a list of the results, in order.

        must be a list. The dynamic order in which  is applied to the elements of  is unspecified.
        """
        _osmosdr_swig.string_string_dict_t_swiginit(self, _osmosdr_swig.new_string_string_dict_t(*args))

    def empty(self) -> "bool":
        r"""empty(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t_empty(self)

    def size(self) -> "std::map< std::string,std::string >::size_type":
        r"""size(string_string_dict_t self) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t_size(self)

    def swap(self, v: "string_string_dict_t") -> "void":
        r"""swap(string_string_dict_t self, string_string_dict_t v)"""
        return _osmosdr_swig.string_string_dict_t_swap(self, v)

    def begin(self) -> "std::map< std::string,std::string >::iterator":
        r"""begin(string_string_dict_t self) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_begin(self)

    def end(self) -> "std::map< std::string,std::string >::iterator":
        r"""end(string_string_dict_t self) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_end(self)

    def rbegin(self) -> "std::map< std::string,std::string >::reverse_iterator":
        r"""rbegin(string_string_dict_t self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _osmosdr_swig.string_string_dict_t_rbegin(self)

    def rend(self) -> "std::map< std::string,std::string >::reverse_iterator":
        r"""rend(string_string_dict_t self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _osmosdr_swig.string_string_dict_t_rend(self)

    def clear(self) -> "void":
        r"""clear(string_string_dict_t self)"""
        return _osmosdr_swig.string_string_dict_t_clear(self)

    def get_allocator(self) -> "std::map< std::string,std::string >::allocator_type":
        r"""get_allocator(string_string_dict_t self) -> std::map< std::string,std::string >::allocator_type"""
        return _osmosdr_swig.string_string_dict_t_get_allocator(self)

    def count(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::size_type":
        r"""count(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t_count(self, x)

    def erase(self, *args) -> "void":
        r"""
        erase(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(string_string_dict_t self, std::map< std::string,std::string >::iterator position)
        erase(string_string_dict_t self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _osmosdr_swig.string_string_dict_t_erase(self, *args)

    def find(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::iterator":
        r"""find(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_find(self, x)

    def lower_bound(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::iterator":
        r"""lower_bound(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_lower_bound(self, x)

    def upper_bound(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::iterator":
        r"""upper_bound(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_upper_bound(self, x)
    __swig_destroy__ = _osmosdr_swig.delete_string_string_dict_t

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

class devices_t(object):
    r"""Proxy of C++ std::vector< osmosdr::device_t > class."""

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

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(devices_t self) -> SwigPyIterator"""
        return _osmosdr_swig.devices_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t___bool__(self)

    def __len__(self) -> "std::vector< osmosdr::device_t >::size_type":
        r"""__len__(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t___len__(self)

    def __getslice__(self, i: "std::vector< osmosdr::device_t >::difference_type", j: "std::vector< osmosdr::device_t >::difference_type") -> "std::vector< osmosdr::device_t,std::allocator< osmosdr::device_t > > *":
        r"""__getslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j) -> devices_t"""
        return _osmosdr_swig.devices_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j)
        __setslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j, devices_t v)
        """
        return _osmosdr_swig.devices_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< osmosdr::device_t >::difference_type", j: "std::vector< osmosdr::device_t >::difference_type") -> "void":
        r"""__delslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j)"""
        return _osmosdr_swig.devices_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i)
        __delitem__(devices_t self, PySliceObject * slice)
        """
        return _osmosdr_swig.devices_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< osmosdr::device_t >::value_type const &":
        r"""
        __getitem__(devices_t self, PySliceObject * slice) -> devices_t
        __getitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i) -> device_t
        """
        return _osmosdr_swig.devices_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(devices_t self, PySliceObject * slice, devices_t v)
        __setitem__(devices_t self, PySliceObject * slice)
        __setitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, device_t x)
        """
        return _osmosdr_swig.devices_t___setitem__(self, *args)

    def pop(self) -> "std::vector< osmosdr::device_t >::value_type":
        r"""pop(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_pop(self)

    def append(self, x: "device_t") -> "void":
        r"""append(devices_t self, device_t x)"""
        return _osmosdr_swig.devices_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t_empty(self)

    def size(self) -> "std::vector< osmosdr::device_t >::size_type":
        r"""size(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t_size(self)

    def swap(self, v: "devices_t") -> "void":
        r"""swap(devices_t self, devices_t v)"""
        return _osmosdr_swig.devices_t_swap(self, v)

    def begin(self) -> "std::vector< osmosdr::device_t >::iterator":
        r"""begin(devices_t self) -> std::vector< osmosdr::device_t >::iterator"""
        return _osmosdr_swig.devices_t_begin(self)

    def end(self) -> "std::vector< osmosdr::device_t >::iterator":
        r"""end(devices_t self) -> std::vector< osmosdr::device_t >::iterator"""
        return _osmosdr_swig.devices_t_end(self)

    def rbegin(self) -> "std::vector< osmosdr::device_t >::reverse_iterator":
        r"""rbegin(devices_t self) -> std::vector< osmosdr::device_t >::reverse_iterator"""
        return _osmosdr_swig.devices_t_rbegin(self)

    def rend(self) -> "std::vector< osmosdr::device_t >::reverse_iterator":
        r"""rend(devices_t self) -> std::vector< osmosdr::device_t >::reverse_iterator"""
        return _osmosdr_swig.devices_t_rend(self)

    def clear(self) -> "void":
        r"""clear(devices_t self)"""
        return _osmosdr_swig.devices_t_clear(self)

    def get_allocator(self) -> "std::vector< osmosdr::device_t >::allocator_type":
        r"""get_allocator(devices_t self) -> std::vector< osmosdr::device_t >::allocator_type"""
        return _osmosdr_swig.devices_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(devices_t self)"""
        return _osmosdr_swig.devices_t_pop_back(self)

    def erase(self, *args) -> "std::vector< osmosdr::device_t >::iterator":
        r"""
        erase(devices_t self, std::vector< osmosdr::device_t >::iterator pos) -> std::vector< osmosdr::device_t >::iterator
        erase(devices_t self, std::vector< osmosdr::device_t >::iterator first, std::vector< osmosdr::device_t >::iterator last) -> std::vector< osmosdr::device_t >::iterator
        """
        return _osmosdr_swig.devices_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(devices_t self) -> devices_t
        __init__(devices_t self, devices_t other) -> devices_t
        __init__(devices_t self, std::vector< osmosdr::device_t >::size_type size) -> devices_t
        __init__(devices_t self, std::vector< osmosdr::device_t >::size_type size, device_t value) -> devices_t
        """
        _osmosdr_swig.devices_t_swiginit(self, _osmosdr_swig.new_devices_t(*args))

    def push_back(self, x: "device_t") -> "void":
        r"""push_back(devices_t self, device_t x)"""
        return _osmosdr_swig.devices_t_push_back(self, x)

    def front(self) -> "std::vector< osmosdr::device_t >::value_type const &":
        r"""front(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_front(self)

    def back(self) -> "std::vector< osmosdr::device_t >::value_type const &":
        r"""back(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_back(self)

    def assign(self, n: "std::vector< osmosdr::device_t >::size_type", x: "device_t") -> "void":
        r"""assign(devices_t self, std::vector< osmosdr::device_t >::size_type n, device_t x)"""
        return _osmosdr_swig.devices_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(devices_t self, std::vector< osmosdr::device_t >::size_type new_size)
        resize(devices_t self, std::vector< osmosdr::device_t >::size_type new_size, device_t x)
        """
        return _osmosdr_swig.devices_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(devices_t self, std::vector< osmosdr::device_t >::iterator pos, device_t x) -> std::vector< osmosdr::device_t >::iterator
        insert(devices_t self, std::vector< osmosdr::device_t >::iterator pos, std::vector< osmosdr::device_t >::size_type n, device_t x)
        """
        return _osmosdr_swig.devices_t_insert(self, *args)

    def reserve(self, n: "std::vector< osmosdr::device_t >::size_type") -> "void":
        r"""reserve(devices_t self, std::vector< osmosdr::device_t >::size_type n)"""
        return _osmosdr_swig.devices_t_reserve(self, n)

    def capacity(self) -> "std::vector< osmosdr::device_t >::size_type":
        r"""capacity(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t_capacity(self)
    __swig_destroy__ = _osmosdr_swig.delete_devices_t

# Register devices_t in _osmosdr_swig:
_osmosdr_swig.devices_t_swigregister(devices_t)

class device_t(string_string_dict_t):
    r"""
    Mapping of key/value pairs for locating devices on the system. When left empty, the device discovery routines will search all available transports on the system (ethernet, usb...).


    The logical device can also be used to pass arguments into the transport layer control to set (for example) buffer sizes.


    An arguments string, is a way to represent a device address using a single string with delimiter characters.
    """

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

    def __init__(self, *args, **kwargs):
        r"""
        __init__(device_t self, std::string const & args="") -> device_t
        Create a logical device from an args string.
        """
        _osmosdr_swig.device_t_swiginit(self, _osmosdr_swig.new_device_t(*args, **kwargs))

    def to_pp_string(self) -> "std::string":
        r"""
        to_pp_string(device_t self) -> std::string
        Convert a logical device into a pretty print string.
        """
        return _osmosdr_swig.device_t_to_pp_string(self)

    def to_string(self) -> "std::string":
        r"""
        to_string(device_t self) -> std::string
        Convert the logical device into an args string. The args string contains delimiter symbols.
        """
        return _osmosdr_swig.device_t_to_string(self)
    __swig_destroy__ = _osmosdr_swig.delete_device_t

# Register device_t in _osmosdr_swig:
_osmosdr_swig.device_t_swigregister(device_t)

class device(object):
    r"""The device interface represents the underyling hardware. The api allows for discovery, configuration, and streaming."""

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

    @staticmethod
    def find(*args, **kwargs) -> "osmosdr::devices_t":
        r"""
        find(device_t hint=osmosdr::device_t()) -> devices_t
        Find logical radio devices attached to the host.

        The device hint should be used to narrow down the search to particular transport types and/or transport arguments.


        The device hint "nofake" switches off dummy devices created by "file" (and other) implementations.
        """
        return _osmosdr_swig.device_find(*args, **kwargs)

    def __init__(self):
        r"""__init__(device self) -> device"""
        _osmosdr_swig.device_swiginit(self, _osmosdr_swig.new_device())
    __swig_destroy__ = _osmosdr_swig.delete_device

# Register device in _osmosdr_swig:
_osmosdr_swig.device_swigregister(device)

def device_find(*args, **kwargs) -> "osmosdr::devices_t":
    r"""
    device_find(device_t hint=osmosdr::device_t()) -> devices_t
    Find logical radio devices attached to the host.

    The device hint should be used to narrow down the search to particular transport types and/or transport arguments.


    The device hint "nofake" switches off dummy devices created by "file" (and other) implementations.
    """
    return _osmosdr_swig.device_find(*args, **kwargs)

class range_vector_t(object):
    r"""Proxy of C++ std::vector< osmosdr::range_t > class."""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class range_t(object):
    r"""A range object describes a set of discrete values of the form: y = start + step*n, where n is an integer between 0 and (stop - start)/step"""

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

    def __init__(self, *args):
        r"""
        __init__(range_t self, double value=0) -> range_t
        __init__(range_t self, double start, double stop, double step=0) -> range_t
        Create a range from a single value. The step size will be taken as zero.
        """
        _osmosdr_swig.range_t_swiginit(self, _osmosdr_swig.new_range_t(*args))

    def start(self) -> "double":
        r"""
        start(range_t self) -> double
        Get the start value for this range.
        """
        return _osmosdr_swig.range_t_start(self)

    def stop(self) -> "double":
        r"""
        stop(range_t self) -> double
        Get the stop value for this range.
        """
        return _osmosdr_swig.range_t_stop(self)

    def step(self) -> "double":
        r"""
        step(range_t self) -> double
        Get the step value for this range.
        """
        return _osmosdr_swig.range_t_step(self)

    def to_pp_string(self) -> "std::string const":
        r"""
        to_pp_string(range_t self) -> std::string const
        Convert this range to a printable string.
        """
        return _osmosdr_swig.range_t_to_pp_string(self)
    __swig_destroy__ = _osmosdr_swig.delete_range_t

# Register range_t in _osmosdr_swig:
_osmosdr_swig.range_t_swigregister(range_t)
cvar = _osmosdr_swig.cvar
ALL_MBOARDS = cvar.ALL_MBOARDS
ALL_CHANS = cvar.ALL_CHANS

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

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

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

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

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

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

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

    def values(self) -> "std::vector< double,std::allocator< double > >":
        r"""values(meta_range_t self) -> pmt_vector_double"""
        return _osmosdr_swig.meta_range_t_values(self)

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

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

class time_spec_t(object):
    r"""
    A time_spec_t holds a seconds and a fractional seconds time value. Depending upon usage, the time_spec_t can represent absolute times, relative times, or time differences (between absolute times).


    The time_spec_t provides clock-domain independent time storage, but can convert fractional seconds to/from clock-domain specific units.


    The fractional seconds are stored as double precision floating point. This gives the fractional seconds enough precision to unambiguously specify a clock-tick/sample-count up to rates of several petahertz.
    """

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

    @staticmethod
    def get_system_time() -> "osmosdr::time_spec_t":
        r"""
        get_system_time() -> time_spec_t
        Get the system time in time_spec_t format. Uses the highest precision clock available.
        """
        return _osmosdr_swig.time_spec_t_get_system_time()

    def __init__(self, *args):
        r"""
        __init__(time_spec_t self, double secs=0) -> time_spec_t
        __init__(time_spec_t self, time_t full_secs, double frac_secs=0) -> time_spec_t
        __init__(time_spec_t self, time_t full_secs, long tick_count, double tick_rate) -> time_spec_t
        Create a time_spec_t from a real-valued seconds count.
        """
        _osmosdr_swig.time_spec_t_swiginit(self, _osmosdr_swig.new_time_spec_t(*args))

    @staticmethod
    def from_ticks(ticks: "long long", tick_rate: "double") -> "osmosdr::time_spec_t":
        r"""
        from_ticks(long long ticks, double tick_rate) -> time_spec_t
        Create a time_spec_t from a 64-bit tick count. Translation from clock-domain specific units.
        """
        return _osmosdr_swig.time_spec_t_from_ticks(ticks, tick_rate)

    def get_tick_count(self, tick_rate: "double") -> "long":
        r"""
        get_tick_count(time_spec_t self, double tick_rate) -> long
        Convert the fractional seconds to clock ticks. Translation into clock-domain specific units.
        """
        return _osmosdr_swig.time_spec_t_get_tick_count(self, tick_rate)

    def to_ticks(self, tick_rate: "double const") -> "long long":
        r"""
        to_ticks(time_spec_t self, double const tick_rate) -> long long
        Convert the time spec into a 64-bit tick count. Translation into clock-domain specific units.
        """
        return _osmosdr_swig.time_spec_t_to_ticks(self, tick_rate)

    def get_real_secs(self) -> "double":
        r"""
        get_real_secs(time_spec_t self) -> double
        Get the time as a real-valued seconds count. Note: If this time_spec_t represents an absolute time, the precision of the fractional seconds may be lost.
        """
        return _osmosdr_swig.time_spec_t_get_real_secs(self)

    def get_full_secs(self) -> "time_t":
        r"""
        get_full_secs(time_spec_t self) -> time_t
        Get the whole/integer part of the time in seconds.
        """
        return _osmosdr_swig.time_spec_t_get_full_secs(self)

    def get_frac_secs(self) -> "double":
        r"""
        get_frac_secs(time_spec_t self) -> double
        Get the fractional part of the time in seconds.
        """
        return _osmosdr_swig.time_spec_t_get_frac_secs(self)

    def __iadd__(self, arg2: "time_spec_t") -> "osmosdr::time_spec_t &":
        r"""
        __iadd__(time_spec_t self, time_spec_t arg2) -> time_spec_t
        Implement addable interface.
        """
        return _osmosdr_swig.time_spec_t___iadd__(self, arg2)

    def __isub__(self, arg2: "time_spec_t") -> "osmosdr::time_spec_t &":
        r"""
        __isub__(time_spec_t self, time_spec_t arg2) -> time_spec_t
        Implement subtractable interface.
        """
        return _osmosdr_swig.time_spec_t___isub__(self, arg2)

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

    def __sub__(self, what: "time_spec_t") -> "osmosdr::time_spec_t":
        r"""__sub__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _osmosdr_swig.time_spec_t___sub__(self, what)
    __swig_destroy__ = _osmosdr_swig.delete_time_spec_t

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

def time_spec_t_get_system_time() -> "osmosdr::time_spec_t":
    r"""
    time_spec_t_get_system_time() -> time_spec_t
    Get the system time in time_spec_t format. Uses the highest precision clock available.
    """
    return _osmosdr_swig.time_spec_t_get_system_time()

def time_spec_t_from_ticks(ticks: "long long", tick_rate: "double") -> "osmosdr::time_spec_t":
    r"""
    time_spec_t_from_ticks(long long ticks, double tick_rate) -> time_spec_t
    Create a time_spec_t from a 64-bit tick count. Translation from clock-domain specific units.
    """
    return _osmosdr_swig.time_spec_t_from_ticks(ticks, tick_rate)


def __eq__(arg1: "time_spec_t", arg2: "time_spec_t") -> "bool":
    r"""
    __eq__(time_spec_t arg1, time_spec_t arg2) -> bool
    Implement equality_comparable interface.
    """
    return _osmosdr_swig.__eq__(arg1, arg2)

def __lt__(arg1: "time_spec_t", arg2: "time_spec_t") -> "bool":
    r"""
    __lt__(time_spec_t arg1, time_spec_t arg2) -> bool
    Implement less_than_comparable interface.
    """
    return _osmosdr_swig.__lt__(arg1, arg2)
class source(object):
    r"""
    Provides a stream of complex samples.

    This uses the preferred technique: subclassing gr::hier_block2.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of source.

    To avoid accidental use of raw pointers, source's constructor is private. osmosdr::source::make is the public interface for creating new instances.

    Args:
        args : the address to identify the hardware
    """

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

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

    @staticmethod
    def make(*args, **kwargs) -> "osmosdr::source::sptr":
        r"""
        make(std::string const & args="") -> source_sptr
        Provides a stream of complex samples.

        This uses the preferred technique: subclassing gr::hier_block2.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of source.

        To avoid accidental use of raw pointers, source's constructor is private. osmosdr::source::make is the public interface for creating new instances.

        Args:
            args : the address to identify the hardware
        """
        return _osmosdr_swig.source_make(*args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""
        get_num_channels(source self) -> size_t
        Get the number of channels the underlying radio hardware offers.
        """
        return _osmosdr_swig.source_get_num_channels(self)

    def seek(self, seek_point: "long", whence: "int", chan: "size_t"=0) -> "bool":
        r"""
        seek(source self, long seek_point, int whence, size_t chan=0) -> bool
        seek file to  relative to
        """
        return _osmosdr_swig.source_seek(self, seek_point, whence, chan)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""
        get_sample_rates(source self) -> meta_range_t
        Get the possible sample rates for the underlying radio hardware.
        """
        return _osmosdr_swig.source_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""
        set_sample_rate(source self, double rate) -> double
        Set the sample rate for the underlying radio hardware. This also will select the appropriate IF bandpass, if applicable.
        """
        return _osmosdr_swig.source_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""
        get_sample_rate(source self) -> double
        Get the sample rate for the underlying radio hardware. This is the actual sample rate and may differ from the rate set.
        """
        return _osmosdr_swig.source_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_freq_range(source self, size_t chan=0) -> meta_range_t
        Get the tunable frequency range for the underlying radio hardware.
        """
        return _osmosdr_swig.source_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""
        set_center_freq(source self, double freq, size_t chan=0) -> double
        Tune the underlying radio hardware to the desired center frequency. This also will select the appropriate RF bandpass.
        """
        return _osmosdr_swig.source_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""
        get_center_freq(source self, size_t chan=0) -> double
        Get the center frequency the underlying radio hardware is tuned to. This is the actual frequency and may differ from the frequency set.
        """
        return _osmosdr_swig.source_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""
        set_freq_corr(source self, double ppm, size_t chan=0) -> double
        Set the frequency correction value in parts per million.
        """
        return _osmosdr_swig.source_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""
        get_freq_corr(source self, size_t chan=0) -> double
        Get the frequency correction value.
        """
        return _osmosdr_swig.source_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_gain_names(source self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the gain stage names of the underlying radio hardware.
        """
        return _osmosdr_swig.source_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(source self, size_t chan=0) -> meta_range_t
        get_gain_range(source self, std::string const & name, size_t chan=0) -> meta_range_t
        Get the settable overall gain range for the underlying radio hardware.
        """
        return _osmosdr_swig.source_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""
        set_gain_mode(source self, bool automatic, size_t chan=0) -> bool
        Set the gain mode for the underlying radio hardware. This might be supported only for certain hardware types.
        """
        return _osmosdr_swig.source_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""
        get_gain_mode(source self, size_t chan=0) -> bool
        Get the gain mode selected for the underlying radio hardware.
        """
        return _osmosdr_swig.source_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(source self, double gain, size_t chan=0) -> double
        set_gain(source self, double gain, std::string const & name, size_t chan=0) -> double
        Set the gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.source_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(source self, size_t chan=0) -> double
        get_gain(source self, std::string const & name, size_t chan=0) -> double
        Get the actual gain setting of the underlying radio hardware.
        """
        return _osmosdr_swig.source_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_if_gain(source self, double gain, size_t chan=0) -> double
        Set the IF gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available IF gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.source_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bb_gain(source self, double gain, size_t chan=0) -> double
        Set the BB gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available BB gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.source_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_antennas(source self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the available antennas of the underlying radio hardware.
        """
        return _osmosdr_swig.source_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""
        set_antenna(source self, std::string const & antenna, size_t chan=0) -> std::string
        Select the active antenna of the underlying radio hardware.
        """
        return _osmosdr_swig.source_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""
        get_antenna(source self, size_t chan=0) -> std::string
        Get the actual underlying radio hardware antenna setting.
        """
        return _osmosdr_swig.source_get_antenna(self, chan)
    DCOffsetOff = _osmosdr_swig.source_DCOffsetOff
    
    DCOffsetManual = _osmosdr_swig.source_DCOffsetManual
    
    DCOffsetAutomatic = _osmosdr_swig.source_DCOffsetAutomatic
    

    def set_dc_offset_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""
        set_dc_offset_mode(source self, int mode, size_t chan=0)
        Set the RX frontend DC correction mode. The automatic correction subtracts out the long-run average.


        When disabled, the averaging option operation is reset. Once in Manual mode, the average value will be held constant until the user re-enables the automatic correction or overrides the value by manually setting the offset.
        """
        return _osmosdr_swig.source_set_dc_offset_mode(self, mode, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_dc_offset(source self, std::complex< double > const & offset, size_t chan=0)
        Set the RX frontend DC offset value. The value is complex to control both I and Q. Only set this when automatic correction is disabled.
        """
        return _osmosdr_swig.source_set_dc_offset(self, offset, chan)
    IQBalanceOff = _osmosdr_swig.source_IQBalanceOff
    
    IQBalanceManual = _osmosdr_swig.source_IQBalanceManual
    
    IQBalanceAutomatic = _osmosdr_swig.source_IQBalanceAutomatic
    

    def set_iq_balance_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""
        set_iq_balance_mode(source self, int mode, size_t chan=0)
        Set the RX frontend IQ balance mode.
        """
        return _osmosdr_swig.source_set_iq_balance_mode(self, mode, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_iq_balance(source self, std::complex< double > const & balance, size_t chan=0)
        Set the RX frontend IQ balance correction. Use this to adjust the magnitude and phase of I and Q.
        """
        return _osmosdr_swig.source_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bandwidth(source self, double bandwidth, size_t chan=0) -> double
        Set the bandpass filter on the radio frontend.
        """
        return _osmosdr_swig.source_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""
        get_bandwidth(source self, size_t chan=0) -> double
        Get the actual bandpass filter setting on the radio frontend.
        """
        return _osmosdr_swig.source_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_bandwidth_range(source self, size_t chan=0) -> meta_range_t
        Get the possible bandpass filter settings on the radio frontend.
        """
        return _osmosdr_swig.source_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_time_source(source self, std::string const & source, size_t const mboard=0)
        Set the time source for the device. This sets the method of time synchronization, typically a pulse per second or an encoded time. Typical options for source: external, MIMO.
        """
        return _osmosdr_swig.source_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_time_source(source self, size_t const mboard) -> std::string
        Get the currently set time source.
        """
        return _osmosdr_swig.source_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_time_sources(source self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible time sources.
        """
        return _osmosdr_swig.source_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_clock_source(source self, std::string const & source, size_t const mboard=0)
        Set the clock source for the device. This sets the source for a 10 Mhz reference clock. Typical options for source: internal, external, MIMO.
        """
        return _osmosdr_swig.source_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_clock_source(source self, size_t const mboard) -> std::string
        Get the currently set clock source.
        """
        return _osmosdr_swig.source_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_clock_sources(source self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible clock sources.
        """
        return _osmosdr_swig.source_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""
        get_clock_rate(source self, size_t mboard=0) -> double
        Get the master clock rate.
        """
        return _osmosdr_swig.source_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""
        set_clock_rate(source self, double rate, size_t mboard=0)
        Set the master clock rate.
        """
        return _osmosdr_swig.source_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_now(source self, size_t mboard=0) -> time_spec_t
        Get the current time registers.
        """
        return _osmosdr_swig.source_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_last_pps(source self, size_t mboard=0) -> time_spec_t
        Get the time when the last pps pulse occured.
        """
        return _osmosdr_swig.source_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""
        set_time_now(source self, time_spec_t time_spec, size_t mboard=0)
        Sets the time registers immediately.
        """
        return _osmosdr_swig.source_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_next_pps(source self, time_spec_t time_spec)
        Set the time registers at the next pps.
        """
        return _osmosdr_swig.source_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_unknown_pps(source self, time_spec_t time_spec)
        Sync the time registers with an unknown pps edge.
        """
        return _osmosdr_swig.source_set_time_unknown_pps(self, time_spec)
    __swig_destroy__ = _osmosdr_swig.delete_source

# Register source in _osmosdr_swig:
_osmosdr_swig.source_swigregister(source)

def source_make(*args, **kwargs) -> "osmosdr::source::sptr":
    r"""
    source_make(std::string const & args="") -> source_sptr
    Provides a stream of complex samples.

    This uses the preferred technique: subclassing gr::hier_block2.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of source.

    To avoid accidental use of raw pointers, source's constructor is private. osmosdr::source::make is the public interface for creating new instances.

    Args:
        args : the address to identify the hardware
    """
    return _osmosdr_swig.source_make(*args, **kwargs)

class sink(object):
    r"""
    Takes a stream of complex samples.

    This uses the preferred technique: subclassing gr::hier_block2.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of sink.

    To avoid accidental use of raw pointers, sink's constructor is private. osmosdr::sink::make is the public interface for creating new instances.

    Args:
        args : the address to identify the hardware
    """

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

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

    @staticmethod
    def make(*args, **kwargs) -> "osmosdr::sink::sptr":
        r"""
        make(std::string const & args="") -> sink_sptr
        Takes a stream of complex samples.

        This uses the preferred technique: subclassing gr::hier_block2.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of sink.

        To avoid accidental use of raw pointers, sink's constructor is private. osmosdr::sink::make is the public interface for creating new instances.

        Args:
            args : the address to identify the hardware
        """
        return _osmosdr_swig.sink_make(*args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""
        get_num_channels(sink self) -> size_t
        Get the number of channels the underlying radio hardware offers.
        """
        return _osmosdr_swig.sink_get_num_channels(self)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""
        get_sample_rates(sink self) -> meta_range_t
        Get the possible sample rates for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""
        set_sample_rate(sink self, double rate) -> double
        Set the sample rate for the underlying radio hardware. This also will select the appropriate IF bandpass, if applicable.
        """
        return _osmosdr_swig.sink_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""
        get_sample_rate(sink self) -> double
        Get the sample rate for the underlying radio hardware. This is the actual sample rate and may differ from the rate set.
        """
        return _osmosdr_swig.sink_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_freq_range(sink self, size_t chan=0) -> meta_range_t
        Get the tunable frequency range for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""
        set_center_freq(sink self, double freq, size_t chan=0) -> double
        Tune the underlying radio hardware to the desired center frequency. This also will select the appropriate RF bandpass.
        """
        return _osmosdr_swig.sink_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""
        get_center_freq(sink self, size_t chan=0) -> double
        Get the center frequency the underlying radio hardware is tuned to. This is the actual frequency and may differ from the frequency set.
        """
        return _osmosdr_swig.sink_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""
        set_freq_corr(sink self, double ppm, size_t chan=0) -> double
        Set the frequency correction value in parts per million.
        """
        return _osmosdr_swig.sink_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""
        get_freq_corr(sink self, size_t chan=0) -> double
        Get the frequency correction value.
        """
        return _osmosdr_swig.sink_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_gain_names(sink self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the gain stage names of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(sink self, size_t chan=0) -> meta_range_t
        get_gain_range(sink self, std::string const & name, size_t chan=0) -> meta_range_t
        Get the settable overall gain range for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""
        set_gain_mode(sink self, bool automatic, size_t chan=0) -> bool
        Set the gain mode for the underlying radio hardware. This might be supported only for certain hardware types.
        """
        return _osmosdr_swig.sink_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""
        get_gain_mode(sink self, size_t chan=0) -> bool
        Get the gain mode selected for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(sink self, double gain, size_t chan=0) -> double
        set_gain(sink self, double gain, std::string const & name, size_t chan=0) -> double
        Set the gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.sink_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(sink self, size_t chan=0) -> double
        get_gain(sink self, std::string const & name, size_t chan=0) -> double
        Get the actual gain setting of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_if_gain(sink self, double gain, size_t chan=0) -> double
        Set the IF gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available IF gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.sink_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bb_gain(sink self, double gain, size_t chan=0) -> double
        Set the BB gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available BB gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.sink_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_antennas(sink self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the available antennas of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""
        set_antenna(sink self, std::string const & antenna, size_t chan=0) -> std::string
        Select the active antenna of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""
        get_antenna(sink self, size_t chan=0) -> std::string
        Get the actual underlying radio hardware antenna setting.
        """
        return _osmosdr_swig.sink_get_antenna(self, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_dc_offset(sink self, std::complex< double > const & offset, size_t chan=0)
        Set the TX frontend DC offset value. The value is complex to control both I and Q.
        """
        return _osmosdr_swig.sink_set_dc_offset(self, offset, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_iq_balance(sink self, std::complex< double > const & balance, size_t chan=0)
        Set the TX frontend IQ balance correction. Use this to adjust the magnitude and phase of I and Q.
        """
        return _osmosdr_swig.sink_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bandwidth(sink self, double bandwidth, size_t chan=0) -> double
        Set the bandpass filter on the radio frontend.
        """
        return _osmosdr_swig.sink_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""
        get_bandwidth(sink self, size_t chan=0) -> double
        Get the actual bandpass filter setting on the radio frontend.
        """
        return _osmosdr_swig.sink_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_bandwidth_range(sink self, size_t chan=0) -> meta_range_t
        Get the possible bandpass filter settings on the radio frontend.
        """
        return _osmosdr_swig.sink_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_time_source(sink self, std::string const & source, size_t const mboard=0)
        Set the time source for the device. This sets the method of time synchronization, typically a pulse per second or an encoded time. Typical options for source: external, MIMO.
        """
        return _osmosdr_swig.sink_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_time_source(sink self, size_t const mboard) -> std::string
        Get the currently set time source.
        """
        return _osmosdr_swig.sink_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_time_sources(sink self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible time sources.
        """
        return _osmosdr_swig.sink_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_clock_source(sink self, std::string const & source, size_t const mboard=0)
        Set the clock source for the device. This sets the source for a 10 Mhz reference clock. Typical options for source: internal, external, MIMO.
        """
        return _osmosdr_swig.sink_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_clock_source(sink self, size_t const mboard) -> std::string
        Get the currently set clock source.
        """
        return _osmosdr_swig.sink_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_clock_sources(sink self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible clock sources.
        """
        return _osmosdr_swig.sink_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""
        get_clock_rate(sink self, size_t mboard=0) -> double
        Get the master clock rate.
        """
        return _osmosdr_swig.sink_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""
        set_clock_rate(sink self, double rate, size_t mboard=0)
        Set the master clock rate.
        """
        return _osmosdr_swig.sink_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_now(sink self, size_t mboard=0) -> time_spec_t
        Get the current time registers.
        """
        return _osmosdr_swig.sink_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_last_pps(sink self, size_t mboard=0) -> time_spec_t
        Get the time when the last pps pulse occured.
        """
        return _osmosdr_swig.sink_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""
        set_time_now(sink self, time_spec_t time_spec, size_t mboard=0)
        Sets the time registers immediately.
        """
        return _osmosdr_swig.sink_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_next_pps(sink self, time_spec_t time_spec)
        Set the time registers at the next pps.
        """
        return _osmosdr_swig.sink_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_unknown_pps(sink self, time_spec_t time_spec)
        Sync the time registers with an unknown pps edge.
        """
        return _osmosdr_swig.sink_set_time_unknown_pps(self, time_spec)
    __swig_destroy__ = _osmosdr_swig.delete_sink

# Register sink in _osmosdr_swig:
_osmosdr_swig.sink_swigregister(sink)

def sink_make(*args, **kwargs) -> "osmosdr::sink::sptr":
    r"""
    sink_make(std::string const & args="") -> sink_sptr
    Takes a stream of complex samples.

    This uses the preferred technique: subclassing gr::hier_block2.

    Constructor Specific Documentation:

    Return a shared_ptr to a new instance of sink.

    To avoid accidental use of raw pointers, sink's constructor is private. osmosdr::sink::make is the public interface for creating new instances.

    Args:
        args : the address to identify the hardware
    """
    return _osmosdr_swig.sink_make(*args, **kwargs)

class source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< osmosdr::source > class."""

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

    def __init__(self, *args):
        r"""
        __init__(source_sptr self) -> source_sptr
        __init__(source_sptr self, source p) -> source_sptr
        """
        _osmosdr_swig.source_sptr_swiginit(self, _osmosdr_swig.new_source_sptr(*args))

    def __deref__(self) -> "osmosdr::source *":
        r"""__deref__(source_sptr self) -> source"""
        return _osmosdr_swig.source_sptr___deref__(self)
    __swig_destroy__ = _osmosdr_swig.delete_source_sptr

    def make(self, *args, **kwargs) -> "osmosdr::source::sptr":
        r"""
        make(source_sptr self, std::string const & args="") -> source_sptr
        Provides a stream of complex samples.

        This uses the preferred technique: subclassing gr::hier_block2.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of source.

        To avoid accidental use of raw pointers, source's constructor is private. osmosdr::source::make is the public interface for creating new instances.

        Args:
            args : the address to identify the hardware
        """
        return _osmosdr_swig.source_sptr_make(self, *args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""
        get_num_channels(source_sptr self) -> size_t
        Get the number of channels the underlying radio hardware offers.
        """
        return _osmosdr_swig.source_sptr_get_num_channels(self)

    def seek(self, seek_point: "long", whence: "int", chan: "size_t"=0) -> "bool":
        r"""
        seek(source_sptr self, long seek_point, int whence, size_t chan=0) -> bool
        seek file to  relative to
        """
        return _osmosdr_swig.source_sptr_seek(self, seek_point, whence, chan)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""
        get_sample_rates(source_sptr self) -> meta_range_t
        Get the possible sample rates for the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""
        set_sample_rate(source_sptr self, double rate) -> double
        Set the sample rate for the underlying radio hardware. This also will select the appropriate IF bandpass, if applicable.
        """
        return _osmosdr_swig.source_sptr_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""
        get_sample_rate(source_sptr self) -> double
        Get the sample rate for the underlying radio hardware. This is the actual sample rate and may differ from the rate set.
        """
        return _osmosdr_swig.source_sptr_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_freq_range(source_sptr self, size_t chan=0) -> meta_range_t
        Get the tunable frequency range for the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""
        set_center_freq(source_sptr self, double freq, size_t chan=0) -> double
        Tune the underlying radio hardware to the desired center frequency. This also will select the appropriate RF bandpass.
        """
        return _osmosdr_swig.source_sptr_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""
        get_center_freq(source_sptr self, size_t chan=0) -> double
        Get the center frequency the underlying radio hardware is tuned to. This is the actual frequency and may differ from the frequency set.
        """
        return _osmosdr_swig.source_sptr_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""
        set_freq_corr(source_sptr self, double ppm, size_t chan=0) -> double
        Set the frequency correction value in parts per million.
        """
        return _osmosdr_swig.source_sptr_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""
        get_freq_corr(source_sptr self, size_t chan=0) -> double
        Get the frequency correction value.
        """
        return _osmosdr_swig.source_sptr_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_gain_names(source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the gain stage names of the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(source_sptr self, size_t chan=0) -> meta_range_t
        get_gain_range(source_sptr self, std::string const & name, size_t chan=0) -> meta_range_t
        Get the settable overall gain range for the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""
        set_gain_mode(source_sptr self, bool automatic, size_t chan=0) -> bool
        Set the gain mode for the underlying radio hardware. This might be supported only for certain hardware types.
        """
        return _osmosdr_swig.source_sptr_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""
        get_gain_mode(source_sptr self, size_t chan=0) -> bool
        Get the gain mode selected for the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(source_sptr self, double gain, size_t chan=0) -> double
        set_gain(source_sptr self, double gain, std::string const & name, size_t chan=0) -> double
        Set the gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.source_sptr_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(source_sptr self, size_t chan=0) -> double
        get_gain(source_sptr self, std::string const & name, size_t chan=0) -> double
        Get the actual gain setting of the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_if_gain(source_sptr self, double gain, size_t chan=0) -> double
        Set the IF gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available IF gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.source_sptr_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bb_gain(source_sptr self, double gain, size_t chan=0) -> double
        Set the BB gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available BB gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.source_sptr_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_antennas(source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the available antennas of the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""
        set_antenna(source_sptr self, std::string const & antenna, size_t chan=0) -> std::string
        Select the active antenna of the underlying radio hardware.
        """
        return _osmosdr_swig.source_sptr_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""
        get_antenna(source_sptr self, size_t chan=0) -> std::string
        Get the actual underlying radio hardware antenna setting.
        """
        return _osmosdr_swig.source_sptr_get_antenna(self, chan)

    def set_dc_offset_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""
        set_dc_offset_mode(source_sptr self, int mode, size_t chan=0)
        Set the RX frontend DC correction mode. The automatic correction subtracts out the long-run average.


        When disabled, the averaging option operation is reset. Once in Manual mode, the average value will be held constant until the user re-enables the automatic correction or overrides the value by manually setting the offset.
        """
        return _osmosdr_swig.source_sptr_set_dc_offset_mode(self, mode, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_dc_offset(source_sptr self, std::complex< double > const & offset, size_t chan=0)
        Set the RX frontend DC offset value. The value is complex to control both I and Q. Only set this when automatic correction is disabled.
        """
        return _osmosdr_swig.source_sptr_set_dc_offset(self, offset, chan)

    def set_iq_balance_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""
        set_iq_balance_mode(source_sptr self, int mode, size_t chan=0)
        Set the RX frontend IQ balance mode.
        """
        return _osmosdr_swig.source_sptr_set_iq_balance_mode(self, mode, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_iq_balance(source_sptr self, std::complex< double > const & balance, size_t chan=0)
        Set the RX frontend IQ balance correction. Use this to adjust the magnitude and phase of I and Q.
        """
        return _osmosdr_swig.source_sptr_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bandwidth(source_sptr self, double bandwidth, size_t chan=0) -> double
        Set the bandpass filter on the radio frontend.
        """
        return _osmosdr_swig.source_sptr_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""
        get_bandwidth(source_sptr self, size_t chan=0) -> double
        Get the actual bandpass filter setting on the radio frontend.
        """
        return _osmosdr_swig.source_sptr_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_bandwidth_range(source_sptr self, size_t chan=0) -> meta_range_t
        Get the possible bandpass filter settings on the radio frontend.
        """
        return _osmosdr_swig.source_sptr_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_time_source(source_sptr self, std::string const & source, size_t const mboard=0)
        Set the time source for the device. This sets the method of time synchronization, typically a pulse per second or an encoded time. Typical options for source: external, MIMO.
        """
        return _osmosdr_swig.source_sptr_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_time_source(source_sptr self, size_t const mboard) -> std::string
        Get the currently set time source.
        """
        return _osmosdr_swig.source_sptr_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_time_sources(source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible time sources.
        """
        return _osmosdr_swig.source_sptr_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_clock_source(source_sptr self, std::string const & source, size_t const mboard=0)
        Set the clock source for the device. This sets the source for a 10 Mhz reference clock. Typical options for source: internal, external, MIMO.
        """
        return _osmosdr_swig.source_sptr_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_clock_source(source_sptr self, size_t const mboard) -> std::string
        Get the currently set clock source.
        """
        return _osmosdr_swig.source_sptr_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_clock_sources(source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible clock sources.
        """
        return _osmosdr_swig.source_sptr_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""
        get_clock_rate(source_sptr self, size_t mboard=0) -> double
        Get the master clock rate.
        """
        return _osmosdr_swig.source_sptr_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""
        set_clock_rate(source_sptr self, double rate, size_t mboard=0)
        Set the master clock rate.
        """
        return _osmosdr_swig.source_sptr_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_now(source_sptr self, size_t mboard=0) -> time_spec_t
        Get the current time registers.
        """
        return _osmosdr_swig.source_sptr_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_last_pps(source_sptr self, size_t mboard=0) -> time_spec_t
        Get the time when the last pps pulse occured.
        """
        return _osmosdr_swig.source_sptr_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""
        set_time_now(source_sptr self, time_spec_t time_spec, size_t mboard=0)
        Sets the time registers immediately.
        """
        return _osmosdr_swig.source_sptr_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_next_pps(source_sptr self, time_spec_t time_spec)
        Set the time registers at the next pps.
        """
        return _osmosdr_swig.source_sptr_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_unknown_pps(source_sptr self, time_spec_t time_spec)
        Sync the time registers with an unknown pps edge.
        """
        return _osmosdr_swig.source_sptr_set_time_unknown_pps(self, time_spec)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(source_sptr self, basic_block_sptr block)
        primitive_connect(source_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.source_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(source_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(source_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.source_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(source_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(source_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.source_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(source_sptr self, basic_block_sptr block)
        primitive_disconnect(source_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.source_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(source_sptr self)"""
        return _osmosdr_swig.source_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(source_sptr self)"""
        return _osmosdr_swig.source_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(source_sptr self)"""
        return _osmosdr_swig.source_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(source_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.source_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(source_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.source_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _osmosdr_swig.source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(source_sptr self)"""
        return _osmosdr_swig.source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _osmosdr_swig.source_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(source_sptr self, std::string level)"""
        return _osmosdr_swig.source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(source_sptr self, int i) -> size_t"""
        return _osmosdr_swig.source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(source_sptr self, size_t max_output_buffer)
        set_max_output_buffer(source_sptr self, int port, size_t max_output_buffer)
        """
        return _osmosdr_swig.source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(source_sptr self, int i) -> size_t"""
        return _osmosdr_swig.source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(source_sptr self, size_t min_output_buffer)
        set_min_output_buffer(source_sptr self, int port, size_t min_output_buffer)
        """
        return _osmosdr_swig.source_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(source_sptr self) -> hier_block2_sptr"""
        return _osmosdr_swig.source_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(source_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(source_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(source_sptr self) -> long"""
        return _osmosdr_swig.source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(source_sptr self) -> basic_block_sptr"""
        return _osmosdr_swig.source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(source_sptr self, int ninputs, int noutputs) -> bool"""
        return _osmosdr_swig.source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(source_sptr self, std::string name)"""
        return _osmosdr_swig.source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _osmosdr_swig.source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(source_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(source_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _osmosdr_swig.source_sptr_message_subscribers(self, which_port)

# Register source_sptr in _osmosdr_swig:
_osmosdr_swig.source_sptr_swigregister(source_sptr)


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

class sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< osmosdr::sink > class."""

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

    def __init__(self, *args):
        r"""
        __init__(sink_sptr self) -> sink_sptr
        __init__(sink_sptr self, sink p) -> sink_sptr
        """
        _osmosdr_swig.sink_sptr_swiginit(self, _osmosdr_swig.new_sink_sptr(*args))

    def __deref__(self) -> "osmosdr::sink *":
        r"""__deref__(sink_sptr self) -> sink"""
        return _osmosdr_swig.sink_sptr___deref__(self)
    __swig_destroy__ = _osmosdr_swig.delete_sink_sptr

    def make(self, *args, **kwargs) -> "osmosdr::sink::sptr":
        r"""
        make(sink_sptr self, std::string const & args="") -> sink_sptr
        Takes a stream of complex samples.

        This uses the preferred technique: subclassing gr::hier_block2.

        Constructor Specific Documentation:

        Return a shared_ptr to a new instance of sink.

        To avoid accidental use of raw pointers, sink's constructor is private. osmosdr::sink::make is the public interface for creating new instances.

        Args:
            args : the address to identify the hardware
        """
        return _osmosdr_swig.sink_sptr_make(self, *args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""
        get_num_channels(sink_sptr self) -> size_t
        Get the number of channels the underlying radio hardware offers.
        """
        return _osmosdr_swig.sink_sptr_get_num_channels(self)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""
        get_sample_rates(sink_sptr self) -> meta_range_t
        Get the possible sample rates for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""
        set_sample_rate(sink_sptr self, double rate) -> double
        Set the sample rate for the underlying radio hardware. This also will select the appropriate IF bandpass, if applicable.
        """
        return _osmosdr_swig.sink_sptr_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""
        get_sample_rate(sink_sptr self) -> double
        Get the sample rate for the underlying radio hardware. This is the actual sample rate and may differ from the rate set.
        """
        return _osmosdr_swig.sink_sptr_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_freq_range(sink_sptr self, size_t chan=0) -> meta_range_t
        Get the tunable frequency range for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""
        set_center_freq(sink_sptr self, double freq, size_t chan=0) -> double
        Tune the underlying radio hardware to the desired center frequency. This also will select the appropriate RF bandpass.
        """
        return _osmosdr_swig.sink_sptr_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""
        get_center_freq(sink_sptr self, size_t chan=0) -> double
        Get the center frequency the underlying radio hardware is tuned to. This is the actual frequency and may differ from the frequency set.
        """
        return _osmosdr_swig.sink_sptr_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""
        set_freq_corr(sink_sptr self, double ppm, size_t chan=0) -> double
        Set the frequency correction value in parts per million.
        """
        return _osmosdr_swig.sink_sptr_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""
        get_freq_corr(sink_sptr self, size_t chan=0) -> double
        Get the frequency correction value.
        """
        return _osmosdr_swig.sink_sptr_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_gain_names(sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the gain stage names of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(sink_sptr self, size_t chan=0) -> meta_range_t
        get_gain_range(sink_sptr self, std::string const & name, size_t chan=0) -> meta_range_t
        Get the settable overall gain range for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""
        set_gain_mode(sink_sptr self, bool automatic, size_t chan=0) -> bool
        Set the gain mode for the underlying radio hardware. This might be supported only for certain hardware types.
        """
        return _osmosdr_swig.sink_sptr_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""
        get_gain_mode(sink_sptr self, size_t chan=0) -> bool
        Get the gain mode selected for the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(sink_sptr self, double gain, size_t chan=0) -> double
        set_gain(sink_sptr self, double gain, std::string const & name, size_t chan=0) -> double
        Set the gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.sink_sptr_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(sink_sptr self, size_t chan=0) -> double
        get_gain(sink_sptr self, std::string const & name, size_t chan=0) -> double
        Get the actual gain setting of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_if_gain(sink_sptr self, double gain, size_t chan=0) -> double
        Set the IF gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available IF gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.sink_sptr_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bb_gain(sink_sptr self, double gain, size_t chan=0) -> double
        Set the BB gain for the underlying radio hardware. This function will automatically distribute the desired gain value over available BB gain stages in an appropriate way and return the actual value.
        """
        return _osmosdr_swig.sink_sptr_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_antennas(sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >
        Get the available antennas of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""
        set_antenna(sink_sptr self, std::string const & antenna, size_t chan=0) -> std::string
        Select the active antenna of the underlying radio hardware.
        """
        return _osmosdr_swig.sink_sptr_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""
        get_antenna(sink_sptr self, size_t chan=0) -> std::string
        Get the actual underlying radio hardware antenna setting.
        """
        return _osmosdr_swig.sink_sptr_get_antenna(self, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_dc_offset(sink_sptr self, std::complex< double > const & offset, size_t chan=0)
        Set the TX frontend DC offset value. The value is complex to control both I and Q.
        """
        return _osmosdr_swig.sink_sptr_set_dc_offset(self, offset, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""
        set_iq_balance(sink_sptr self, std::complex< double > const & balance, size_t chan=0)
        Set the TX frontend IQ balance correction. Use this to adjust the magnitude and phase of I and Q.
        """
        return _osmosdr_swig.sink_sptr_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""
        set_bandwidth(sink_sptr self, double bandwidth, size_t chan=0) -> double
        Set the bandpass filter on the radio frontend.
        """
        return _osmosdr_swig.sink_sptr_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""
        get_bandwidth(sink_sptr self, size_t chan=0) -> double
        Get the actual bandpass filter setting on the radio frontend.
        """
        return _osmosdr_swig.sink_sptr_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""
        get_bandwidth_range(sink_sptr self, size_t chan=0) -> meta_range_t
        Get the possible bandpass filter settings on the radio frontend.
        """
        return _osmosdr_swig.sink_sptr_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_time_source(sink_sptr self, std::string const & source, size_t const mboard=0)
        Set the time source for the device. This sets the method of time synchronization, typically a pulse per second or an encoded time. Typical options for source: external, MIMO.
        """
        return _osmosdr_swig.sink_sptr_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_time_source(sink_sptr self, size_t const mboard) -> std::string
        Get the currently set time source.
        """
        return _osmosdr_swig.sink_sptr_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_time_sources(sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible time sources.
        """
        return _osmosdr_swig.sink_sptr_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""
        set_clock_source(sink_sptr self, std::string const & source, size_t const mboard=0)
        Set the clock source for the device. This sets the source for a 10 Mhz reference clock. Typical options for source: internal, external, MIMO.
        """
        return _osmosdr_swig.sink_sptr_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""
        get_clock_source(sink_sptr self, size_t const mboard) -> std::string
        Get the currently set clock source.
        """
        return _osmosdr_swig.sink_sptr_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""
        get_clock_sources(sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >
        Get a list of possible clock sources.
        """
        return _osmosdr_swig.sink_sptr_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""
        get_clock_rate(sink_sptr self, size_t mboard=0) -> double
        Get the master clock rate.
        """
        return _osmosdr_swig.sink_sptr_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""
        set_clock_rate(sink_sptr self, double rate, size_t mboard=0)
        Set the master clock rate.
        """
        return _osmosdr_swig.sink_sptr_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_now(sink_sptr self, size_t mboard=0) -> time_spec_t
        Get the current time registers.
        """
        return _osmosdr_swig.sink_sptr_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""
        get_time_last_pps(sink_sptr self, size_t mboard=0) -> time_spec_t
        Get the time when the last pps pulse occured.
        """
        return _osmosdr_swig.sink_sptr_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""
        set_time_now(sink_sptr self, time_spec_t time_spec, size_t mboard=0)
        Sets the time registers immediately.
        """
        return _osmosdr_swig.sink_sptr_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_next_pps(sink_sptr self, time_spec_t time_spec)
        Set the time registers at the next pps.
        """
        return _osmosdr_swig.sink_sptr_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""
        set_time_unknown_pps(sink_sptr self, time_spec_t time_spec)
        Sync the time registers with an unknown pps edge.
        """
        return _osmosdr_swig.sink_sptr_set_time_unknown_pps(self, time_spec)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(sink_sptr self, basic_block_sptr block)
        primitive_connect(sink_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.sink_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(sink_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(sink_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.sink_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(sink_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(sink_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.sink_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(sink_sptr self, basic_block_sptr block)
        primitive_disconnect(sink_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.sink_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(sink_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.sink_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(sink_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.sink_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _osmosdr_swig.sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _osmosdr_swig.sink_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sink_sptr self, std::string level)"""
        return _osmosdr_swig.sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(sink_sptr self, int i) -> size_t"""
        return _osmosdr_swig.sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(sink_sptr self, size_t max_output_buffer)
        set_max_output_buffer(sink_sptr self, int port, size_t max_output_buffer)
        """
        return _osmosdr_swig.sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(sink_sptr self, int i) -> size_t"""
        return _osmosdr_swig.sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(sink_sptr self, size_t min_output_buffer)
        set_min_output_buffer(sink_sptr self, int port, size_t min_output_buffer)
        """
        return _osmosdr_swig.sink_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(sink_sptr self) -> hier_block2_sptr"""
        return _osmosdr_swig.sink_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sink_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sink_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sink_sptr self) -> long"""
        return _osmosdr_swig.sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(sink_sptr self) -> basic_block_sptr"""
        return _osmosdr_swig.sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _osmosdr_swig.sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(sink_sptr self, std::string name)"""
        return _osmosdr_swig.sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _osmosdr_swig.sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sink_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sink_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _osmosdr_swig.sink_sptr_message_subscribers(self, which_port)

# Register sink_sptr in _osmosdr_swig:
_osmosdr_swig.sink_sptr_swigregister(sink_sptr)


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



