# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.

import _gnuradio_swig_py_runtime
import new
new_instancemethod = new.instancemethod
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class PySwigIterator(object):
    """Proxy of C++ PySwigIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args):
        """value(self) -> PyObject"""
        return _gnuradio_swig_py_runtime.PySwigIterator_value(*args)

    def incr(*args):
        """
        incr(self, size_t n=1) -> PySwigIterator
        incr(self) -> PySwigIterator
        """
        return _gnuradio_swig_py_runtime.PySwigIterator_incr(*args)

    def decr(*args):
        """
        decr(self, size_t n=1) -> PySwigIterator
        decr(self) -> PySwigIterator
        """
        return _gnuradio_swig_py_runtime.PySwigIterator_decr(*args)

    def distance(*args):
        """distance(self, PySwigIterator x) -> ptrdiff_t"""
        return _gnuradio_swig_py_runtime.PySwigIterator_distance(*args)

    def equal(*args):
        """equal(self, PySwigIterator x) -> bool"""
        return _gnuradio_swig_py_runtime.PySwigIterator_equal(*args)

    def copy(*args):
        """copy(self) -> PySwigIterator"""
        return _gnuradio_swig_py_runtime.PySwigIterator_copy(*args)

    def next(*args):
        """next(self) -> PyObject"""
        return _gnuradio_swig_py_runtime.PySwigIterator_next(*args)

    def previous(*args):
        """previous(self) -> PyObject"""
        return _gnuradio_swig_py_runtime.PySwigIterator_previous(*args)

    def advance(*args):
        """advance(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_py_runtime.PySwigIterator_advance(*args)

    def __eq__(*args):
        """__eq__(self, PySwigIterator x) -> bool"""
        return _gnuradio_swig_py_runtime.PySwigIterator___eq__(*args)

    def __ne__(*args):
        """__ne__(self, PySwigIterator x) -> bool"""
        return _gnuradio_swig_py_runtime.PySwigIterator___ne__(*args)

    def __iadd__(*args):
        """__iadd__(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_py_runtime.PySwigIterator___iadd__(*args)

    def __isub__(*args):
        """__isub__(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_py_runtime.PySwigIterator___isub__(*args)

    def __add__(*args):
        """__add__(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_py_runtime.PySwigIterator___add__(*args)

    def __sub__(*args):
        """
        __sub__(self, ptrdiff_t n) -> PySwigIterator
        __sub__(self, PySwigIterator x) -> ptrdiff_t
        """
        return _gnuradio_swig_py_runtime.PySwigIterator___sub__(*args)

    def __iter__(self): return self
PySwigIterator_swigregister = _gnuradio_swig_py_runtime.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

sizeof_char = _gnuradio_swig_py_runtime.sizeof_char
sizeof_short = _gnuradio_swig_py_runtime.sizeof_short
sizeof_int = _gnuradio_swig_py_runtime.sizeof_int
sizeof_float = _gnuradio_swig_py_runtime.sizeof_float
sizeof_double = _gnuradio_swig_py_runtime.sizeof_double
sizeof_gr_complex = _gnuradio_swig_py_runtime.sizeof_gr_complex
class gr_io_signature_sptr(object):
    """Proxy of C++ gr_io_signature_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_io_signature_sptr
        __init__(self, gr_io_signature p) -> gr_io_signature_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_io_signature_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_io_signature"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_io_signature_sptr
    __del__ = lambda self : None;
    def min_streams(*args):
        """min_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_min_streams(*args)

    def max_streams(*args):
        """max_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_max_streams(*args)

    def sizeof_stream_item(*args):
        """sizeof_stream_item(self, int index) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_sizeof_stream_item(*args)

    def sizeof_stream_items(*args):
        """sizeof_stream_items(self) -> __dummy_3__"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_sizeof_stream_items(*args)

gr_io_signature_sptr_swigregister = _gnuradio_swig_py_runtime.gr_io_signature_sptr_swigregister
gr_io_signature_sptr_swigregister(gr_io_signature_sptr)


def io_signature(*args):
  """io_signature(int min_streams, int max_streams, int sizeof_stream_item) -> gr_io_signature_sptr"""
  return _gnuradio_swig_py_runtime.io_signature(*args)

def io_signature2(*args):
  """
    io_signature2(int min_streams, int max_streams, int sizeof_stream_item1, 
        int sizeof_stream_item2) -> gr_io_signature_sptr
    """
  return _gnuradio_swig_py_runtime.io_signature2(*args)

def io_signature3(*args):
  """
    io_signature3(int min_streams, int max_streams, int sizeof_stream_item1, 
        int sizeof_stream_item2, int sizeof_stream_item3) -> gr_io_signature_sptr
    """
  return _gnuradio_swig_py_runtime.io_signature3(*args)

def io_signaturev(*args):
  """io_signaturev(int min_streams, int max_streams, __dummy_3__ sizeof_stream_items) -> gr_io_signature_sptr"""
  return _gnuradio_swig_py_runtime.io_signaturev(*args)
class gr_io_signature(object):
    """Proxy of C++ gr_io_signature class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_io_signature
    __del__ = lambda self : None;
    def min_streams(*args):
        """min_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_min_streams(*args)

    def max_streams(*args):
        """max_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_max_streams(*args)

    def sizeof_stream_item(*args):
        """sizeof_stream_item(self, int index) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sizeof_stream_item(*args)

    def sizeof_stream_items(*args):
        """sizeof_stream_items(self) -> __dummy_3__"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sizeof_stream_items(*args)

gr_io_signature_swigregister = _gnuradio_swig_py_runtime.gr_io_signature_swigregister
gr_io_signature_swigregister(gr_io_signature)

class gr_buffer_sptr(object):
    """Proxy of C++ gr_buffer_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_buffer_sptr
        __init__(self,  p) -> gr_buffer_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_buffer_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_buffer_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_buffer_sptr
    __del__ = lambda self : None;
gr_buffer_sptr_swigregister = _gnuradio_swig_py_runtime.gr_buffer_sptr_swigregister
gr_buffer_sptr_swigregister(gr_buffer_sptr)


def buffer(*args):
  """buffer(int nitems, size_t sizeof_item) -> gr_buffer_sptr"""
  return _gnuradio_swig_py_runtime.buffer(*args)
class gr_buffer_reader_sptr(object):
    """Proxy of C++ gr_buffer_reader_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_buffer_reader_sptr
        __init__(self,  p) -> gr_buffer_reader_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_buffer_reader_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_buffer_reader_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_buffer_reader_sptr
    __del__ = lambda self : None;
gr_buffer_reader_sptr_swigregister = _gnuradio_swig_py_runtime.gr_buffer_reader_sptr_swigregister
gr_buffer_reader_sptr_swigregister(gr_buffer_reader_sptr)


def buffer_add_reader(*args):
  """buffer_add_reader(gr_buffer_sptr buf, int nzero_preload) -> gr_buffer_reader_sptr"""
  return _gnuradio_swig_py_runtime.buffer_add_reader(*args)

def buffer_ncurrently_allocated(*args):
  """buffer_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.buffer_ncurrently_allocated(*args)

def buffer_reader_ncurrently_allocated(*args):
  """buffer_reader_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.buffer_reader_ncurrently_allocated(*args)
class gr_basic_block_sptr(object):
    """Proxy of C++ gr_basic_block_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_basic_block_sptr
        __init__(self, gr_basic_block p) -> gr_basic_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_basic_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_basic_block"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_basic_block_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_unique_id(*args)

    def basic_block(*args):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_basic_block(*args)

    def check_topology(*args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_check_topology(*args)

gr_basic_block_sptr_swigregister = _gnuradio_swig_py_runtime.gr_basic_block_sptr_swigregister
gr_basic_block_sptr_swigregister(gr_basic_block_sptr)

class x_vector_gr_basic_block_sptr(object):
    """Proxy of C++ x_vector_gr_basic_block_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___len__(*args)

    def pop(*args):
        """pop(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_pop(*args)

    def __getslice__(*args):
        """
        __getslice__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type j) -> x_vector_gr_basic_block_sptr
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___getslice__(*args)

    def __setslice__(*args):
        """
        __setslice__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type j, 
            x_vector_gr_basic_block_sptr v)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___setslice__(*args)

    def __delslice__(*args):
        """
        __delslice__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type j)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___getitem__(*args)

    def __setitem__(*args):
        """
        __setitem__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___setitem__(*args)

    def append(*args):
        """append(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_empty(*args)

    def size(*args):
        """size(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_size(*args)

    def clear(*args):
        """clear(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_clear(*args)

    def swap(*args):
        """swap(self, x_vector_gr_basic_block_sptr v)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::allocator_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_get_allocator(*args)

    def begin(*args):
        """begin(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_begin(*args)

    def end(*args):
        """end(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_end(*args)

    def rbegin(*args):
        """rbegin(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_rbegin(*args)

    def rend(*args):
        """rend(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_pop_back(*args)

    def erase(*args):
        """
        erase(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator pos) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator
        erase(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator first, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator last) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> x_vector_gr_basic_block_sptr
        __init__(self, x_vector_gr_basic_block_sptr ?) -> x_vector_gr_basic_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type size) -> x_vector_gr_basic_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type size, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type value) -> x_vector_gr_basic_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_x_vector_gr_basic_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_push_back(*args)

    def front(*args):
        """front(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_front(*args)

    def back(*args):
        """back(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_back(*args)

    def assign(*args):
        """
        assign(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_assign(*args)

    def resize(*args):
        """
        resize(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type new_size)
        resize(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type new_size, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_resize(*args)

    def insert(*args):
        """
        insert(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator
        insert(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_insert(*args)

    def reserve(*args):
        """reserve(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type n)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_reserve(*args)

    def capacity(*args):
        """capacity(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_capacity(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_x_vector_gr_basic_block_sptr
    __del__ = lambda self : None;
x_vector_gr_basic_block_sptr_swigregister = _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_swigregister
x_vector_gr_basic_block_sptr_swigregister(x_vector_gr_basic_block_sptr)

class gr_basic_block(object):
    """Proxy of C++ gr_basic_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_basic_block
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_basic_block_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_basic_block_unique_id(*args)

    def basic_block(*args):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_basic_block(*args)

    def check_topology(*args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_runtime.gr_basic_block_check_topology(*args)

gr_basic_block_swigregister = _gnuradio_swig_py_runtime.gr_basic_block_swigregister
gr_basic_block_swigregister(gr_basic_block)


def block_ncurrently_allocated(*args):
  """block_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.block_ncurrently_allocated(*args)
gr_basic_block_sptr.__repr__ = lambda self: "<gr_basic_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_block_sptr(object):
    """Proxy of C++ gr_block_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_block_sptr
        __init__(self, gr_block p) -> gr_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_block"""
        return _gnuradio_swig_py_runtime.gr_block_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_block_sptr
    __del__ = lambda self : None;
    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_relative_rate(*args)

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_set_detail(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_unique_id(*args)

    def basic_block(*args):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_basic_block(*args)

    def check_topology(*args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_check_topology(*args)

gr_block_sptr_swigregister = _gnuradio_swig_py_runtime.gr_block_sptr_swigregister
gr_block_sptr_swigregister(gr_block_sptr)

class x_vector_gr_block_sptr(object):
    """Proxy of C++ x_vector_gr_block_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___len__(*args)

    def pop(*args):
        """pop(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_pop(*args)

    def __getslice__(*args):
        """
        __getslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j) -> x_vector_gr_block_sptr
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___getslice__(*args)

    def __setslice__(*args):
        """
        __setslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j, 
            x_vector_gr_block_sptr v)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___setslice__(*args)

    def __delslice__(*args):
        """
        __delslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___getitem__(*args)

    def __setitem__(*args):
        """
        __setitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___setitem__(*args)

    def append(*args):
        """append(self, std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_empty(*args)

    def size(*args):
        """size(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_size(*args)

    def clear(*args):
        """clear(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_clear(*args)

    def swap(*args):
        """swap(self, x_vector_gr_block_sptr v)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::allocator_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_get_allocator(*args)

    def begin(*args):
        """begin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_begin(*args)

    def end(*args):
        """end(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_end(*args)

    def rbegin(*args):
        """rbegin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_rbegin(*args)

    def rend(*args):
        """rend(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_pop_back(*args)

    def erase(*args):
        """
        erase(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator pos) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        erase(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator first, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::iterator last) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> x_vector_gr_block_sptr
        __init__(self, x_vector_gr_block_sptr ?) -> x_vector_gr_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type size) -> x_vector_gr_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type size, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type value) -> x_vector_gr_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_x_vector_gr_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_push_back(*args)

    def front(*args):
        """front(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_front(*args)

    def back(*args):
        """back(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_back(*args)

    def assign(*args):
        """
        assign(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_assign(*args)

    def resize(*args):
        """
        resize(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type new_size)
        resize(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type new_size, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_resize(*args)

    def insert(*args):
        """
        insert(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        insert(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_insert(*args)

    def reserve(*args):
        """reserve(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_reserve(*args)

    def capacity(*args):
        """capacity(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_capacity(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_x_vector_gr_block_sptr
    __del__ = lambda self : None;
x_vector_gr_block_sptr_swigregister = _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_swigregister
x_vector_gr_block_sptr_swigregister(x_vector_gr_block_sptr)

class gr_block(gr_basic_block):
    """Proxy of C++ gr_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_block
    __del__ = lambda self : None;
    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_runtime.gr_block_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_block_relative_rate(*args)

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_runtime.gr_block_set_detail(*args)

gr_block_swigregister = _gnuradio_swig_py_runtime.gr_block_swigregister
gr_block_swigregister(gr_block)

gr_block_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())
gr_block_sptr.block = lambda self: self

class gr_block_detail_sptr(object):
    """Proxy of C++ gr_block_detail_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_block_detail_sptr
        __init__(self,  p) -> gr_block_detail_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_block_detail_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_block_detail_sptr
    __del__ = lambda self : None;
    def ninputs(*args):
        """ninputs(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_ninputs(*args)

    def noutputs(*args):
        """noutputs(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_noutputs(*args)

    def sink_p(*args):
        """sink_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_sink_p(*args)

    def source_p(*args):
        """source_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_source_p(*args)

    def set_input(*args):
        """set_input(self, unsigned int which, gr_buffer_reader_sptr reader)"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_set_input(*args)

    def input(*args):
        """input(self, unsigned int which) -> gr_buffer_reader_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_input(*args)

    def set_output(*args):
        """set_output(self, unsigned int which, gr_buffer_sptr buffer)"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_set_output(*args)

    def output(*args):
        """output(self, unsigned int which) -> gr_buffer_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_output(*args)

gr_block_detail_sptr_swigregister = _gnuradio_swig_py_runtime.gr_block_detail_sptr_swigregister
gr_block_detail_sptr_swigregister(gr_block_detail_sptr)


def block_detail(*args):
  """block_detail(unsigned int ninputs, unsigned int noutputs) -> gr_block_detail_sptr"""
  return _gnuradio_swig_py_runtime.block_detail(*args)

def block_detail_ncurrently_allocated(*args):
  """block_detail_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.block_detail_ncurrently_allocated(*args)
class gr_hier_block2_sptr(object):
    """Proxy of C++ gr_hier_block2_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_hier_block2_sptr
        __init__(self, gr_hier_block2 p) -> gr_hier_block2_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_hier_block2_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_hier_block2"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_hier_block2_sptr
    __del__ = lambda self : None;
    def connect(*args):
        """
        connect(self, gr_basic_block_sptr block)
        connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_connect(*args)

    def disconnect(*args):
        """
        disconnect(self, gr_basic_block_sptr block)
        disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_disconnect(*args)

    def disconnect_all(*args):
        """disconnect_all(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_disconnect_all(*args)

    def lock(*args):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_lock(*args)

    def unlock(*args):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_unlock(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_unique_id(*args)

    def basic_block(*args):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_basic_block(*args)

    def check_topology(*args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_check_topology(*args)

gr_hier_block2_sptr_swigregister = _gnuradio_swig_py_runtime.gr_hier_block2_sptr_swigregister
gr_hier_block2_sptr_swigregister(gr_hier_block2_sptr)


def hier_block2_swig(*args):
  """
    hier_block2_swig(string name, gr_io_signature_sptr input_signature, 
        gr_io_signature_sptr output_signature) -> gr_hier_block2_sptr
    """
  return _gnuradio_swig_py_runtime.hier_block2_swig(*args)
class gr_hier_block2(gr_basic_block):
    """Proxy of C++ gr_hier_block2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_hier_block2
    __del__ = lambda self : None;
    def connect(*args):
        """
        connect(self, gr_basic_block_sptr block)
        connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_connect(*args)

    def disconnect(*args):
        """
        disconnect(self, gr_basic_block_sptr block)
        disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_disconnect(*args)

    def disconnect_all(*args):
        """disconnect_all(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_disconnect_all(*args)

    def lock(*args):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_lock(*args)

    def unlock(*args):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_unlock(*args)

gr_hier_block2_swigregister = _gnuradio_swig_py_runtime.gr_hier_block2_swigregister
gr_hier_block2_swigregister(gr_hier_block2)

class gr_single_threaded_scheduler_sptr(object):
    """Proxy of C++ gr_single_threaded_scheduler_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_single_threaded_scheduler_sptr
        __init__(self,  p) -> gr_single_threaded_scheduler_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_single_threaded_scheduler_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_single_threaded_scheduler_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_single_threaded_scheduler_sptr
    __del__ = lambda self : None;
    def stop(*args):
        """stop(self)"""
        return _gnuradio_swig_py_runtime.gr_single_threaded_scheduler_sptr_stop(*args)

gr_single_threaded_scheduler_sptr_swigregister = _gnuradio_swig_py_runtime.gr_single_threaded_scheduler_sptr_swigregister
gr_single_threaded_scheduler_sptr_swigregister(gr_single_threaded_scheduler_sptr)


def single_threaded_scheduler(*args):
  """single_threaded_scheduler(x_vector_gr_block_sptr modules) -> gr_single_threaded_scheduler_sptr"""
  return _gnuradio_swig_py_runtime.single_threaded_scheduler(*args)

def sts_pyrun(*args):
  """sts_pyrun(gr_single_threaded_scheduler_sptr s)"""
  return _gnuradio_swig_py_runtime.sts_pyrun(*args)
class gr_message_sptr(object):
    """Proxy of C++ gr_message_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_message_sptr
        __init__(self, gr_message p) -> gr_message_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_message_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_message"""
        return _gnuradio_swig_py_runtime.gr_message_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_message_sptr
    __del__ = lambda self : None;
    def type(*args):
        """type(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_type(*args)

    def arg1(*args):
        """arg1(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_arg1(*args)

    def arg2(*args):
        """arg2(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_arg2(*args)

    def set_type(*args):
        """set_type(self, long type)"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_set_type(*args)

    def set_arg1(*args):
        """set_arg1(self, double arg1)"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_set_arg1(*args)

    def set_arg2(*args):
        """set_arg2(self, double arg2)"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_set_arg2(*args)

    def length(*args):
        """length(self) -> size_t"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_length(*args)

    def to_string(*args):
        """to_string(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_to_string(*args)

gr_message_sptr_swigregister = _gnuradio_swig_py_runtime.gr_message_sptr_swigregister
gr_message_sptr_swigregister(gr_message_sptr)

class gr_message(object):
    """Proxy of C++ gr_message class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_message
    __del__ = lambda self : None;
    def type(*args):
        """type(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_message_type(*args)

    def arg1(*args):
        """arg1(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_arg1(*args)

    def arg2(*args):
        """arg2(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_arg2(*args)

    def set_type(*args):
        """set_type(self, long type)"""
        return _gnuradio_swig_py_runtime.gr_message_set_type(*args)

    def set_arg1(*args):
        """set_arg1(self, double arg1)"""
        return _gnuradio_swig_py_runtime.gr_message_set_arg1(*args)

    def set_arg2(*args):
        """set_arg2(self, double arg2)"""
        return _gnuradio_swig_py_runtime.gr_message_set_arg2(*args)

    def length(*args):
        """length(self) -> size_t"""
        return _gnuradio_swig_py_runtime.gr_message_length(*args)

    def to_string(*args):
        """to_string(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_message_to_string(*args)

gr_message_swigregister = _gnuradio_swig_py_runtime.gr_message_swigregister
gr_message_swigregister(gr_message)

def message_from_string(*args):
  """
    message_from_string(string s, long type=0, double arg1=0, double arg2=0) -> gr_message_sptr
    message_from_string(string s, long type=0, double arg1=0) -> gr_message_sptr
    message_from_string(string s, long type=0) -> gr_message_sptr
    message_from_string(string s) -> gr_message_sptr
    """
  return _gnuradio_swig_py_runtime.message_from_string(*args)

def message(*args):
  """
    message(long type=0, double arg1=0, double arg2=0, size_t length=0) -> gr_message_sptr
    message(long type=0, double arg1=0, double arg2=0) -> gr_message_sptr
    message(long type=0, double arg1=0) -> gr_message_sptr
    message(long type=0) -> gr_message_sptr
    message() -> gr_message_sptr
    """
  return _gnuradio_swig_py_runtime.message(*args)


def message_ncurrently_allocated(*args):
  """message_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.message_ncurrently_allocated(*args)
class gr_msg_handler(object):
    """Proxy of C++ gr_msg_handler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_msg_handler
    __del__ = lambda self : None;
    def handle(*args):
        """handle(self, gr_message_sptr msg)"""
        return _gnuradio_swig_py_runtime.gr_msg_handler_handle(*args)

gr_msg_handler_swigregister = _gnuradio_swig_py_runtime.gr_msg_handler_swigregister
gr_msg_handler_swigregister(gr_msg_handler)

class gr_msg_queue_sptr(object):
    """Proxy of C++ gr_msg_queue_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_msg_queue_sptr
        __init__(self,  p) -> gr_msg_queue_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_msg_queue_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_msg_queue_sptr
    __del__ = lambda self : None;
    def delete_head_nowait(*args):
        """delete_head_nowait(self) -> gr_message_sptr"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_delete_head_nowait(*args)

    def empty_p(*args):
        """empty_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_empty_p(*args)

    def full_p(*args):
        """full_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_full_p(*args)

    def count(*args):
        """count(self) -> unsigned int"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_count(*args)

    def flush(*args):
        """flush(self)"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_flush(*args)

    def handle(*args):
        """handle(self, gr_message_sptr msg)"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_handle(*args)

gr_msg_queue_sptr_swigregister = _gnuradio_swig_py_runtime.gr_msg_queue_sptr_swigregister
gr_msg_queue_sptr_swigregister(gr_msg_queue_sptr)


def gr_py_msg_queue__delete_head(*args):
  """gr_py_msg_queue__delete_head(gr_msg_queue_sptr q) -> gr_message_sptr"""
  return _gnuradio_swig_py_runtime.gr_py_msg_queue__delete_head(*args)

def gr_py_msg_queue__insert_tail(*args):
  """gr_py_msg_queue__insert_tail(gr_msg_queue_sptr q, gr_message_sptr msg)"""
  return _gnuradio_swig_py_runtime.gr_py_msg_queue__insert_tail(*args)
gr_msg_queue_sptr.delete_head = gr_py_msg_queue__delete_head
gr_msg_queue_sptr.insert_tail = gr_py_msg_queue__insert_tail
gr_msg_queue_sptr.handle = gr_py_msg_queue__insert_tail

class gr_dispatcher_sptr(object):
    """Proxy of C++ gr_dispatcher_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_dispatcher_sptr
        __init__(self, gr_dispatcher p) -> gr_dispatcher_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_dispatcher_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_dispatcher"""
        return _gnuradio_swig_py_runtime.gr_dispatcher_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_dispatcher_sptr
    __del__ = lambda self : None;
    def loop(*args):
        """
        loop(self, double timeout=10)
        loop(self)
        """
        return _gnuradio_swig_py_runtime.gr_dispatcher_sptr_loop(*args)

gr_dispatcher_sptr_swigregister = _gnuradio_swig_py_runtime.gr_dispatcher_sptr_swigregister
gr_dispatcher_sptr_swigregister(gr_dispatcher_sptr)

def msg_queue(*args):
  """
    msg_queue(unsigned int limit=0) -> gr_msg_queue_sptr
    msg_queue() -> gr_msg_queue_sptr
    """
  return _gnuradio_swig_py_runtime.msg_queue(*args)


def dispatcher(*args):
  """dispatcher() -> gr_dispatcher_sptr"""
  return _gnuradio_swig_py_runtime.dispatcher(*args)

def dispatcher_singleton(*args):
  """dispatcher_singleton() -> gr_dispatcher_sptr"""
  return _gnuradio_swig_py_runtime.dispatcher_singleton(*args)
class gr_dispatcher(object):
    """Proxy of C++ gr_dispatcher class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_dispatcher
    __del__ = lambda self : None;
    def loop(*args):
        """
        loop(self, double timeout=10)
        loop(self)
        """
        return _gnuradio_swig_py_runtime.gr_dispatcher_loop(*args)

gr_dispatcher_swigregister = _gnuradio_swig_py_runtime.gr_dispatcher_swigregister
gr_dispatcher_swigregister(gr_dispatcher)

class error_handler(object):
    """Proxy of C++ error_handler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    ERR_DEBUG = _gnuradio_swig_py_runtime.error_handler_ERR_DEBUG
    ERR_MESSAGE = _gnuradio_swig_py_runtime.error_handler_ERR_MESSAGE
    ERR_WARNING = _gnuradio_swig_py_runtime.error_handler_ERR_WARNING
    ERR_ERROR = _gnuradio_swig_py_runtime.error_handler_ERR_ERROR
    ERR_FATAL = _gnuradio_swig_py_runtime.error_handler_ERR_FATAL
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_error_handler
    __del__ = lambda self : None;
    def default_handler(*args):
        """default_handler() -> error_handler"""
        return _gnuradio_swig_py_runtime.error_handler_default_handler(*args)

    default_handler = staticmethod(default_handler)
    def silent_handler(*args):
        """silent_handler() -> error_handler"""
        return _gnuradio_swig_py_runtime.error_handler_silent_handler(*args)

    silent_handler = staticmethod(silent_handler)
    def has_default_handler(*args):
        """has_default_handler() -> bool"""
        return _gnuradio_swig_py_runtime.error_handler_has_default_handler(*args)

    has_default_handler = staticmethod(has_default_handler)
    def set_default_handler(*args):
        """set_default_handler(error_handler errh)"""
        return _gnuradio_swig_py_runtime.error_handler_set_default_handler(*args)

    set_default_handler = staticmethod(set_default_handler)
    def nwarnings(*args):
        """nwarnings(self) -> int"""
        return _gnuradio_swig_py_runtime.error_handler_nwarnings(*args)

    def nerrors(*args):
        """nerrors(self) -> int"""
        return _gnuradio_swig_py_runtime.error_handler_nerrors(*args)

    def reset_counts(*args):
        """reset_counts(self)"""
        return _gnuradio_swig_py_runtime.error_handler_reset_counts(*args)

    def verror_text(*args):
        """verror_text(self, seriousness s, string text)"""
        return _gnuradio_swig_py_runtime.error_handler_verror_text(*args)

error_handler_swigregister = _gnuradio_swig_py_runtime.error_handler_swigregister
error_handler_swigregister(error_handler)

def error_handler_default_handler(*args):
  """error_handler_default_handler() -> error_handler"""
  return _gnuradio_swig_py_runtime.error_handler_default_handler(*args)

def error_handler_silent_handler(*args):
  """error_handler_silent_handler() -> error_handler"""
  return _gnuradio_swig_py_runtime.error_handler_silent_handler(*args)

def error_handler_has_default_handler(*args):
  """error_handler_has_default_handler() -> bool"""
  return _gnuradio_swig_py_runtime.error_handler_has_default_handler(*args)

def error_handler_set_default_handler(*args):
  """error_handler_set_default_handler(error_handler errh)"""
  return _gnuradio_swig_py_runtime.error_handler_set_default_handler(*args)

class file_error_handler(object):
    """Proxy of C++ file_error_handler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, int file_descriptor) -> file_error_handler"""
        this = _gnuradio_swig_py_runtime.new_file_error_handler(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_file_error_handler
    __del__ = lambda self : None;
file_error_handler_swigregister = _gnuradio_swig_py_runtime.file_error_handler_swigregister
file_error_handler_swigregister(file_error_handler)

RT_OK = _gnuradio_swig_py_runtime.RT_OK
RT_NOT_IMPLEMENTED = _gnuradio_swig_py_runtime.RT_NOT_IMPLEMENTED
RT_NO_PRIVS = _gnuradio_swig_py_runtime.RT_NO_PRIVS
RT_OTHER_ERROR = _gnuradio_swig_py_runtime.RT_OTHER_ERROR

def enable_realtime_scheduling(*args):
  """enable_realtime_scheduling() -> gr_rt_status_t"""
  return _gnuradio_swig_py_runtime.enable_realtime_scheduling(*args)
class gr_sync_block(gr_block):
    """Proxy of C++ gr_sync_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_sync_block
    __del__ = lambda self : None;
gr_sync_block_swigregister = _gnuradio_swig_py_runtime.gr_sync_block_swigregister
gr_sync_block_swigregister(gr_sync_block)

class gr_sync_decimator(gr_sync_block):
    """Proxy of C++ gr_sync_decimator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_sync_decimator
    __del__ = lambda self : None;
gr_sync_decimator_swigregister = _gnuradio_swig_py_runtime.gr_sync_decimator_swigregister
gr_sync_decimator_swigregister(gr_sync_decimator)

class gr_sync_interpolator(gr_sync_block):
    """Proxy of C++ gr_sync_interpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_sync_interpolator
    __del__ = lambda self : None;
gr_sync_interpolator_swigregister = _gnuradio_swig_py_runtime.gr_sync_interpolator_swigregister
gr_sync_interpolator_swigregister(gr_sync_interpolator)

class gr_top_block_sptr(object):
    """Proxy of C++ gr_top_block_sptr class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_top_block_sptr
        __init__(self, gr_top_block p) -> gr_top_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_top_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_top_block"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_top_block_sptr
    __del__ = lambda self : None;
    def start(*args):
        """start(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_start(*args)

    def stop(*args):
        """stop(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_stop(*args)

    def wait(*args):
        """wait(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_wait(*args)

    def run(*args):
        """run(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_run(*args)

    def lock(*args):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_lock(*args)

    def unlock(*args):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_unlock(*args)

    def dump(*args):
        """dump(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_dump(*args)

    def connect(*args):
        """
        connect(self, gr_basic_block_sptr block)
        connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_connect(*args)

    def disconnect(*args):
        """
        disconnect(self, gr_basic_block_sptr block)
        disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_disconnect(*args)

    def disconnect_all(*args):
        """disconnect_all(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_disconnect_all(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_unique_id(*args)

    def basic_block(*args):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_basic_block(*args)

    def check_topology(*args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_check_topology(*args)

gr_top_block_sptr_swigregister = _gnuradio_swig_py_runtime.gr_top_block_sptr_swigregister
gr_top_block_sptr_swigregister(gr_top_block_sptr)


def top_block_swig(*args):
  """top_block_swig(string name) -> gr_top_block_sptr"""
  return _gnuradio_swig_py_runtime.top_block_swig(*args)
class gr_top_block(gr_hier_block2):
    """Proxy of C++ gr_top_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_top_block
    __del__ = lambda self : None;
    def start(*args):
        """start(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_start(*args)

    def stop(*args):
        """stop(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_stop(*args)

    def wait(*args):
        """wait(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_wait(*args)

    def run(*args):
        """run(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_run(*args)

    def lock(*args):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_lock(*args)

    def unlock(*args):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_unlock(*args)

    def dump(*args):
        """dump(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_dump(*args)

gr_top_block_swigregister = _gnuradio_swig_py_runtime.gr_top_block_swigregister
gr_top_block_swigregister(gr_top_block)


def top_block_run_unlocked(*args):
  """top_block_run_unlocked(gr_top_block_sptr r)"""
  return _gnuradio_swig_py_runtime.top_block_run_unlocked(*args)

def top_block_wait_unlocked(*args):
  """top_block_wait_unlocked(gr_top_block_sptr r)"""
  return _gnuradio_swig_py_runtime.top_block_wait_unlocked(*args)


